diff --git a/codegen/src/cfg.rs b/codegen/src/cfg.rs
index 5932860f59..f11dc8693d 100644
--- a/codegen/src/cfg.rs
+++ b/codegen/src/cfg.rs
@@ -2,11 +2,28 @@ use proc_macro2::TokenStream;
 use quote::quote;
 use syn_codegen::Features;
 
-pub fn features(features: &Features) -> TokenStream {
+pub fn features<'a>(
+    features: &Features,
+    overriding_cfg: impl Into<Option<&'a str>>,
+) -> TokenStream {
     let features = &features.any;
-    match features.len() {
-        0 => quote!(),
-        1 => quote!(#[cfg(feature = #(#features)*)]),
-        _ => quote!(#[cfg(any(#(feature = #features),*))]),
+    let cfg = match features.len() {
+        0 => None,
+        1 => Some(quote! { cfg(feature = #(#features)*) }),
+        _ => Some(quote! { cfg(any(#(feature = #features),*)) }),
+    };
+    match (cfg, overriding_cfg.into()) {
+        (Some(cfg), Some(overriding_cfg)) => quote! {
+            #[#cfg]
+            #[cfg_attr(doc_cfg, doc(cfg(feature = #overriding_cfg)))]
+        },
+        (Some(cfg), None) => quote! {
+            #[#cfg]
+            #[cfg_attr(doc_cfg, doc(#cfg))]
+        },
+        (None, Some(overriding_cfg)) => quote! {
+            #[cfg_attr(doc_cfg, doc(cfg(feature = #overriding_cfg)))]
+        },
+        (None, None) => TokenStream::new(),
     }
 }
diff --git a/codegen/src/clone.rs b/codegen/src/clone.rs
index 117732bbb4..9db771e781 100644
--- a/codegen/src/clone.rs
+++ b/codegen/src/clone.rs
@@ -76,7 +76,7 @@ fn expand_impl(defs: &Definitions, node: &Node) -> TokenStream {
     }
 
     let ident = Ident::new(&node.ident, Span::call_site());
-    let cfg_features = cfg::features(&node.features);
+    let cfg_features = cfg::features(&node.features, "clone-impls");
 
     let copy = node.ident == "AttrStyle"
         || node.ident == "BinOp"
@@ -86,10 +86,8 @@ fn expand_impl(defs: &Definitions, node: &Node) -> TokenStream {
     if copy {
         return quote! {
             #cfg_features
-            #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
             impl Copy for #ident {}
             #cfg_features
-            #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
             impl Clone for #ident {
                 fn clone(&self) -> Self {
                     *self
@@ -102,7 +100,6 @@ fn expand_impl(defs: &Definitions, node: &Node) -> TokenStream {
 
     quote! {
         #cfg_features
-        #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
         impl Clone for #ident {
             fn clone(&self) -> Self {
                 #body
diff --git a/codegen/src/debug.rs b/codegen/src/debug.rs
index 005d4a05b0..b0f517522e 100644
--- a/codegen/src/debug.rs
+++ b/codegen/src/debug.rs
@@ -147,7 +147,7 @@ fn expand_impl(defs: &Definitions, node: &Node, syntax_tree_variants: &Set<&str>
     }
 
     let ident = Ident::new(&node.ident, Span::call_site());
-    let cfg_features = cfg::features(&node.features);
+    let cfg_features = cfg::features(&node.features, "extra-traits");
     let body = expand_impl_body(defs, node, syntax_tree_variants);
     let formatter = match &node.data {
         Data::Enum(variants) if variants.is_empty() => quote!(_formatter),
@@ -156,7 +156,6 @@ fn expand_impl(defs: &Definitions, node: &Node, syntax_tree_variants: &Set<&str>
 
     quote! {
         #cfg_features
-        #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
         impl Debug for #ident {
             fn fmt(&self, #formatter: &mut fmt::Formatter) -> fmt::Result {
                 #body
diff --git a/codegen/src/eq.rs b/codegen/src/eq.rs
index 4b7b79e33c..d709a90af2 100644
--- a/codegen/src/eq.rs
+++ b/codegen/src/eq.rs
@@ -114,11 +114,10 @@ fn expand_impl(defs: &Definitions, node: &Node) -> TokenStream {
     }
 
     let ident = Ident::new(&node.ident, Span::call_site());
-    let cfg_features = cfg::features(&node.features);
+    let cfg_features = cfg::features(&node.features, "extra-traits");
 
     let eq = quote! {
         #cfg_features
-        #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
         impl Eq for #ident {}
     };
 
@@ -138,7 +137,6 @@ fn expand_impl(defs: &Definitions, node: &Node) -> TokenStream {
         #eq
 
         #cfg_features
-        #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
         impl PartialEq for #ident {
             fn eq(&self, #other: &Self) -> bool {
                 #body
diff --git a/codegen/src/gen.rs b/codegen/src/gen.rs
index 54f6e75b90..57a9b68f32 100644
--- a/codegen/src/gen.rs
+++ b/codegen/src/gen.rs
@@ -27,7 +27,7 @@ pub fn traverse(
     let mut traits = TokenStream::new();
     let mut impls = TokenStream::new();
     for s in types {
-        let features = cfg::features(&s.features);
+        let features = cfg::features(&s.features, None);
         traits.extend(features.clone());
         impls.extend(features);
         node(&mut traits, &mut impls, &s, defs);
diff --git a/codegen/src/hash.rs b/codegen/src/hash.rs
index 323db351ee..c0868e2f09 100644
--- a/codegen/src/hash.rs
+++ b/codegen/src/hash.rs
@@ -123,7 +123,7 @@ fn expand_impl(defs: &Definitions, node: &Node) -> TokenStream {
     }
 
     let ident = Ident::new(&node.ident, Span::call_site());
-    let cfg_features = cfg::features(&node.features);
+    let cfg_features = cfg::features(&node.features, "extra-traits");
 
     let body = expand_impl_body(defs, node);
 
@@ -135,7 +135,6 @@ fn expand_impl(defs: &Definitions, node: &Node) -> TokenStream {
 
     quote! {
         #cfg_features
-        #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
         impl Hash for #ident {
             fn hash<H>(&self, #hasher: &mut H)
             where
diff --git a/src/gen/fold.rs b/src/gen/fold.rs
index a993277e7c..14f4956580 100644
--- a/src/gen/fold.rs
+++ b/src/gen/fold.rs
@@ -30,10 +30,12 @@ macro_rules! full {
 /// [module documentation]: self
 pub trait Fold {
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_abi(&mut self, i: Abi) -> Abi {
         fold_abi(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_angle_bracketed_generic_arguments(
         &mut self,
         i: AngleBracketedGenericArguments,
@@ -41,294 +43,367 @@ pub trait Fold {
         fold_angle_bracketed_generic_arguments(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_arm(&mut self, i: Arm) -> Arm {
         fold_arm(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_assoc_const(&mut self, i: AssocConst) -> AssocConst {
         fold_assoc_const(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_assoc_type(&mut self, i: AssocType) -> AssocType {
         fold_assoc_type(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_attr_style(&mut self, i: AttrStyle) -> AttrStyle {
         fold_attr_style(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_attribute(&mut self, i: Attribute) -> Attribute {
         fold_attribute(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_bare_fn_arg(&mut self, i: BareFnArg) -> BareFnArg {
         fold_bare_fn_arg(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_bare_variadic(&mut self, i: BareVariadic) -> BareVariadic {
         fold_bare_variadic(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_bin_op(&mut self, i: BinOp) -> BinOp {
         fold_bin_op(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_block(&mut self, i: Block) -> Block {
         fold_block(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_bound_lifetimes(&mut self, i: BoundLifetimes) -> BoundLifetimes {
         fold_bound_lifetimes(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_const_param(&mut self, i: ConstParam) -> ConstParam {
         fold_const_param(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_constraint(&mut self, i: Constraint) -> Constraint {
         fold_constraint(self, i)
     }
     #[cfg(feature = "derive")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
     fn fold_data(&mut self, i: Data) -> Data {
         fold_data(self, i)
     }
     #[cfg(feature = "derive")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
     fn fold_data_enum(&mut self, i: DataEnum) -> DataEnum {
         fold_data_enum(self, i)
     }
     #[cfg(feature = "derive")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
     fn fold_data_struct(&mut self, i: DataStruct) -> DataStruct {
         fold_data_struct(self, i)
     }
     #[cfg(feature = "derive")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
     fn fold_data_union(&mut self, i: DataUnion) -> DataUnion {
         fold_data_union(self, i)
     }
     #[cfg(feature = "derive")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
     fn fold_derive_input(&mut self, i: DeriveInput) -> DeriveInput {
         fold_derive_input(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_expr(&mut self, i: Expr) -> Expr {
         fold_expr(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_expr_array(&mut self, i: ExprArray) -> ExprArray {
         fold_expr_array(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_expr_assign(&mut self, i: ExprAssign) -> ExprAssign {
         fold_expr_assign(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_expr_async(&mut self, i: ExprAsync) -> ExprAsync {
         fold_expr_async(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_expr_await(&mut self, i: ExprAwait) -> ExprAwait {
         fold_expr_await(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_expr_binary(&mut self, i: ExprBinary) -> ExprBinary {
         fold_expr_binary(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_expr_block(&mut self, i: ExprBlock) -> ExprBlock {
         fold_expr_block(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_expr_break(&mut self, i: ExprBreak) -> ExprBreak {
         fold_expr_break(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_expr_call(&mut self, i: ExprCall) -> ExprCall {
         fold_expr_call(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_expr_cast(&mut self, i: ExprCast) -> ExprCast {
         fold_expr_cast(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_expr_closure(&mut self, i: ExprClosure) -> ExprClosure {
         fold_expr_closure(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_expr_const(&mut self, i: ExprConst) -> ExprConst {
         fold_expr_const(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_expr_continue(&mut self, i: ExprContinue) -> ExprContinue {
         fold_expr_continue(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_expr_field(&mut self, i: ExprField) -> ExprField {
         fold_expr_field(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_expr_for_loop(&mut self, i: ExprForLoop) -> ExprForLoop {
         fold_expr_for_loop(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_expr_group(&mut self, i: ExprGroup) -> ExprGroup {
         fold_expr_group(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_expr_if(&mut self, i: ExprIf) -> ExprIf {
         fold_expr_if(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_expr_index(&mut self, i: ExprIndex) -> ExprIndex {
         fold_expr_index(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_expr_infer(&mut self, i: ExprInfer) -> ExprInfer {
         fold_expr_infer(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_expr_let(&mut self, i: ExprLet) -> ExprLet {
         fold_expr_let(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_expr_lit(&mut self, i: ExprLit) -> ExprLit {
         fold_expr_lit(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_expr_loop(&mut self, i: ExprLoop) -> ExprLoop {
         fold_expr_loop(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_expr_macro(&mut self, i: ExprMacro) -> ExprMacro {
         fold_expr_macro(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_expr_match(&mut self, i: ExprMatch) -> ExprMatch {
         fold_expr_match(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_expr_method_call(&mut self, i: ExprMethodCall) -> ExprMethodCall {
         fold_expr_method_call(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_expr_paren(&mut self, i: ExprParen) -> ExprParen {
         fold_expr_paren(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_expr_path(&mut self, i: ExprPath) -> ExprPath {
         fold_expr_path(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_expr_range(&mut self, i: ExprRange) -> ExprRange {
         fold_expr_range(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_expr_reference(&mut self, i: ExprReference) -> ExprReference {
         fold_expr_reference(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_expr_repeat(&mut self, i: ExprRepeat) -> ExprRepeat {
         fold_expr_repeat(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_expr_return(&mut self, i: ExprReturn) -> ExprReturn {
         fold_expr_return(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_expr_struct(&mut self, i: ExprStruct) -> ExprStruct {
         fold_expr_struct(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_expr_try(&mut self, i: ExprTry) -> ExprTry {
         fold_expr_try(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_expr_try_block(&mut self, i: ExprTryBlock) -> ExprTryBlock {
         fold_expr_try_block(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_expr_tuple(&mut self, i: ExprTuple) -> ExprTuple {
         fold_expr_tuple(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_expr_unary(&mut self, i: ExprUnary) -> ExprUnary {
         fold_expr_unary(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_expr_unsafe(&mut self, i: ExprUnsafe) -> ExprUnsafe {
         fold_expr_unsafe(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_expr_while(&mut self, i: ExprWhile) -> ExprWhile {
         fold_expr_while(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_expr_yield(&mut self, i: ExprYield) -> ExprYield {
         fold_expr_yield(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_field(&mut self, i: Field) -> Field {
         fold_field(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_field_mutability(&mut self, i: FieldMutability) -> FieldMutability {
         fold_field_mutability(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_field_pat(&mut self, i: FieldPat) -> FieldPat {
         fold_field_pat(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_field_value(&mut self, i: FieldValue) -> FieldValue {
         fold_field_value(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_fields(&mut self, i: Fields) -> Fields {
         fold_fields(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_fields_named(&mut self, i: FieldsNamed) -> FieldsNamed {
         fold_fields_named(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_fields_unnamed(&mut self, i: FieldsUnnamed) -> FieldsUnnamed {
         fold_fields_unnamed(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_file(&mut self, i: File) -> File {
         fold_file(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_fn_arg(&mut self, i: FnArg) -> FnArg {
         fold_fn_arg(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_foreign_item(&mut self, i: ForeignItem) -> ForeignItem {
         fold_foreign_item(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_foreign_item_fn(&mut self, i: ForeignItemFn) -> ForeignItemFn {
         fold_foreign_item_fn(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_foreign_item_macro(&mut self, i: ForeignItemMacro) -> ForeignItemMacro {
         fold_foreign_item_macro(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_foreign_item_static(&mut self, i: ForeignItemStatic) -> ForeignItemStatic {
         fold_foreign_item_static(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_foreign_item_type(&mut self, i: ForeignItemType) -> ForeignItemType {
         fold_foreign_item_type(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_generic_argument(&mut self, i: GenericArgument) -> GenericArgument {
         fold_generic_argument(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_generic_param(&mut self, i: GenericParam) -> GenericParam {
         fold_generic_param(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_generics(&mut self, i: Generics) -> Generics {
         fold_generics(self, i)
     }
@@ -336,98 +411,122 @@ pub trait Fold {
         fold_ident(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_impl_item(&mut self, i: ImplItem) -> ImplItem {
         fold_impl_item(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_impl_item_const(&mut self, i: ImplItemConst) -> ImplItemConst {
         fold_impl_item_const(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_impl_item_fn(&mut self, i: ImplItemFn) -> ImplItemFn {
         fold_impl_item_fn(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_impl_item_macro(&mut self, i: ImplItemMacro) -> ImplItemMacro {
         fold_impl_item_macro(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_impl_item_type(&mut self, i: ImplItemType) -> ImplItemType {
         fold_impl_item_type(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_impl_restriction(&mut self, i: ImplRestriction) -> ImplRestriction {
         fold_impl_restriction(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_index(&mut self, i: Index) -> Index {
         fold_index(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_item(&mut self, i: Item) -> Item {
         fold_item(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_item_const(&mut self, i: ItemConst) -> ItemConst {
         fold_item_const(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_item_enum(&mut self, i: ItemEnum) -> ItemEnum {
         fold_item_enum(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_item_extern_crate(&mut self, i: ItemExternCrate) -> ItemExternCrate {
         fold_item_extern_crate(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_item_fn(&mut self, i: ItemFn) -> ItemFn {
         fold_item_fn(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_item_foreign_mod(&mut self, i: ItemForeignMod) -> ItemForeignMod {
         fold_item_foreign_mod(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_item_impl(&mut self, i: ItemImpl) -> ItemImpl {
         fold_item_impl(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_item_macro(&mut self, i: ItemMacro) -> ItemMacro {
         fold_item_macro(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_item_mod(&mut self, i: ItemMod) -> ItemMod {
         fold_item_mod(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_item_static(&mut self, i: ItemStatic) -> ItemStatic {
         fold_item_static(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_item_struct(&mut self, i: ItemStruct) -> ItemStruct {
         fold_item_struct(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_item_trait(&mut self, i: ItemTrait) -> ItemTrait {
         fold_item_trait(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_item_trait_alias(&mut self, i: ItemTraitAlias) -> ItemTraitAlias {
         fold_item_trait_alias(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_item_type(&mut self, i: ItemType) -> ItemType {
         fold_item_type(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_item_union(&mut self, i: ItemUnion) -> ItemUnion {
         fold_item_union(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_item_use(&mut self, i: ItemUse) -> ItemUse {
         fold_item_use(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_label(&mut self, i: Label) -> Label {
         fold_label(self, i)
     }
@@ -435,6 +534,7 @@ pub trait Fold {
         fold_lifetime(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_lifetime_param(&mut self, i: LifetimeParam) -> LifetimeParam {
         fold_lifetime_param(self, i)
     }
@@ -463,38 +563,47 @@ pub trait Fold {
         fold_lit_str(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_local(&mut self, i: Local) -> Local {
         fold_local(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_local_init(&mut self, i: LocalInit) -> LocalInit {
         fold_local_init(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_macro(&mut self, i: Macro) -> Macro {
         fold_macro(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_macro_delimiter(&mut self, i: MacroDelimiter) -> MacroDelimiter {
         fold_macro_delimiter(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_member(&mut self, i: Member) -> Member {
         fold_member(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_meta(&mut self, i: Meta) -> Meta {
         fold_meta(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_meta_list(&mut self, i: MetaList) -> MetaList {
         fold_meta_list(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_meta_name_value(&mut self, i: MetaNameValue) -> MetaNameValue {
         fold_meta_name_value(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_parenthesized_generic_arguments(
         &mut self,
         i: ParenthesizedGenericArguments,
@@ -502,90 +611,112 @@ pub trait Fold {
         fold_parenthesized_generic_arguments(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_pat(&mut self, i: Pat) -> Pat {
         fold_pat(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_pat_ident(&mut self, i: PatIdent) -> PatIdent {
         fold_pat_ident(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_pat_or(&mut self, i: PatOr) -> PatOr {
         fold_pat_or(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_pat_paren(&mut self, i: PatParen) -> PatParen {
         fold_pat_paren(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_pat_reference(&mut self, i: PatReference) -> PatReference {
         fold_pat_reference(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_pat_rest(&mut self, i: PatRest) -> PatRest {
         fold_pat_rest(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_pat_slice(&mut self, i: PatSlice) -> PatSlice {
         fold_pat_slice(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_pat_struct(&mut self, i: PatStruct) -> PatStruct {
         fold_pat_struct(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_pat_tuple(&mut self, i: PatTuple) -> PatTuple {
         fold_pat_tuple(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_pat_tuple_struct(&mut self, i: PatTupleStruct) -> PatTupleStruct {
         fold_pat_tuple_struct(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_pat_type(&mut self, i: PatType) -> PatType {
         fold_pat_type(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_pat_wild(&mut self, i: PatWild) -> PatWild {
         fold_pat_wild(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_path(&mut self, i: Path) -> Path {
         fold_path(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_path_arguments(&mut self, i: PathArguments) -> PathArguments {
         fold_path_arguments(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_path_segment(&mut self, i: PathSegment) -> PathSegment {
         fold_path_segment(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_predicate_lifetime(&mut self, i: PredicateLifetime) -> PredicateLifetime {
         fold_predicate_lifetime(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_predicate_type(&mut self, i: PredicateType) -> PredicateType {
         fold_predicate_type(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_qself(&mut self, i: QSelf) -> QSelf {
         fold_qself(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_range_limits(&mut self, i: RangeLimits) -> RangeLimits {
         fold_range_limits(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_receiver(&mut self, i: Receiver) -> Receiver {
         fold_receiver(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_return_type(&mut self, i: ReturnType) -> ReturnType {
         fold_return_type(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_signature(&mut self, i: Signature) -> Signature {
         fold_signature(self, i)
     }
@@ -593,22 +724,27 @@ pub trait Fold {
         fold_span(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_static_mutability(&mut self, i: StaticMutability) -> StaticMutability {
         fold_static_mutability(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_stmt(&mut self, i: Stmt) -> Stmt {
         fold_stmt(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_stmt_macro(&mut self, i: StmtMacro) -> StmtMacro {
         fold_stmt_macro(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_trait_bound(&mut self, i: TraitBound) -> TraitBound {
         fold_trait_bound(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_trait_bound_modifier(
         &mut self,
         i: TraitBoundModifier,
@@ -616,147 +752,183 @@ pub trait Fold {
         fold_trait_bound_modifier(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_trait_item(&mut self, i: TraitItem) -> TraitItem {
         fold_trait_item(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_trait_item_const(&mut self, i: TraitItemConst) -> TraitItemConst {
         fold_trait_item_const(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_trait_item_fn(&mut self, i: TraitItemFn) -> TraitItemFn {
         fold_trait_item_fn(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_trait_item_macro(&mut self, i: TraitItemMacro) -> TraitItemMacro {
         fold_trait_item_macro(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_trait_item_type(&mut self, i: TraitItemType) -> TraitItemType {
         fold_trait_item_type(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_type(&mut self, i: Type) -> Type {
         fold_type(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_type_array(&mut self, i: TypeArray) -> TypeArray {
         fold_type_array(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_type_bare_fn(&mut self, i: TypeBareFn) -> TypeBareFn {
         fold_type_bare_fn(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_type_group(&mut self, i: TypeGroup) -> TypeGroup {
         fold_type_group(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_type_impl_trait(&mut self, i: TypeImplTrait) -> TypeImplTrait {
         fold_type_impl_trait(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_type_infer(&mut self, i: TypeInfer) -> TypeInfer {
         fold_type_infer(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_type_macro(&mut self, i: TypeMacro) -> TypeMacro {
         fold_type_macro(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_type_never(&mut self, i: TypeNever) -> TypeNever {
         fold_type_never(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_type_param(&mut self, i: TypeParam) -> TypeParam {
         fold_type_param(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_type_param_bound(&mut self, i: TypeParamBound) -> TypeParamBound {
         fold_type_param_bound(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_type_paren(&mut self, i: TypeParen) -> TypeParen {
         fold_type_paren(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_type_path(&mut self, i: TypePath) -> TypePath {
         fold_type_path(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_type_ptr(&mut self, i: TypePtr) -> TypePtr {
         fold_type_ptr(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_type_reference(&mut self, i: TypeReference) -> TypeReference {
         fold_type_reference(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_type_slice(&mut self, i: TypeSlice) -> TypeSlice {
         fold_type_slice(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_type_trait_object(&mut self, i: TypeTraitObject) -> TypeTraitObject {
         fold_type_trait_object(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_type_tuple(&mut self, i: TypeTuple) -> TypeTuple {
         fold_type_tuple(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_un_op(&mut self, i: UnOp) -> UnOp {
         fold_un_op(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_use_glob(&mut self, i: UseGlob) -> UseGlob {
         fold_use_glob(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_use_group(&mut self, i: UseGroup) -> UseGroup {
         fold_use_group(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_use_name(&mut self, i: UseName) -> UseName {
         fold_use_name(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_use_path(&mut self, i: UsePath) -> UsePath {
         fold_use_path(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_use_rename(&mut self, i: UseRename) -> UseRename {
         fold_use_rename(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_use_tree(&mut self, i: UseTree) -> UseTree {
         fold_use_tree(self, i)
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn fold_variadic(&mut self, i: Variadic) -> Variadic {
         fold_variadic(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_variant(&mut self, i: Variant) -> Variant {
         fold_variant(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_vis_restricted(&mut self, i: VisRestricted) -> VisRestricted {
         fold_vis_restricted(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_visibility(&mut self, i: Visibility) -> Visibility {
         fold_visibility(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_where_clause(&mut self, i: WhereClause) -> WhereClause {
         fold_where_clause(self, i)
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn fold_where_predicate(&mut self, i: WherePredicate) -> WherePredicate {
         fold_where_predicate(self, i)
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_abi<F>(f: &mut F, node: Abi) -> Abi
 where
     F: Fold + ?Sized,
@@ -767,6 +939,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_angle_bracketed_generic_arguments<F>(
     f: &mut F,
     node: AngleBracketedGenericArguments,
@@ -782,6 +955,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_arm<F>(f: &mut F, node: Arm) -> Arm
 where
     F: Fold + ?Sized,
@@ -796,6 +970,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_assoc_const<F>(f: &mut F, node: AssocConst) -> AssocConst
 where
     F: Fold + ?Sized,
@@ -808,6 +983,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_assoc_type<F>(f: &mut F, node: AssocType) -> AssocType
 where
     F: Fold + ?Sized,
@@ -820,6 +996,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_attr_style<F>(f: &mut F, node: AttrStyle) -> AttrStyle
 where
     F: Fold + ?Sized,
@@ -830,6 +1007,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_attribute<F>(f: &mut F, node: Attribute) -> Attribute
 where
     F: Fold + ?Sized,
@@ -842,6 +1020,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_bare_fn_arg<F>(f: &mut F, node: BareFnArg) -> BareFnArg
 where
     F: Fold + ?Sized,
@@ -853,6 +1032,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_bare_variadic<F>(f: &mut F, node: BareVariadic) -> BareVariadic
 where
     F: Fold + ?Sized,
@@ -865,6 +1045,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_bin_op<F>(f: &mut F, node: BinOp) -> BinOp
 where
     F: Fold + ?Sized,
@@ -901,6 +1082,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_block<F>(f: &mut F, node: Block) -> Block
 where
     F: Fold + ?Sized,
@@ -911,6 +1093,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_bound_lifetimes<F>(f: &mut F, node: BoundLifetimes) -> BoundLifetimes
 where
     F: Fold + ?Sized,
@@ -923,6 +1106,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_const_param<F>(f: &mut F, node: ConstParam) -> ConstParam
 where
     F: Fold + ?Sized,
@@ -938,6 +1122,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_constraint<F>(f: &mut F, node: Constraint) -> Constraint
 where
     F: Fold + ?Sized,
@@ -950,6 +1135,7 @@ where
     }
 }
 #[cfg(feature = "derive")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
 pub fn fold_data<F>(f: &mut F, node: Data) -> Data
 where
     F: Fold + ?Sized,
@@ -961,6 +1147,7 @@ where
     }
 }
 #[cfg(feature = "derive")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
 pub fn fold_data_enum<F>(f: &mut F, node: DataEnum) -> DataEnum
 where
     F: Fold + ?Sized,
@@ -972,6 +1159,7 @@ where
     }
 }
 #[cfg(feature = "derive")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
 pub fn fold_data_struct<F>(f: &mut F, node: DataStruct) -> DataStruct
 where
     F: Fold + ?Sized,
@@ -983,6 +1171,7 @@ where
     }
 }
 #[cfg(feature = "derive")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
 pub fn fold_data_union<F>(f: &mut F, node: DataUnion) -> DataUnion
 where
     F: Fold + ?Sized,
@@ -993,6 +1182,7 @@ where
     }
 }
 #[cfg(feature = "derive")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
 pub fn fold_derive_input<F>(f: &mut F, node: DeriveInput) -> DeriveInput
 where
     F: Fold + ?Sized,
@@ -1006,6 +1196,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_expr<F>(f: &mut F, node: Expr) -> Expr
 where
     F: Fold + ?Sized,
@@ -1063,6 +1254,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_expr_array<F>(f: &mut F, node: ExprArray) -> ExprArray
 where
     F: Fold + ?Sized,
@@ -1074,6 +1266,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_expr_assign<F>(f: &mut F, node: ExprAssign) -> ExprAssign
 where
     F: Fold + ?Sized,
@@ -1086,6 +1279,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_expr_async<F>(f: &mut F, node: ExprAsync) -> ExprAsync
 where
     F: Fold + ?Sized,
@@ -1098,6 +1292,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_expr_await<F>(f: &mut F, node: ExprAwait) -> ExprAwait
 where
     F: Fold + ?Sized,
@@ -1110,6 +1305,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_expr_binary<F>(f: &mut F, node: ExprBinary) -> ExprBinary
 where
     F: Fold + ?Sized,
@@ -1122,6 +1318,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_expr_block<F>(f: &mut F, node: ExprBlock) -> ExprBlock
 where
     F: Fold + ?Sized,
@@ -1133,6 +1330,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_expr_break<F>(f: &mut F, node: ExprBreak) -> ExprBreak
 where
     F: Fold + ?Sized,
@@ -1145,6 +1343,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_expr_call<F>(f: &mut F, node: ExprCall) -> ExprCall
 where
     F: Fold + ?Sized,
@@ -1157,6 +1356,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_expr_cast<F>(f: &mut F, node: ExprCast) -> ExprCast
 where
     F: Fold + ?Sized,
@@ -1169,6 +1369,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_expr_closure<F>(f: &mut F, node: ExprClosure) -> ExprClosure
 where
     F: Fold + ?Sized,
@@ -1188,6 +1389,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_expr_const<F>(f: &mut F, node: ExprConst) -> ExprConst
 where
     F: Fold + ?Sized,
@@ -1199,6 +1401,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_expr_continue<F>(f: &mut F, node: ExprContinue) -> ExprContinue
 where
     F: Fold + ?Sized,
@@ -1210,6 +1413,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_expr_field<F>(f: &mut F, node: ExprField) -> ExprField
 where
     F: Fold + ?Sized,
@@ -1222,6 +1426,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_expr_for_loop<F>(f: &mut F, node: ExprForLoop) -> ExprForLoop
 where
     F: Fold + ?Sized,
@@ -1237,6 +1442,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_expr_group<F>(f: &mut F, node: ExprGroup) -> ExprGroup
 where
     F: Fold + ?Sized,
@@ -1248,6 +1454,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_expr_if<F>(f: &mut F, node: ExprIf) -> ExprIf
 where
     F: Fold + ?Sized,
@@ -1262,6 +1469,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_expr_index<F>(f: &mut F, node: ExprIndex) -> ExprIndex
 where
     F: Fold + ?Sized,
@@ -1274,6 +1482,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_expr_infer<F>(f: &mut F, node: ExprInfer) -> ExprInfer
 where
     F: Fold + ?Sized,
@@ -1284,6 +1493,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_expr_let<F>(f: &mut F, node: ExprLet) -> ExprLet
 where
     F: Fold + ?Sized,
@@ -1297,6 +1507,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_expr_lit<F>(f: &mut F, node: ExprLit) -> ExprLit
 where
     F: Fold + ?Sized,
@@ -1307,6 +1518,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_expr_loop<F>(f: &mut F, node: ExprLoop) -> ExprLoop
 where
     F: Fold + ?Sized,
@@ -1319,6 +1531,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_expr_macro<F>(f: &mut F, node: ExprMacro) -> ExprMacro
 where
     F: Fold + ?Sized,
@@ -1329,6 +1542,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_expr_match<F>(f: &mut F, node: ExprMatch) -> ExprMatch
 where
     F: Fold + ?Sized,
@@ -1342,6 +1556,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_expr_method_call<F>(f: &mut F, node: ExprMethodCall) -> ExprMethodCall
 where
     F: Fold + ?Sized,
@@ -1358,6 +1573,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_expr_paren<F>(f: &mut F, node: ExprParen) -> ExprParen
 where
     F: Fold + ?Sized,
@@ -1369,6 +1585,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_expr_path<F>(f: &mut F, node: ExprPath) -> ExprPath
 where
     F: Fold + ?Sized,
@@ -1380,6 +1597,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_expr_range<F>(f: &mut F, node: ExprRange) -> ExprRange
 where
     F: Fold + ?Sized,
@@ -1392,6 +1610,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_expr_reference<F>(f: &mut F, node: ExprReference) -> ExprReference
 where
     F: Fold + ?Sized,
@@ -1404,6 +1623,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_expr_repeat<F>(f: &mut F, node: ExprRepeat) -> ExprRepeat
 where
     F: Fold + ?Sized,
@@ -1417,6 +1637,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_expr_return<F>(f: &mut F, node: ExprReturn) -> ExprReturn
 where
     F: Fold + ?Sized,
@@ -1428,6 +1649,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_expr_struct<F>(f: &mut F, node: ExprStruct) -> ExprStruct
 where
     F: Fold + ?Sized,
@@ -1443,6 +1665,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_expr_try<F>(f: &mut F, node: ExprTry) -> ExprTry
 where
     F: Fold + ?Sized,
@@ -1454,6 +1677,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_expr_try_block<F>(f: &mut F, node: ExprTryBlock) -> ExprTryBlock
 where
     F: Fold + ?Sized,
@@ -1465,6 +1689,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_expr_tuple<F>(f: &mut F, node: ExprTuple) -> ExprTuple
 where
     F: Fold + ?Sized,
@@ -1476,6 +1701,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_expr_unary<F>(f: &mut F, node: ExprUnary) -> ExprUnary
 where
     F: Fold + ?Sized,
@@ -1487,6 +1713,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_expr_unsafe<F>(f: &mut F, node: ExprUnsafe) -> ExprUnsafe
 where
     F: Fold + ?Sized,
@@ -1498,6 +1725,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_expr_while<F>(f: &mut F, node: ExprWhile) -> ExprWhile
 where
     F: Fold + ?Sized,
@@ -1511,6 +1739,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_expr_yield<F>(f: &mut F, node: ExprYield) -> ExprYield
 where
     F: Fold + ?Sized,
@@ -1522,6 +1751,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_field<F>(f: &mut F, node: Field) -> Field
 where
     F: Fold + ?Sized,
@@ -1536,6 +1766,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_field_mutability<F>(f: &mut F, node: FieldMutability) -> FieldMutability
 where
     F: Fold + ?Sized,
@@ -1545,6 +1776,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_field_pat<F>(f: &mut F, node: FieldPat) -> FieldPat
 where
     F: Fold + ?Sized,
@@ -1557,6 +1789,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_field_value<F>(f: &mut F, node: FieldValue) -> FieldValue
 where
     F: Fold + ?Sized,
@@ -1569,6 +1802,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_fields<F>(f: &mut F, node: Fields) -> Fields
 where
     F: Fold + ?Sized,
@@ -1580,6 +1814,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_fields_named<F>(f: &mut F, node: FieldsNamed) -> FieldsNamed
 where
     F: Fold + ?Sized,
@@ -1590,6 +1825,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_fields_unnamed<F>(f: &mut F, node: FieldsUnnamed) -> FieldsUnnamed
 where
     F: Fold + ?Sized,
@@ -1600,6 +1836,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_file<F>(f: &mut F, node: File) -> File
 where
     F: Fold + ?Sized,
@@ -1611,6 +1848,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_fn_arg<F>(f: &mut F, node: FnArg) -> FnArg
 where
     F: Fold + ?Sized,
@@ -1621,6 +1859,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_foreign_item<F>(f: &mut F, node: ForeignItem) -> ForeignItem
 where
     F: Fold + ?Sized,
@@ -1642,6 +1881,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_foreign_item_fn<F>(f: &mut F, node: ForeignItemFn) -> ForeignItemFn
 where
     F: Fold + ?Sized,
@@ -1654,6 +1894,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_foreign_item_macro<F>(f: &mut F, node: ForeignItemMacro) -> ForeignItemMacro
 where
     F: Fold + ?Sized,
@@ -1665,6 +1906,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_foreign_item_static<F>(
     f: &mut F,
     node: ForeignItemStatic,
@@ -1684,6 +1926,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_foreign_item_type<F>(f: &mut F, node: ForeignItemType) -> ForeignItemType
 where
     F: Fold + ?Sized,
@@ -1698,6 +1941,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_generic_argument<F>(f: &mut F, node: GenericArgument) -> GenericArgument
 where
     F: Fold + ?Sized,
@@ -1724,6 +1968,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_generic_param<F>(f: &mut F, node: GenericParam) -> GenericParam
 where
     F: Fold + ?Sized,
@@ -1741,6 +1986,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_generics<F>(f: &mut F, node: Generics) -> Generics
 where
     F: Fold + ?Sized,
@@ -1762,6 +2008,7 @@ where
     node
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_impl_item<F>(f: &mut F, node: ImplItem) -> ImplItem
 where
     F: Fold + ?Sized,
@@ -1779,6 +2026,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_impl_item_const<F>(f: &mut F, node: ImplItemConst) -> ImplItemConst
 where
     F: Fold + ?Sized,
@@ -1798,6 +2046,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_impl_item_fn<F>(f: &mut F, node: ImplItemFn) -> ImplItemFn
 where
     F: Fold + ?Sized,
@@ -1811,6 +2060,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_impl_item_macro<F>(f: &mut F, node: ImplItemMacro) -> ImplItemMacro
 where
     F: Fold + ?Sized,
@@ -1822,6 +2072,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_impl_item_type<F>(f: &mut F, node: ImplItemType) -> ImplItemType
 where
     F: Fold + ?Sized,
@@ -1839,6 +2090,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_impl_restriction<F>(f: &mut F, node: ImplRestriction) -> ImplRestriction
 where
     F: Fold + ?Sized,
@@ -1846,6 +2098,7 @@ where
     match node {}
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_index<F>(f: &mut F, node: Index) -> Index
 where
     F: Fold + ?Sized,
@@ -1856,6 +2109,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_item<F>(f: &mut F, node: Item) -> Item
 where
     F: Fold + ?Sized,
@@ -1886,6 +2140,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_item_const<F>(f: &mut F, node: ItemConst) -> ItemConst
 where
     F: Fold + ?Sized,
@@ -1904,6 +2159,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_item_enum<F>(f: &mut F, node: ItemEnum) -> ItemEnum
 where
     F: Fold + ?Sized,
@@ -1919,6 +2175,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_item_extern_crate<F>(f: &mut F, node: ItemExternCrate) -> ItemExternCrate
 where
     F: Fold + ?Sized,
@@ -1934,6 +2191,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_item_fn<F>(f: &mut F, node: ItemFn) -> ItemFn
 where
     F: Fold + ?Sized,
@@ -1946,6 +2204,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_item_foreign_mod<F>(f: &mut F, node: ItemForeignMod) -> ItemForeignMod
 where
     F: Fold + ?Sized,
@@ -1959,6 +2218,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_item_impl<F>(f: &mut F, node: ItemImpl) -> ItemImpl
 where
     F: Fold + ?Sized,
@@ -1976,6 +2236,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_item_macro<F>(f: &mut F, node: ItemMacro) -> ItemMacro
 where
     F: Fold + ?Sized,
@@ -1988,6 +2249,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_item_mod<F>(f: &mut F, node: ItemMod) -> ItemMod
 where
     F: Fold + ?Sized,
@@ -2004,6 +2266,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_item_static<F>(f: &mut F, node: ItemStatic) -> ItemStatic
 where
     F: Fold + ?Sized,
@@ -2022,6 +2285,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_item_struct<F>(f: &mut F, node: ItemStruct) -> ItemStruct
 where
     F: Fold + ?Sized,
@@ -2037,6 +2301,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_item_trait<F>(f: &mut F, node: ItemTrait) -> ItemTrait
 where
     F: Fold + ?Sized,
@@ -2060,6 +2325,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_item_trait_alias<F>(f: &mut F, node: ItemTraitAlias) -> ItemTraitAlias
 where
     F: Fold + ?Sized,
@@ -2076,6 +2342,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_item_type<F>(f: &mut F, node: ItemType) -> ItemType
 where
     F: Fold + ?Sized,
@@ -2092,6 +2359,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_item_union<F>(f: &mut F, node: ItemUnion) -> ItemUnion
 where
     F: Fold + ?Sized,
@@ -2106,6 +2374,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_item_use<F>(f: &mut F, node: ItemUse) -> ItemUse
 where
     F: Fold + ?Sized,
@@ -2120,6 +2389,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_label<F>(f: &mut F, node: Label) -> Label
 where
     F: Fold + ?Sized,
@@ -2139,6 +2409,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_lifetime_param<F>(f: &mut F, node: LifetimeParam) -> LifetimeParam
 where
     F: Fold + ?Sized,
@@ -2229,6 +2500,7 @@ where
     node
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_local<F>(f: &mut F, node: Local) -> Local
 where
     F: Fold + ?Sized,
@@ -2242,6 +2514,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_local_init<F>(f: &mut F, node: LocalInit) -> LocalInit
 where
     F: Fold + ?Sized,
@@ -2253,6 +2526,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_macro<F>(f: &mut F, node: Macro) -> Macro
 where
     F: Fold + ?Sized,
@@ -2265,6 +2539,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_macro_delimiter<F>(f: &mut F, node: MacroDelimiter) -> MacroDelimiter
 where
     F: Fold + ?Sized,
@@ -2276,6 +2551,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_member<F>(f: &mut F, node: Member) -> Member
 where
     F: Fold + ?Sized,
@@ -2286,6 +2562,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_meta<F>(f: &mut F, node: Meta) -> Meta
 where
     F: Fold + ?Sized,
@@ -2299,6 +2576,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_meta_list<F>(f: &mut F, node: MetaList) -> MetaList
 where
     F: Fold + ?Sized,
@@ -2310,6 +2588,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_meta_name_value<F>(f: &mut F, node: MetaNameValue) -> MetaNameValue
 where
     F: Fold + ?Sized,
@@ -2321,6 +2600,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_parenthesized_generic_arguments<F>(
     f: &mut F,
     node: ParenthesizedGenericArguments,
@@ -2335,6 +2615,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_pat<F>(f: &mut F, node: Pat) -> Pat
 where
     F: Fold + ?Sized,
@@ -2362,6 +2643,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_pat_ident<F>(f: &mut F, node: PatIdent) -> PatIdent
 where
     F: Fold + ?Sized,
@@ -2375,6 +2657,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_pat_or<F>(f: &mut F, node: PatOr) -> PatOr
 where
     F: Fold + ?Sized,
@@ -2386,6 +2669,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_pat_paren<F>(f: &mut F, node: PatParen) -> PatParen
 where
     F: Fold + ?Sized,
@@ -2397,6 +2681,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_pat_reference<F>(f: &mut F, node: PatReference) -> PatReference
 where
     F: Fold + ?Sized,
@@ -2409,6 +2694,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_pat_rest<F>(f: &mut F, node: PatRest) -> PatRest
 where
     F: Fold + ?Sized,
@@ -2419,6 +2705,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_pat_slice<F>(f: &mut F, node: PatSlice) -> PatSlice
 where
     F: Fold + ?Sized,
@@ -2430,6 +2717,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_pat_struct<F>(f: &mut F, node: PatStruct) -> PatStruct
 where
     F: Fold + ?Sized,
@@ -2444,6 +2732,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_pat_tuple<F>(f: &mut F, node: PatTuple) -> PatTuple
 where
     F: Fold + ?Sized,
@@ -2455,6 +2744,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_pat_tuple_struct<F>(f: &mut F, node: PatTupleStruct) -> PatTupleStruct
 where
     F: Fold + ?Sized,
@@ -2468,6 +2758,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_pat_type<F>(f: &mut F, node: PatType) -> PatType
 where
     F: Fold + ?Sized,
@@ -2480,6 +2771,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_pat_wild<F>(f: &mut F, node: PatWild) -> PatWild
 where
     F: Fold + ?Sized,
@@ -2490,6 +2782,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_path<F>(f: &mut F, node: Path) -> Path
 where
     F: Fold + ?Sized,
@@ -2500,6 +2793,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_path_arguments<F>(f: &mut F, node: PathArguments) -> PathArguments
 where
     F: Fold + ?Sized,
@@ -2519,6 +2813,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_path_segment<F>(f: &mut F, node: PathSegment) -> PathSegment
 where
     F: Fold + ?Sized,
@@ -2529,6 +2824,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_predicate_lifetime<F>(
     f: &mut F,
     node: PredicateLifetime,
@@ -2543,6 +2839,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_predicate_type<F>(f: &mut F, node: PredicateType) -> PredicateType
 where
     F: Fold + ?Sized,
@@ -2555,6 +2852,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_qself<F>(f: &mut F, node: QSelf) -> QSelf
 where
     F: Fold + ?Sized,
@@ -2568,6 +2866,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_range_limits<F>(f: &mut F, node: RangeLimits) -> RangeLimits
 where
     F: Fold + ?Sized,
@@ -2578,6 +2877,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_receiver<F>(f: &mut F, node: Receiver) -> Receiver
 where
     F: Fold + ?Sized,
@@ -2593,6 +2893,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_return_type<F>(f: &mut F, node: ReturnType) -> ReturnType
 where
     F: Fold + ?Sized,
@@ -2605,6 +2906,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_signature<F>(f: &mut F, node: Signature) -> Signature
 where
     F: Fold + ?Sized,
@@ -2630,6 +2932,7 @@ where
     node
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_static_mutability<F>(f: &mut F, node: StaticMutability) -> StaticMutability
 where
     F: Fold + ?Sized,
@@ -2640,6 +2943,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_stmt<F>(f: &mut F, node: Stmt) -> Stmt
 where
     F: Fold + ?Sized,
@@ -2654,6 +2958,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_stmt_macro<F>(f: &mut F, node: StmtMacro) -> StmtMacro
 where
     F: Fold + ?Sized,
@@ -2665,6 +2970,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_trait_bound<F>(f: &mut F, node: TraitBound) -> TraitBound
 where
     F: Fold + ?Sized,
@@ -2677,6 +2983,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_trait_bound_modifier<F>(
     f: &mut F,
     node: TraitBoundModifier,
@@ -2690,6 +2997,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_trait_item<F>(f: &mut F, node: TraitItem) -> TraitItem
 where
     F: Fold + ?Sized,
@@ -2709,6 +3017,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_trait_item_const<F>(f: &mut F, node: TraitItemConst) -> TraitItemConst
 where
     F: Fold + ?Sized,
@@ -2725,6 +3034,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_trait_item_fn<F>(f: &mut F, node: TraitItemFn) -> TraitItemFn
 where
     F: Fold + ?Sized,
@@ -2737,6 +3047,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_trait_item_macro<F>(f: &mut F, node: TraitItemMacro) -> TraitItemMacro
 where
     F: Fold + ?Sized,
@@ -2748,6 +3059,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_trait_item_type<F>(f: &mut F, node: TraitItemType) -> TraitItemType
 where
     F: Fold + ?Sized,
@@ -2764,6 +3076,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_type<F>(f: &mut F, node: Type) -> Type
 where
     F: Fold + ?Sized,
@@ -2791,6 +3104,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_type_array<F>(f: &mut F, node: TypeArray) -> TypeArray
 where
     F: Fold + ?Sized,
@@ -2803,6 +3117,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_type_bare_fn<F>(f: &mut F, node: TypeBareFn) -> TypeBareFn
 where
     F: Fold + ?Sized,
@@ -2819,6 +3134,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_type_group<F>(f: &mut F, node: TypeGroup) -> TypeGroup
 where
     F: Fold + ?Sized,
@@ -2829,6 +3145,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_type_impl_trait<F>(f: &mut F, node: TypeImplTrait) -> TypeImplTrait
 where
     F: Fold + ?Sized,
@@ -2839,6 +3156,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_type_infer<F>(f: &mut F, node: TypeInfer) -> TypeInfer
 where
     F: Fold + ?Sized,
@@ -2848,6 +3166,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_type_macro<F>(f: &mut F, node: TypeMacro) -> TypeMacro
 where
     F: Fold + ?Sized,
@@ -2857,6 +3176,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_type_never<F>(f: &mut F, node: TypeNever) -> TypeNever
 where
     F: Fold + ?Sized,
@@ -2866,6 +3186,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_type_param<F>(f: &mut F, node: TypeParam) -> TypeParam
 where
     F: Fold + ?Sized,
@@ -2880,6 +3201,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_type_param_bound<F>(f: &mut F, node: TypeParamBound) -> TypeParamBound
 where
     F: Fold + ?Sized,
@@ -2895,6 +3217,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_type_paren<F>(f: &mut F, node: TypeParen) -> TypeParen
 where
     F: Fold + ?Sized,
@@ -2905,6 +3228,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_type_path<F>(f: &mut F, node: TypePath) -> TypePath
 where
     F: Fold + ?Sized,
@@ -2915,6 +3239,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_type_ptr<F>(f: &mut F, node: TypePtr) -> TypePtr
 where
     F: Fold + ?Sized,
@@ -2927,6 +3252,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_type_reference<F>(f: &mut F, node: TypeReference) -> TypeReference
 where
     F: Fold + ?Sized,
@@ -2939,6 +3265,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_type_slice<F>(f: &mut F, node: TypeSlice) -> TypeSlice
 where
     F: Fold + ?Sized,
@@ -2949,6 +3276,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_type_trait_object<F>(f: &mut F, node: TypeTraitObject) -> TypeTraitObject
 where
     F: Fold + ?Sized,
@@ -2959,6 +3287,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_type_tuple<F>(f: &mut F, node: TypeTuple) -> TypeTuple
 where
     F: Fold + ?Sized,
@@ -2969,6 +3298,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_un_op<F>(f: &mut F, node: UnOp) -> UnOp
 where
     F: Fold + ?Sized,
@@ -2980,6 +3310,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_use_glob<F>(f: &mut F, node: UseGlob) -> UseGlob
 where
     F: Fold + ?Sized,
@@ -2989,6 +3320,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_use_group<F>(f: &mut F, node: UseGroup) -> UseGroup
 where
     F: Fold + ?Sized,
@@ -2999,6 +3331,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_use_name<F>(f: &mut F, node: UseName) -> UseName
 where
     F: Fold + ?Sized,
@@ -3008,6 +3341,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_use_path<F>(f: &mut F, node: UsePath) -> UsePath
 where
     F: Fold + ?Sized,
@@ -3019,6 +3353,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_use_rename<F>(f: &mut F, node: UseRename) -> UseRename
 where
     F: Fold + ?Sized,
@@ -3030,6 +3365,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_use_tree<F>(f: &mut F, node: UseTree) -> UseTree
 where
     F: Fold + ?Sized,
@@ -3043,6 +3379,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn fold_variadic<F>(f: &mut F, node: Variadic) -> Variadic
 where
     F: Fold + ?Sized,
@@ -3055,6 +3392,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_variant<F>(f: &mut F, node: Variant) -> Variant
 where
     F: Fold + ?Sized,
@@ -3067,6 +3405,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_vis_restricted<F>(f: &mut F, node: VisRestricted) -> VisRestricted
 where
     F: Fold + ?Sized,
@@ -3079,6 +3418,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_visibility<F>(f: &mut F, node: Visibility) -> Visibility
 where
     F: Fold + ?Sized,
@@ -3092,6 +3432,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_where_clause<F>(f: &mut F, node: WhereClause) -> WhereClause
 where
     F: Fold + ?Sized,
@@ -3102,6 +3443,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn fold_where_predicate<F>(f: &mut F, node: WherePredicate) -> WherePredicate
 where
     F: Fold + ?Sized,
diff --git a/src/gen/visit.rs b/src/gen/visit.rs
index ed36d4cc61..9f5a46ca92 100644
--- a/src/gen/visit.rs
+++ b/src/gen/visit.rs
@@ -29,10 +29,12 @@ macro_rules! skip {
 /// [module documentation]: self
 pub trait Visit<'ast> {
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_abi(&mut self, i: &'ast Abi) {
         visit_abi(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_angle_bracketed_generic_arguments(
         &mut self,
         i: &'ast AngleBracketedGenericArguments,
@@ -40,294 +42,367 @@ pub trait Visit<'ast> {
         visit_angle_bracketed_generic_arguments(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_arm(&mut self, i: &'ast Arm) {
         visit_arm(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_assoc_const(&mut self, i: &'ast AssocConst) {
         visit_assoc_const(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_assoc_type(&mut self, i: &'ast AssocType) {
         visit_assoc_type(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_attr_style(&mut self, i: &'ast AttrStyle) {
         visit_attr_style(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_attribute(&mut self, i: &'ast Attribute) {
         visit_attribute(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_bare_fn_arg(&mut self, i: &'ast BareFnArg) {
         visit_bare_fn_arg(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_bare_variadic(&mut self, i: &'ast BareVariadic) {
         visit_bare_variadic(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_bin_op(&mut self, i: &'ast BinOp) {
         visit_bin_op(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_block(&mut self, i: &'ast Block) {
         visit_block(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_bound_lifetimes(&mut self, i: &'ast BoundLifetimes) {
         visit_bound_lifetimes(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_const_param(&mut self, i: &'ast ConstParam) {
         visit_const_param(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_constraint(&mut self, i: &'ast Constraint) {
         visit_constraint(self, i);
     }
     #[cfg(feature = "derive")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
     fn visit_data(&mut self, i: &'ast Data) {
         visit_data(self, i);
     }
     #[cfg(feature = "derive")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
     fn visit_data_enum(&mut self, i: &'ast DataEnum) {
         visit_data_enum(self, i);
     }
     #[cfg(feature = "derive")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
     fn visit_data_struct(&mut self, i: &'ast DataStruct) {
         visit_data_struct(self, i);
     }
     #[cfg(feature = "derive")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
     fn visit_data_union(&mut self, i: &'ast DataUnion) {
         visit_data_union(self, i);
     }
     #[cfg(feature = "derive")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
     fn visit_derive_input(&mut self, i: &'ast DeriveInput) {
         visit_derive_input(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_expr(&mut self, i: &'ast Expr) {
         visit_expr(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_array(&mut self, i: &'ast ExprArray) {
         visit_expr_array(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_assign(&mut self, i: &'ast ExprAssign) {
         visit_expr_assign(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_async(&mut self, i: &'ast ExprAsync) {
         visit_expr_async(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_await(&mut self, i: &'ast ExprAwait) {
         visit_expr_await(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_expr_binary(&mut self, i: &'ast ExprBinary) {
         visit_expr_binary(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_block(&mut self, i: &'ast ExprBlock) {
         visit_expr_block(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_break(&mut self, i: &'ast ExprBreak) {
         visit_expr_break(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_expr_call(&mut self, i: &'ast ExprCall) {
         visit_expr_call(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_expr_cast(&mut self, i: &'ast ExprCast) {
         visit_expr_cast(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_closure(&mut self, i: &'ast ExprClosure) {
         visit_expr_closure(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_const(&mut self, i: &'ast ExprConst) {
         visit_expr_const(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_continue(&mut self, i: &'ast ExprContinue) {
         visit_expr_continue(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_expr_field(&mut self, i: &'ast ExprField) {
         visit_expr_field(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_for_loop(&mut self, i: &'ast ExprForLoop) {
         visit_expr_for_loop(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_expr_group(&mut self, i: &'ast ExprGroup) {
         visit_expr_group(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_if(&mut self, i: &'ast ExprIf) {
         visit_expr_if(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_expr_index(&mut self, i: &'ast ExprIndex) {
         visit_expr_index(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_infer(&mut self, i: &'ast ExprInfer) {
         visit_expr_infer(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_let(&mut self, i: &'ast ExprLet) {
         visit_expr_let(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_expr_lit(&mut self, i: &'ast ExprLit) {
         visit_expr_lit(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_loop(&mut self, i: &'ast ExprLoop) {
         visit_expr_loop(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_expr_macro(&mut self, i: &'ast ExprMacro) {
         visit_expr_macro(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_match(&mut self, i: &'ast ExprMatch) {
         visit_expr_match(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_expr_method_call(&mut self, i: &'ast ExprMethodCall) {
         visit_expr_method_call(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_expr_paren(&mut self, i: &'ast ExprParen) {
         visit_expr_paren(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_expr_path(&mut self, i: &'ast ExprPath) {
         visit_expr_path(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_range(&mut self, i: &'ast ExprRange) {
         visit_expr_range(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_expr_reference(&mut self, i: &'ast ExprReference) {
         visit_expr_reference(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_repeat(&mut self, i: &'ast ExprRepeat) {
         visit_expr_repeat(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_return(&mut self, i: &'ast ExprReturn) {
         visit_expr_return(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_struct(&mut self, i: &'ast ExprStruct) {
         visit_expr_struct(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_try(&mut self, i: &'ast ExprTry) {
         visit_expr_try(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_try_block(&mut self, i: &'ast ExprTryBlock) {
         visit_expr_try_block(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_tuple(&mut self, i: &'ast ExprTuple) {
         visit_expr_tuple(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_expr_unary(&mut self, i: &'ast ExprUnary) {
         visit_expr_unary(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_unsafe(&mut self, i: &'ast ExprUnsafe) {
         visit_expr_unsafe(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_while(&mut self, i: &'ast ExprWhile) {
         visit_expr_while(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_yield(&mut self, i: &'ast ExprYield) {
         visit_expr_yield(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_field(&mut self, i: &'ast Field) {
         visit_field(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_field_mutability(&mut self, i: &'ast FieldMutability) {
         visit_field_mutability(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_field_pat(&mut self, i: &'ast FieldPat) {
         visit_field_pat(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_field_value(&mut self, i: &'ast FieldValue) {
         visit_field_value(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_fields(&mut self, i: &'ast Fields) {
         visit_fields(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_fields_named(&mut self, i: &'ast FieldsNamed) {
         visit_fields_named(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_fields_unnamed(&mut self, i: &'ast FieldsUnnamed) {
         visit_fields_unnamed(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_file(&mut self, i: &'ast File) {
         visit_file(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_fn_arg(&mut self, i: &'ast FnArg) {
         visit_fn_arg(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_foreign_item(&mut self, i: &'ast ForeignItem) {
         visit_foreign_item(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_foreign_item_fn(&mut self, i: &'ast ForeignItemFn) {
         visit_foreign_item_fn(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_foreign_item_macro(&mut self, i: &'ast ForeignItemMacro) {
         visit_foreign_item_macro(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_foreign_item_static(&mut self, i: &'ast ForeignItemStatic) {
         visit_foreign_item_static(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_foreign_item_type(&mut self, i: &'ast ForeignItemType) {
         visit_foreign_item_type(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_generic_argument(&mut self, i: &'ast GenericArgument) {
         visit_generic_argument(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_generic_param(&mut self, i: &'ast GenericParam) {
         visit_generic_param(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_generics(&mut self, i: &'ast Generics) {
         visit_generics(self, i);
     }
@@ -335,98 +410,122 @@ pub trait Visit<'ast> {
         visit_ident(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_impl_item(&mut self, i: &'ast ImplItem) {
         visit_impl_item(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_impl_item_const(&mut self, i: &'ast ImplItemConst) {
         visit_impl_item_const(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_impl_item_fn(&mut self, i: &'ast ImplItemFn) {
         visit_impl_item_fn(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_impl_item_macro(&mut self, i: &'ast ImplItemMacro) {
         visit_impl_item_macro(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_impl_item_type(&mut self, i: &'ast ImplItemType) {
         visit_impl_item_type(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_impl_restriction(&mut self, i: &'ast ImplRestriction) {
         visit_impl_restriction(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_index(&mut self, i: &'ast Index) {
         visit_index(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_item(&mut self, i: &'ast Item) {
         visit_item(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_item_const(&mut self, i: &'ast ItemConst) {
         visit_item_const(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_item_enum(&mut self, i: &'ast ItemEnum) {
         visit_item_enum(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_item_extern_crate(&mut self, i: &'ast ItemExternCrate) {
         visit_item_extern_crate(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_item_fn(&mut self, i: &'ast ItemFn) {
         visit_item_fn(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_item_foreign_mod(&mut self, i: &'ast ItemForeignMod) {
         visit_item_foreign_mod(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_item_impl(&mut self, i: &'ast ItemImpl) {
         visit_item_impl(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_item_macro(&mut self, i: &'ast ItemMacro) {
         visit_item_macro(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_item_mod(&mut self, i: &'ast ItemMod) {
         visit_item_mod(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_item_static(&mut self, i: &'ast ItemStatic) {
         visit_item_static(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_item_struct(&mut self, i: &'ast ItemStruct) {
         visit_item_struct(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_item_trait(&mut self, i: &'ast ItemTrait) {
         visit_item_trait(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_item_trait_alias(&mut self, i: &'ast ItemTraitAlias) {
         visit_item_trait_alias(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_item_type(&mut self, i: &'ast ItemType) {
         visit_item_type(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_item_union(&mut self, i: &'ast ItemUnion) {
         visit_item_union(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_item_use(&mut self, i: &'ast ItemUse) {
         visit_item_use(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_label(&mut self, i: &'ast Label) {
         visit_label(self, i);
     }
@@ -434,6 +533,7 @@ pub trait Visit<'ast> {
         visit_lifetime(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_lifetime_param(&mut self, i: &'ast LifetimeParam) {
         visit_lifetime_param(self, i);
     }
@@ -462,38 +562,47 @@ pub trait Visit<'ast> {
         visit_lit_str(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_local(&mut self, i: &'ast Local) {
         visit_local(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_local_init(&mut self, i: &'ast LocalInit) {
         visit_local_init(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_macro(&mut self, i: &'ast Macro) {
         visit_macro(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_macro_delimiter(&mut self, i: &'ast MacroDelimiter) {
         visit_macro_delimiter(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_member(&mut self, i: &'ast Member) {
         visit_member(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_meta(&mut self, i: &'ast Meta) {
         visit_meta(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_meta_list(&mut self, i: &'ast MetaList) {
         visit_meta_list(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_meta_name_value(&mut self, i: &'ast MetaNameValue) {
         visit_meta_name_value(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_parenthesized_generic_arguments(
         &mut self,
         i: &'ast ParenthesizedGenericArguments,
@@ -501,90 +610,112 @@ pub trait Visit<'ast> {
         visit_parenthesized_generic_arguments(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_pat(&mut self, i: &'ast Pat) {
         visit_pat(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_pat_ident(&mut self, i: &'ast PatIdent) {
         visit_pat_ident(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_pat_or(&mut self, i: &'ast PatOr) {
         visit_pat_or(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_pat_paren(&mut self, i: &'ast PatParen) {
         visit_pat_paren(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_pat_reference(&mut self, i: &'ast PatReference) {
         visit_pat_reference(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_pat_rest(&mut self, i: &'ast PatRest) {
         visit_pat_rest(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_pat_slice(&mut self, i: &'ast PatSlice) {
         visit_pat_slice(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_pat_struct(&mut self, i: &'ast PatStruct) {
         visit_pat_struct(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_pat_tuple(&mut self, i: &'ast PatTuple) {
         visit_pat_tuple(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_pat_tuple_struct(&mut self, i: &'ast PatTupleStruct) {
         visit_pat_tuple_struct(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_pat_type(&mut self, i: &'ast PatType) {
         visit_pat_type(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_pat_wild(&mut self, i: &'ast PatWild) {
         visit_pat_wild(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_path(&mut self, i: &'ast Path) {
         visit_path(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_path_arguments(&mut self, i: &'ast PathArguments) {
         visit_path_arguments(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_path_segment(&mut self, i: &'ast PathSegment) {
         visit_path_segment(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_predicate_lifetime(&mut self, i: &'ast PredicateLifetime) {
         visit_predicate_lifetime(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_predicate_type(&mut self, i: &'ast PredicateType) {
         visit_predicate_type(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_qself(&mut self, i: &'ast QSelf) {
         visit_qself(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_range_limits(&mut self, i: &'ast RangeLimits) {
         visit_range_limits(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_receiver(&mut self, i: &'ast Receiver) {
         visit_receiver(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_return_type(&mut self, i: &'ast ReturnType) {
         visit_return_type(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_signature(&mut self, i: &'ast Signature) {
         visit_signature(self, i);
     }
@@ -592,167 +723,208 @@ pub trait Visit<'ast> {
         visit_span(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_static_mutability(&mut self, i: &'ast StaticMutability) {
         visit_static_mutability(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_stmt(&mut self, i: &'ast Stmt) {
         visit_stmt(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_stmt_macro(&mut self, i: &'ast StmtMacro) {
         visit_stmt_macro(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_trait_bound(&mut self, i: &'ast TraitBound) {
         visit_trait_bound(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_trait_bound_modifier(&mut self, i: &'ast TraitBoundModifier) {
         visit_trait_bound_modifier(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_trait_item(&mut self, i: &'ast TraitItem) {
         visit_trait_item(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_trait_item_const(&mut self, i: &'ast TraitItemConst) {
         visit_trait_item_const(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_trait_item_fn(&mut self, i: &'ast TraitItemFn) {
         visit_trait_item_fn(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_trait_item_macro(&mut self, i: &'ast TraitItemMacro) {
         visit_trait_item_macro(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_trait_item_type(&mut self, i: &'ast TraitItemType) {
         visit_trait_item_type(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_type(&mut self, i: &'ast Type) {
         visit_type(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_type_array(&mut self, i: &'ast TypeArray) {
         visit_type_array(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_type_bare_fn(&mut self, i: &'ast TypeBareFn) {
         visit_type_bare_fn(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_type_group(&mut self, i: &'ast TypeGroup) {
         visit_type_group(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_type_impl_trait(&mut self, i: &'ast TypeImplTrait) {
         visit_type_impl_trait(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_type_infer(&mut self, i: &'ast TypeInfer) {
         visit_type_infer(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_type_macro(&mut self, i: &'ast TypeMacro) {
         visit_type_macro(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_type_never(&mut self, i: &'ast TypeNever) {
         visit_type_never(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_type_param(&mut self, i: &'ast TypeParam) {
         visit_type_param(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_type_param_bound(&mut self, i: &'ast TypeParamBound) {
         visit_type_param_bound(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_type_paren(&mut self, i: &'ast TypeParen) {
         visit_type_paren(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_type_path(&mut self, i: &'ast TypePath) {
         visit_type_path(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_type_ptr(&mut self, i: &'ast TypePtr) {
         visit_type_ptr(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_type_reference(&mut self, i: &'ast TypeReference) {
         visit_type_reference(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_type_slice(&mut self, i: &'ast TypeSlice) {
         visit_type_slice(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_type_trait_object(&mut self, i: &'ast TypeTraitObject) {
         visit_type_trait_object(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_type_tuple(&mut self, i: &'ast TypeTuple) {
         visit_type_tuple(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_un_op(&mut self, i: &'ast UnOp) {
         visit_un_op(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_use_glob(&mut self, i: &'ast UseGlob) {
         visit_use_glob(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_use_group(&mut self, i: &'ast UseGroup) {
         visit_use_group(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_use_name(&mut self, i: &'ast UseName) {
         visit_use_name(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_use_path(&mut self, i: &'ast UsePath) {
         visit_use_path(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_use_rename(&mut self, i: &'ast UseRename) {
         visit_use_rename(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_use_tree(&mut self, i: &'ast UseTree) {
         visit_use_tree(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_variadic(&mut self, i: &'ast Variadic) {
         visit_variadic(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_variant(&mut self, i: &'ast Variant) {
         visit_variant(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_vis_restricted(&mut self, i: &'ast VisRestricted) {
         visit_vis_restricted(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_visibility(&mut self, i: &'ast Visibility) {
         visit_visibility(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_where_clause(&mut self, i: &'ast WhereClause) {
         visit_where_clause(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_where_predicate(&mut self, i: &'ast WherePredicate) {
         visit_where_predicate(self, i);
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_abi<'ast, V>(v: &mut V, node: &'ast Abi)
 where
     V: Visit<'ast> + ?Sized,
@@ -763,6 +935,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_angle_bracketed_generic_arguments<'ast, V>(
     v: &mut V,
     node: &'ast AngleBracketedGenericArguments,
@@ -779,6 +952,7 @@ where
     skip!(node.gt_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_arm<'ast, V>(v: &mut V, node: &'ast Arm)
 where
     V: Visit<'ast> + ?Sized,
@@ -796,6 +970,7 @@ where
     skip!(node.comma);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_assoc_const<'ast, V>(v: &mut V, node: &'ast AssocConst)
 where
     V: Visit<'ast> + ?Sized,
@@ -808,6 +983,7 @@ where
     v.visit_expr(&node.value);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_assoc_type<'ast, V>(v: &mut V, node: &'ast AssocType)
 where
     V: Visit<'ast> + ?Sized,
@@ -820,6 +996,7 @@ where
     v.visit_type(&node.ty);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_attr_style<'ast, V>(v: &mut V, node: &'ast AttrStyle)
 where
     V: Visit<'ast> + ?Sized,
@@ -832,6 +1009,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_attribute<'ast, V>(v: &mut V, node: &'ast Attribute)
 where
     V: Visit<'ast> + ?Sized,
@@ -842,6 +1020,7 @@ where
     v.visit_meta(&node.meta);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_bare_fn_arg<'ast, V>(v: &mut V, node: &'ast BareFnArg)
 where
     V: Visit<'ast> + ?Sized,
@@ -856,6 +1035,7 @@ where
     v.visit_type(&node.ty);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_bare_variadic<'ast, V>(v: &mut V, node: &'ast BareVariadic)
 where
     V: Visit<'ast> + ?Sized,
@@ -871,6 +1051,7 @@ where
     skip!(node.comma);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_bin_op<'ast, V>(v: &mut V, node: &'ast BinOp)
 where
     V: Visit<'ast> + ?Sized,
@@ -963,6 +1144,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_block<'ast, V>(v: &mut V, node: &'ast Block)
 where
     V: Visit<'ast> + ?Sized,
@@ -973,6 +1155,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_bound_lifetimes<'ast, V>(v: &mut V, node: &'ast BoundLifetimes)
 where
     V: Visit<'ast> + ?Sized,
@@ -986,6 +1169,7 @@ where
     skip!(node.gt_token);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_const_param<'ast, V>(v: &mut V, node: &'ast ConstParam)
 where
     V: Visit<'ast> + ?Sized,
@@ -1003,6 +1187,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_constraint<'ast, V>(v: &mut V, node: &'ast Constraint)
 where
     V: Visit<'ast> + ?Sized,
@@ -1018,6 +1203,7 @@ where
     }
 }
 #[cfg(feature = "derive")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
 pub fn visit_data<'ast, V>(v: &mut V, node: &'ast Data)
 where
     V: Visit<'ast> + ?Sized,
@@ -1035,6 +1221,7 @@ where
     }
 }
 #[cfg(feature = "derive")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
 pub fn visit_data_enum<'ast, V>(v: &mut V, node: &'ast DataEnum)
 where
     V: Visit<'ast> + ?Sized,
@@ -1047,6 +1234,7 @@ where
     }
 }
 #[cfg(feature = "derive")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
 pub fn visit_data_struct<'ast, V>(v: &mut V, node: &'ast DataStruct)
 where
     V: Visit<'ast> + ?Sized,
@@ -1056,6 +1244,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "derive")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
 pub fn visit_data_union<'ast, V>(v: &mut V, node: &'ast DataUnion)
 where
     V: Visit<'ast> + ?Sized,
@@ -1064,6 +1253,7 @@ where
     v.visit_fields_named(&node.fields);
 }
 #[cfg(feature = "derive")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
 pub fn visit_derive_input<'ast, V>(v: &mut V, node: &'ast DeriveInput)
 where
     V: Visit<'ast> + ?Sized,
@@ -1077,6 +1267,7 @@ where
     v.visit_data(&node.data);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_expr<'ast, V>(v: &mut V, node: &'ast Expr)
 where
     V: Visit<'ast> + ?Sized,
@@ -1202,6 +1393,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_array<'ast, V>(v: &mut V, node: &'ast ExprArray)
 where
     V: Visit<'ast> + ?Sized,
@@ -1216,6 +1408,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_assign<'ast, V>(v: &mut V, node: &'ast ExprAssign)
 where
     V: Visit<'ast> + ?Sized,
@@ -1228,6 +1421,7 @@ where
     v.visit_expr(&*node.right);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_async<'ast, V>(v: &mut V, node: &'ast ExprAsync)
 where
     V: Visit<'ast> + ?Sized,
@@ -1240,6 +1434,7 @@ where
     v.visit_block(&node.block);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_await<'ast, V>(v: &mut V, node: &'ast ExprAwait)
 where
     V: Visit<'ast> + ?Sized,
@@ -1252,6 +1447,7 @@ where
     skip!(node.await_token);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_expr_binary<'ast, V>(v: &mut V, node: &'ast ExprBinary)
 where
     V: Visit<'ast> + ?Sized,
@@ -1264,6 +1460,7 @@ where
     v.visit_expr(&*node.right);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_block<'ast, V>(v: &mut V, node: &'ast ExprBlock)
 where
     V: Visit<'ast> + ?Sized,
@@ -1277,6 +1474,7 @@ where
     v.visit_block(&node.block);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_break<'ast, V>(v: &mut V, node: &'ast ExprBreak)
 where
     V: Visit<'ast> + ?Sized,
@@ -1293,6 +1491,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_expr_call<'ast, V>(v: &mut V, node: &'ast ExprCall)
 where
     V: Visit<'ast> + ?Sized,
@@ -1308,6 +1507,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_expr_cast<'ast, V>(v: &mut V, node: &'ast ExprCast)
 where
     V: Visit<'ast> + ?Sized,
@@ -1320,6 +1520,7 @@ where
     v.visit_type(&*node.ty);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_closure<'ast, V>(v: &mut V, node: &'ast ExprClosure)
 where
     V: Visit<'ast> + ?Sized,
@@ -1344,6 +1545,7 @@ where
     v.visit_expr(&*node.body);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_const<'ast, V>(v: &mut V, node: &'ast ExprConst)
 where
     V: Visit<'ast> + ?Sized,
@@ -1355,6 +1557,7 @@ where
     v.visit_block(&node.block);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_continue<'ast, V>(v: &mut V, node: &'ast ExprContinue)
 where
     V: Visit<'ast> + ?Sized,
@@ -1368,6 +1571,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_expr_field<'ast, V>(v: &mut V, node: &'ast ExprField)
 where
     V: Visit<'ast> + ?Sized,
@@ -1380,6 +1584,7 @@ where
     v.visit_member(&node.member);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_for_loop<'ast, V>(v: &mut V, node: &'ast ExprForLoop)
 where
     V: Visit<'ast> + ?Sized,
@@ -1397,6 +1602,7 @@ where
     v.visit_block(&node.body);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_expr_group<'ast, V>(v: &mut V, node: &'ast ExprGroup)
 where
     V: Visit<'ast> + ?Sized,
@@ -1408,6 +1614,7 @@ where
     v.visit_expr(&*node.expr);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_if<'ast, V>(v: &mut V, node: &'ast ExprIf)
 where
     V: Visit<'ast> + ?Sized,
@@ -1424,6 +1631,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_expr_index<'ast, V>(v: &mut V, node: &'ast ExprIndex)
 where
     V: Visit<'ast> + ?Sized,
@@ -1436,6 +1644,7 @@ where
     v.visit_expr(&*node.index);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_infer<'ast, V>(v: &mut V, node: &'ast ExprInfer)
 where
     V: Visit<'ast> + ?Sized,
@@ -1446,6 +1655,7 @@ where
     skip!(node.underscore_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_let<'ast, V>(v: &mut V, node: &'ast ExprLet)
 where
     V: Visit<'ast> + ?Sized,
@@ -1459,6 +1669,7 @@ where
     v.visit_expr(&*node.expr);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_expr_lit<'ast, V>(v: &mut V, node: &'ast ExprLit)
 where
     V: Visit<'ast> + ?Sized,
@@ -1469,6 +1680,7 @@ where
     v.visit_lit(&node.lit);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_loop<'ast, V>(v: &mut V, node: &'ast ExprLoop)
 where
     V: Visit<'ast> + ?Sized,
@@ -1483,6 +1695,7 @@ where
     v.visit_block(&node.body);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_expr_macro<'ast, V>(v: &mut V, node: &'ast ExprMacro)
 where
     V: Visit<'ast> + ?Sized,
@@ -1493,6 +1706,7 @@ where
     v.visit_macro(&node.mac);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_match<'ast, V>(v: &mut V, node: &'ast ExprMatch)
 where
     V: Visit<'ast> + ?Sized,
@@ -1508,6 +1722,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_expr_method_call<'ast, V>(v: &mut V, node: &'ast ExprMethodCall)
 where
     V: Visit<'ast> + ?Sized,
@@ -1528,6 +1743,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_expr_paren<'ast, V>(v: &mut V, node: &'ast ExprParen)
 where
     V: Visit<'ast> + ?Sized,
@@ -1539,6 +1755,7 @@ where
     v.visit_expr(&*node.expr);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_expr_path<'ast, V>(v: &mut V, node: &'ast ExprPath)
 where
     V: Visit<'ast> + ?Sized,
@@ -1552,6 +1769,7 @@ where
     v.visit_path(&node.path);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_range<'ast, V>(v: &mut V, node: &'ast ExprRange)
 where
     V: Visit<'ast> + ?Sized,
@@ -1568,6 +1786,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_expr_reference<'ast, V>(v: &mut V, node: &'ast ExprReference)
 where
     V: Visit<'ast> + ?Sized,
@@ -1580,6 +1799,7 @@ where
     v.visit_expr(&*node.expr);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_repeat<'ast, V>(v: &mut V, node: &'ast ExprRepeat)
 where
     V: Visit<'ast> + ?Sized,
@@ -1593,6 +1813,7 @@ where
     v.visit_expr(&*node.len);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_return<'ast, V>(v: &mut V, node: &'ast ExprReturn)
 where
     V: Visit<'ast> + ?Sized,
@@ -1606,6 +1827,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_struct<'ast, V>(v: &mut V, node: &'ast ExprStruct)
 where
     V: Visit<'ast> + ?Sized,
@@ -1628,6 +1850,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_try<'ast, V>(v: &mut V, node: &'ast ExprTry)
 where
     V: Visit<'ast> + ?Sized,
@@ -1639,6 +1862,7 @@ where
     skip!(node.question_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_try_block<'ast, V>(v: &mut V, node: &'ast ExprTryBlock)
 where
     V: Visit<'ast> + ?Sized,
@@ -1650,6 +1874,7 @@ where
     v.visit_block(&node.block);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_tuple<'ast, V>(v: &mut V, node: &'ast ExprTuple)
 where
     V: Visit<'ast> + ?Sized,
@@ -1664,6 +1889,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_expr_unary<'ast, V>(v: &mut V, node: &'ast ExprUnary)
 where
     V: Visit<'ast> + ?Sized,
@@ -1675,6 +1901,7 @@ where
     v.visit_expr(&*node.expr);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_unsafe<'ast, V>(v: &mut V, node: &'ast ExprUnsafe)
 where
     V: Visit<'ast> + ?Sized,
@@ -1686,6 +1913,7 @@ where
     v.visit_block(&node.block);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_while<'ast, V>(v: &mut V, node: &'ast ExprWhile)
 where
     V: Visit<'ast> + ?Sized,
@@ -1701,6 +1929,7 @@ where
     v.visit_block(&node.body);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_yield<'ast, V>(v: &mut V, node: &'ast ExprYield)
 where
     V: Visit<'ast> + ?Sized,
@@ -1714,6 +1943,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_field<'ast, V>(v: &mut V, node: &'ast Field)
 where
     V: Visit<'ast> + ?Sized,
@@ -1730,6 +1960,7 @@ where
     v.visit_type(&node.ty);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_field_mutability<'ast, V>(v: &mut V, node: &'ast FieldMutability)
 where
     V: Visit<'ast> + ?Sized,
@@ -1739,6 +1970,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_field_pat<'ast, V>(v: &mut V, node: &'ast FieldPat)
 where
     V: Visit<'ast> + ?Sized,
@@ -1751,6 +1983,7 @@ where
     v.visit_pat(&*node.pat);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_field_value<'ast, V>(v: &mut V, node: &'ast FieldValue)
 where
     V: Visit<'ast> + ?Sized,
@@ -1763,6 +1996,7 @@ where
     v.visit_expr(&node.expr);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_fields<'ast, V>(v: &mut V, node: &'ast Fields)
 where
     V: Visit<'ast> + ?Sized,
@@ -1778,6 +2012,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_fields_named<'ast, V>(v: &mut V, node: &'ast FieldsNamed)
 where
     V: Visit<'ast> + ?Sized,
@@ -1789,6 +2024,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_fields_unnamed<'ast, V>(v: &mut V, node: &'ast FieldsUnnamed)
 where
     V: Visit<'ast> + ?Sized,
@@ -1800,6 +2036,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_file<'ast, V>(v: &mut V, node: &'ast File)
 where
     V: Visit<'ast> + ?Sized,
@@ -1813,6 +2050,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_fn_arg<'ast, V>(v: &mut V, node: &'ast FnArg)
 where
     V: Visit<'ast> + ?Sized,
@@ -1827,6 +2065,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_foreign_item<'ast, V>(v: &mut V, node: &'ast ForeignItem)
 where
     V: Visit<'ast> + ?Sized,
@@ -1850,6 +2089,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_foreign_item_fn<'ast, V>(v: &mut V, node: &'ast ForeignItemFn)
 where
     V: Visit<'ast> + ?Sized,
@@ -1862,6 +2102,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_foreign_item_macro<'ast, V>(v: &mut V, node: &'ast ForeignItemMacro)
 where
     V: Visit<'ast> + ?Sized,
@@ -1873,6 +2114,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_foreign_item_static<'ast, V>(v: &mut V, node: &'ast ForeignItemStatic)
 where
     V: Visit<'ast> + ?Sized,
@@ -1889,6 +2131,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_foreign_item_type<'ast, V>(v: &mut V, node: &'ast ForeignItemType)
 where
     V: Visit<'ast> + ?Sized,
@@ -1903,6 +2146,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_generic_argument<'ast, V>(v: &mut V, node: &'ast GenericArgument)
 where
     V: Visit<'ast> + ?Sized,
@@ -1929,6 +2173,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_generic_param<'ast, V>(v: &mut V, node: &'ast GenericParam)
 where
     V: Visit<'ast> + ?Sized,
@@ -1946,6 +2191,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_generics<'ast, V>(v: &mut V, node: &'ast Generics)
 where
     V: Visit<'ast> + ?Sized,
@@ -1967,6 +2213,7 @@ where
     v.visit_span(&node.span());
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_impl_item<'ast, V>(v: &mut V, node: &'ast ImplItem)
 where
     V: Visit<'ast> + ?Sized,
@@ -1990,6 +2237,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_impl_item_const<'ast, V>(v: &mut V, node: &'ast ImplItemConst)
 where
     V: Visit<'ast> + ?Sized,
@@ -2009,6 +2257,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_impl_item_fn<'ast, V>(v: &mut V, node: &'ast ImplItemFn)
 where
     V: Visit<'ast> + ?Sized,
@@ -2022,6 +2271,7 @@ where
     v.visit_block(&node.block);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_impl_item_macro<'ast, V>(v: &mut V, node: &'ast ImplItemMacro)
 where
     V: Visit<'ast> + ?Sized,
@@ -2033,6 +2283,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_impl_item_type<'ast, V>(v: &mut V, node: &'ast ImplItemType)
 where
     V: Visit<'ast> + ?Sized,
@@ -2050,6 +2301,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_impl_restriction<'ast, V>(v: &mut V, node: &'ast ImplRestriction)
 where
     V: Visit<'ast> + ?Sized,
@@ -2057,6 +2309,7 @@ where
     match *node {}
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_index<'ast, V>(v: &mut V, node: &'ast Index)
 where
     V: Visit<'ast> + ?Sized,
@@ -2065,6 +2318,7 @@ where
     v.visit_span(&node.span);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_item<'ast, V>(v: &mut V, node: &'ast Item)
 where
     V: Visit<'ast> + ?Sized,
@@ -2121,6 +2375,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_item_const<'ast, V>(v: &mut V, node: &'ast ItemConst)
 where
     V: Visit<'ast> + ?Sized,
@@ -2139,6 +2394,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_item_enum<'ast, V>(v: &mut V, node: &'ast ItemEnum)
 where
     V: Visit<'ast> + ?Sized,
@@ -2157,6 +2413,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_item_extern_crate<'ast, V>(v: &mut V, node: &'ast ItemExternCrate)
 where
     V: Visit<'ast> + ?Sized,
@@ -2175,6 +2432,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_item_fn<'ast, V>(v: &mut V, node: &'ast ItemFn)
 where
     V: Visit<'ast> + ?Sized,
@@ -2187,6 +2445,7 @@ where
     v.visit_block(&*node.block);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_item_foreign_mod<'ast, V>(v: &mut V, node: &'ast ItemForeignMod)
 where
     V: Visit<'ast> + ?Sized,
@@ -2202,6 +2461,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_item_impl<'ast, V>(v: &mut V, node: &'ast ItemImpl)
 where
     V: Visit<'ast> + ?Sized,
@@ -2225,6 +2485,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_item_macro<'ast, V>(v: &mut V, node: &'ast ItemMacro)
 where
     V: Visit<'ast> + ?Sized,
@@ -2239,6 +2500,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_item_mod<'ast, V>(v: &mut V, node: &'ast ItemMod)
 where
     V: Visit<'ast> + ?Sized,
@@ -2259,6 +2521,7 @@ where
     skip!(node.semi);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_item_static<'ast, V>(v: &mut V, node: &'ast ItemStatic)
 where
     V: Visit<'ast> + ?Sized,
@@ -2277,6 +2540,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_item_struct<'ast, V>(v: &mut V, node: &'ast ItemStruct)
 where
     V: Visit<'ast> + ?Sized,
@@ -2292,6 +2556,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_item_trait<'ast, V>(v: &mut V, node: &'ast ItemTrait)
 where
     V: Visit<'ast> + ?Sized,
@@ -2319,6 +2584,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_item_trait_alias<'ast, V>(v: &mut V, node: &'ast ItemTraitAlias)
 where
     V: Visit<'ast> + ?Sized,
@@ -2338,6 +2604,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_item_type<'ast, V>(v: &mut V, node: &'ast ItemType)
 where
     V: Visit<'ast> + ?Sized,
@@ -2354,6 +2621,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_item_union<'ast, V>(v: &mut V, node: &'ast ItemUnion)
 where
     V: Visit<'ast> + ?Sized,
@@ -2368,6 +2636,7 @@ where
     v.visit_fields_named(&node.fields);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_item_use<'ast, V>(v: &mut V, node: &'ast ItemUse)
 where
     V: Visit<'ast> + ?Sized,
@@ -2382,6 +2651,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_label<'ast, V>(v: &mut V, node: &'ast Label)
 where
     V: Visit<'ast> + ?Sized,
@@ -2397,6 +2667,7 @@ where
     v.visit_ident(&node.ident);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_lifetime_param<'ast, V>(v: &mut V, node: &'ast LifetimeParam)
 where
     V: Visit<'ast> + ?Sized,
@@ -2474,6 +2745,7 @@ where
     V: Visit<'ast> + ?Sized,
 {}
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_local<'ast, V>(v: &mut V, node: &'ast Local)
 where
     V: Visit<'ast> + ?Sized,
@@ -2489,6 +2761,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_local_init<'ast, V>(v: &mut V, node: &'ast LocalInit)
 where
     V: Visit<'ast> + ?Sized,
@@ -2501,6 +2774,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_macro<'ast, V>(v: &mut V, node: &'ast Macro)
 where
     V: Visit<'ast> + ?Sized,
@@ -2511,6 +2785,7 @@ where
     skip!(node.tokens);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_macro_delimiter<'ast, V>(v: &mut V, node: &'ast MacroDelimiter)
 where
     V: Visit<'ast> + ?Sized,
@@ -2528,6 +2803,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_member<'ast, V>(v: &mut V, node: &'ast Member)
 where
     V: Visit<'ast> + ?Sized,
@@ -2542,6 +2818,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_meta<'ast, V>(v: &mut V, node: &'ast Meta)
 where
     V: Visit<'ast> + ?Sized,
@@ -2559,6 +2836,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_meta_list<'ast, V>(v: &mut V, node: &'ast MetaList)
 where
     V: Visit<'ast> + ?Sized,
@@ -2568,6 +2846,7 @@ where
     skip!(node.tokens);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_meta_name_value<'ast, V>(v: &mut V, node: &'ast MetaNameValue)
 where
     V: Visit<'ast> + ?Sized,
@@ -2577,6 +2856,7 @@ where
     v.visit_expr(&node.value);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_parenthesized_generic_arguments<'ast, V>(
     v: &mut V,
     node: &'ast ParenthesizedGenericArguments,
@@ -2592,6 +2872,7 @@ where
     v.visit_return_type(&node.output);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_pat<'ast, V>(v: &mut V, node: &'ast Pat)
 where
     V: Visit<'ast> + ?Sized,
@@ -2651,6 +2932,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_pat_ident<'ast, V>(v: &mut V, node: &'ast PatIdent)
 where
     V: Visit<'ast> + ?Sized,
@@ -2667,6 +2949,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_pat_or<'ast, V>(v: &mut V, node: &'ast PatOr)
 where
     V: Visit<'ast> + ?Sized,
@@ -2681,6 +2964,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_pat_paren<'ast, V>(v: &mut V, node: &'ast PatParen)
 where
     V: Visit<'ast> + ?Sized,
@@ -2692,6 +2976,7 @@ where
     v.visit_pat(&*node.pat);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_pat_reference<'ast, V>(v: &mut V, node: &'ast PatReference)
 where
     V: Visit<'ast> + ?Sized,
@@ -2704,6 +2989,7 @@ where
     v.visit_pat(&*node.pat);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_pat_rest<'ast, V>(v: &mut V, node: &'ast PatRest)
 where
     V: Visit<'ast> + ?Sized,
@@ -2714,6 +3000,7 @@ where
     skip!(node.dot2_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_pat_slice<'ast, V>(v: &mut V, node: &'ast PatSlice)
 where
     V: Visit<'ast> + ?Sized,
@@ -2728,6 +3015,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_pat_struct<'ast, V>(v: &mut V, node: &'ast PatStruct)
 where
     V: Visit<'ast> + ?Sized,
@@ -2749,6 +3037,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_pat_tuple<'ast, V>(v: &mut V, node: &'ast PatTuple)
 where
     V: Visit<'ast> + ?Sized,
@@ -2763,6 +3052,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_pat_tuple_struct<'ast, V>(v: &mut V, node: &'ast PatTupleStruct)
 where
     V: Visit<'ast> + ?Sized,
@@ -2781,6 +3071,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_pat_type<'ast, V>(v: &mut V, node: &'ast PatType)
 where
     V: Visit<'ast> + ?Sized,
@@ -2793,6 +3084,7 @@ where
     v.visit_type(&*node.ty);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_pat_wild<'ast, V>(v: &mut V, node: &'ast PatWild)
 where
     V: Visit<'ast> + ?Sized,
@@ -2803,6 +3095,7 @@ where
     skip!(node.underscore_token);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_path<'ast, V>(v: &mut V, node: &'ast Path)
 where
     V: Visit<'ast> + ?Sized,
@@ -2814,6 +3107,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_path_arguments<'ast, V>(v: &mut V, node: &'ast PathArguments)
 where
     V: Visit<'ast> + ?Sized,
@@ -2829,6 +3123,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_path_segment<'ast, V>(v: &mut V, node: &'ast PathSegment)
 where
     V: Visit<'ast> + ?Sized,
@@ -2837,6 +3132,7 @@ where
     v.visit_path_arguments(&node.arguments);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_predicate_lifetime<'ast, V>(v: &mut V, node: &'ast PredicateLifetime)
 where
     V: Visit<'ast> + ?Sized,
@@ -2849,6 +3145,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_predicate_type<'ast, V>(v: &mut V, node: &'ast PredicateType)
 where
     V: Visit<'ast> + ?Sized,
@@ -2864,6 +3161,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_qself<'ast, V>(v: &mut V, node: &'ast QSelf)
 where
     V: Visit<'ast> + ?Sized,
@@ -2875,6 +3173,7 @@ where
     skip!(node.gt_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_range_limits<'ast, V>(v: &mut V, node: &'ast RangeLimits)
 where
     V: Visit<'ast> + ?Sized,
@@ -2889,6 +3188,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_receiver<'ast, V>(v: &mut V, node: &'ast Receiver)
 where
     V: Visit<'ast> + ?Sized,
@@ -2908,6 +3208,7 @@ where
     v.visit_type(&*node.ty);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_return_type<'ast, V>(v: &mut V, node: &'ast ReturnType)
 where
     V: Visit<'ast> + ?Sized,
@@ -2921,6 +3222,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_signature<'ast, V>(v: &mut V, node: &'ast Signature)
 where
     V: Visit<'ast> + ?Sized,
@@ -2949,6 +3251,7 @@ where
     V: Visit<'ast> + ?Sized,
 {}
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_static_mutability<'ast, V>(v: &mut V, node: &'ast StaticMutability)
 where
     V: Visit<'ast> + ?Sized,
@@ -2961,6 +3264,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_stmt<'ast, V>(v: &mut V, node: &'ast Stmt)
 where
     V: Visit<'ast> + ?Sized,
@@ -2982,6 +3286,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_stmt_macro<'ast, V>(v: &mut V, node: &'ast StmtMacro)
 where
     V: Visit<'ast> + ?Sized,
@@ -2993,6 +3298,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_trait_bound<'ast, V>(v: &mut V, node: &'ast TraitBound)
 where
     V: Visit<'ast> + ?Sized,
@@ -3005,6 +3311,7 @@ where
     v.visit_path(&node.path);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_trait_bound_modifier<'ast, V>(v: &mut V, node: &'ast TraitBoundModifier)
 where
     V: Visit<'ast> + ?Sized,
@@ -3017,6 +3324,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_trait_item<'ast, V>(v: &mut V, node: &'ast TraitItem)
 where
     V: Visit<'ast> + ?Sized,
@@ -3040,6 +3348,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_trait_item_const<'ast, V>(v: &mut V, node: &'ast TraitItemConst)
 where
     V: Visit<'ast> + ?Sized,
@@ -3059,6 +3368,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_trait_item_fn<'ast, V>(v: &mut V, node: &'ast TraitItemFn)
 where
     V: Visit<'ast> + ?Sized,
@@ -3073,6 +3383,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_trait_item_macro<'ast, V>(v: &mut V, node: &'ast TraitItemMacro)
 where
     V: Visit<'ast> + ?Sized,
@@ -3084,6 +3395,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_trait_item_type<'ast, V>(v: &mut V, node: &'ast TraitItemType)
 where
     V: Visit<'ast> + ?Sized,
@@ -3106,6 +3418,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_type<'ast, V>(v: &mut V, node: &'ast Type)
 where
     V: Visit<'ast> + ?Sized,
@@ -3159,6 +3472,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_type_array<'ast, V>(v: &mut V, node: &'ast TypeArray)
 where
     V: Visit<'ast> + ?Sized,
@@ -3169,6 +3483,7 @@ where
     v.visit_expr(&node.len);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_type_bare_fn<'ast, V>(v: &mut V, node: &'ast TypeBareFn)
 where
     V: Visit<'ast> + ?Sized,
@@ -3192,6 +3507,7 @@ where
     v.visit_return_type(&node.output);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_type_group<'ast, V>(v: &mut V, node: &'ast TypeGroup)
 where
     V: Visit<'ast> + ?Sized,
@@ -3200,6 +3516,7 @@ where
     v.visit_type(&*node.elem);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_type_impl_trait<'ast, V>(v: &mut V, node: &'ast TypeImplTrait)
 where
     V: Visit<'ast> + ?Sized,
@@ -3211,6 +3528,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_type_infer<'ast, V>(v: &mut V, node: &'ast TypeInfer)
 where
     V: Visit<'ast> + ?Sized,
@@ -3218,6 +3536,7 @@ where
     skip!(node.underscore_token);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_type_macro<'ast, V>(v: &mut V, node: &'ast TypeMacro)
 where
     V: Visit<'ast> + ?Sized,
@@ -3225,6 +3544,7 @@ where
     v.visit_macro(&node.mac);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_type_never<'ast, V>(v: &mut V, node: &'ast TypeNever)
 where
     V: Visit<'ast> + ?Sized,
@@ -3232,6 +3552,7 @@ where
     skip!(node.bang_token);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_type_param<'ast, V>(v: &mut V, node: &'ast TypeParam)
 where
     V: Visit<'ast> + ?Sized,
@@ -3251,6 +3572,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_type_param_bound<'ast, V>(v: &mut V, node: &'ast TypeParamBound)
 where
     V: Visit<'ast> + ?Sized,
@@ -3268,6 +3590,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_type_paren<'ast, V>(v: &mut V, node: &'ast TypeParen)
 where
     V: Visit<'ast> + ?Sized,
@@ -3276,6 +3599,7 @@ where
     v.visit_type(&*node.elem);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_type_path<'ast, V>(v: &mut V, node: &'ast TypePath)
 where
     V: Visit<'ast> + ?Sized,
@@ -3286,6 +3610,7 @@ where
     v.visit_path(&node.path);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_type_ptr<'ast, V>(v: &mut V, node: &'ast TypePtr)
 where
     V: Visit<'ast> + ?Sized,
@@ -3296,6 +3621,7 @@ where
     v.visit_type(&*node.elem);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_type_reference<'ast, V>(v: &mut V, node: &'ast TypeReference)
 where
     V: Visit<'ast> + ?Sized,
@@ -3308,6 +3634,7 @@ where
     v.visit_type(&*node.elem);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_type_slice<'ast, V>(v: &mut V, node: &'ast TypeSlice)
 where
     V: Visit<'ast> + ?Sized,
@@ -3316,6 +3643,7 @@ where
     v.visit_type(&*node.elem);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_type_trait_object<'ast, V>(v: &mut V, node: &'ast TypeTraitObject)
 where
     V: Visit<'ast> + ?Sized,
@@ -3327,6 +3655,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_type_tuple<'ast, V>(v: &mut V, node: &'ast TypeTuple)
 where
     V: Visit<'ast> + ?Sized,
@@ -3338,6 +3667,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_un_op<'ast, V>(v: &mut V, node: &'ast UnOp)
 where
     V: Visit<'ast> + ?Sized,
@@ -3355,6 +3685,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_use_glob<'ast, V>(v: &mut V, node: &'ast UseGlob)
 where
     V: Visit<'ast> + ?Sized,
@@ -3362,6 +3693,7 @@ where
     skip!(node.star_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_use_group<'ast, V>(v: &mut V, node: &'ast UseGroup)
 where
     V: Visit<'ast> + ?Sized,
@@ -3373,6 +3705,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_use_name<'ast, V>(v: &mut V, node: &'ast UseName)
 where
     V: Visit<'ast> + ?Sized,
@@ -3380,6 +3713,7 @@ where
     v.visit_ident(&node.ident);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_use_path<'ast, V>(v: &mut V, node: &'ast UsePath)
 where
     V: Visit<'ast> + ?Sized,
@@ -3389,6 +3723,7 @@ where
     v.visit_use_tree(&*node.tree);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_use_rename<'ast, V>(v: &mut V, node: &'ast UseRename)
 where
     V: Visit<'ast> + ?Sized,
@@ -3398,6 +3733,7 @@ where
     v.visit_ident(&node.rename);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_use_tree<'ast, V>(v: &mut V, node: &'ast UseTree)
 where
     V: Visit<'ast> + ?Sized,
@@ -3421,6 +3757,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_variadic<'ast, V>(v: &mut V, node: &'ast Variadic)
 where
     V: Visit<'ast> + ?Sized,
@@ -3436,6 +3773,7 @@ where
     skip!(node.comma);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_variant<'ast, V>(v: &mut V, node: &'ast Variant)
 where
     V: Visit<'ast> + ?Sized,
@@ -3451,6 +3789,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_vis_restricted<'ast, V>(v: &mut V, node: &'ast VisRestricted)
 where
     V: Visit<'ast> + ?Sized,
@@ -3461,6 +3800,7 @@ where
     v.visit_path(&*node.path);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_visibility<'ast, V>(v: &mut V, node: &'ast Visibility)
 where
     V: Visit<'ast> + ?Sized,
@@ -3476,6 +3816,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_where_clause<'ast, V>(v: &mut V, node: &'ast WhereClause)
 where
     V: Visit<'ast> + ?Sized,
@@ -3487,6 +3828,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_where_predicate<'ast, V>(v: &mut V, node: &'ast WherePredicate)
 where
     V: Visit<'ast> + ?Sized,
diff --git a/src/gen/visit_mut.rs b/src/gen/visit_mut.rs
index 64b85f39e3..9242132d1b 100644
--- a/src/gen/visit_mut.rs
+++ b/src/gen/visit_mut.rs
@@ -30,10 +30,12 @@ macro_rules! skip {
 /// [module documentation]: self
 pub trait VisitMut {
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_abi_mut(&mut self, i: &mut Abi) {
         visit_abi_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_angle_bracketed_generic_arguments_mut(
         &mut self,
         i: &mut AngleBracketedGenericArguments,
@@ -41,294 +43,367 @@ pub trait VisitMut {
         visit_angle_bracketed_generic_arguments_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_arm_mut(&mut self, i: &mut Arm) {
         visit_arm_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_assoc_const_mut(&mut self, i: &mut AssocConst) {
         visit_assoc_const_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_assoc_type_mut(&mut self, i: &mut AssocType) {
         visit_assoc_type_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_attr_style_mut(&mut self, i: &mut AttrStyle) {
         visit_attr_style_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_attribute_mut(&mut self, i: &mut Attribute) {
         visit_attribute_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_bare_fn_arg_mut(&mut self, i: &mut BareFnArg) {
         visit_bare_fn_arg_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_bare_variadic_mut(&mut self, i: &mut BareVariadic) {
         visit_bare_variadic_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_bin_op_mut(&mut self, i: &mut BinOp) {
         visit_bin_op_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_block_mut(&mut self, i: &mut Block) {
         visit_block_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_bound_lifetimes_mut(&mut self, i: &mut BoundLifetimes) {
         visit_bound_lifetimes_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_const_param_mut(&mut self, i: &mut ConstParam) {
         visit_const_param_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_constraint_mut(&mut self, i: &mut Constraint) {
         visit_constraint_mut(self, i);
     }
     #[cfg(feature = "derive")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
     fn visit_data_mut(&mut self, i: &mut Data) {
         visit_data_mut(self, i);
     }
     #[cfg(feature = "derive")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
     fn visit_data_enum_mut(&mut self, i: &mut DataEnum) {
         visit_data_enum_mut(self, i);
     }
     #[cfg(feature = "derive")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
     fn visit_data_struct_mut(&mut self, i: &mut DataStruct) {
         visit_data_struct_mut(self, i);
     }
     #[cfg(feature = "derive")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
     fn visit_data_union_mut(&mut self, i: &mut DataUnion) {
         visit_data_union_mut(self, i);
     }
     #[cfg(feature = "derive")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
     fn visit_derive_input_mut(&mut self, i: &mut DeriveInput) {
         visit_derive_input_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_expr_mut(&mut self, i: &mut Expr) {
         visit_expr_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_array_mut(&mut self, i: &mut ExprArray) {
         visit_expr_array_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_assign_mut(&mut self, i: &mut ExprAssign) {
         visit_expr_assign_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_async_mut(&mut self, i: &mut ExprAsync) {
         visit_expr_async_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_await_mut(&mut self, i: &mut ExprAwait) {
         visit_expr_await_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_expr_binary_mut(&mut self, i: &mut ExprBinary) {
         visit_expr_binary_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_block_mut(&mut self, i: &mut ExprBlock) {
         visit_expr_block_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_break_mut(&mut self, i: &mut ExprBreak) {
         visit_expr_break_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_expr_call_mut(&mut self, i: &mut ExprCall) {
         visit_expr_call_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_expr_cast_mut(&mut self, i: &mut ExprCast) {
         visit_expr_cast_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_closure_mut(&mut self, i: &mut ExprClosure) {
         visit_expr_closure_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_const_mut(&mut self, i: &mut ExprConst) {
         visit_expr_const_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_continue_mut(&mut self, i: &mut ExprContinue) {
         visit_expr_continue_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_expr_field_mut(&mut self, i: &mut ExprField) {
         visit_expr_field_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_for_loop_mut(&mut self, i: &mut ExprForLoop) {
         visit_expr_for_loop_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_expr_group_mut(&mut self, i: &mut ExprGroup) {
         visit_expr_group_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_if_mut(&mut self, i: &mut ExprIf) {
         visit_expr_if_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_expr_index_mut(&mut self, i: &mut ExprIndex) {
         visit_expr_index_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_infer_mut(&mut self, i: &mut ExprInfer) {
         visit_expr_infer_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_let_mut(&mut self, i: &mut ExprLet) {
         visit_expr_let_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_expr_lit_mut(&mut self, i: &mut ExprLit) {
         visit_expr_lit_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_loop_mut(&mut self, i: &mut ExprLoop) {
         visit_expr_loop_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_expr_macro_mut(&mut self, i: &mut ExprMacro) {
         visit_expr_macro_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_match_mut(&mut self, i: &mut ExprMatch) {
         visit_expr_match_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_expr_method_call_mut(&mut self, i: &mut ExprMethodCall) {
         visit_expr_method_call_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_expr_paren_mut(&mut self, i: &mut ExprParen) {
         visit_expr_paren_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_expr_path_mut(&mut self, i: &mut ExprPath) {
         visit_expr_path_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_range_mut(&mut self, i: &mut ExprRange) {
         visit_expr_range_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_expr_reference_mut(&mut self, i: &mut ExprReference) {
         visit_expr_reference_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_repeat_mut(&mut self, i: &mut ExprRepeat) {
         visit_expr_repeat_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_return_mut(&mut self, i: &mut ExprReturn) {
         visit_expr_return_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_struct_mut(&mut self, i: &mut ExprStruct) {
         visit_expr_struct_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_try_mut(&mut self, i: &mut ExprTry) {
         visit_expr_try_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_try_block_mut(&mut self, i: &mut ExprTryBlock) {
         visit_expr_try_block_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_tuple_mut(&mut self, i: &mut ExprTuple) {
         visit_expr_tuple_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_expr_unary_mut(&mut self, i: &mut ExprUnary) {
         visit_expr_unary_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_unsafe_mut(&mut self, i: &mut ExprUnsafe) {
         visit_expr_unsafe_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_while_mut(&mut self, i: &mut ExprWhile) {
         visit_expr_while_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_expr_yield_mut(&mut self, i: &mut ExprYield) {
         visit_expr_yield_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_field_mut(&mut self, i: &mut Field) {
         visit_field_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_field_mutability_mut(&mut self, i: &mut FieldMutability) {
         visit_field_mutability_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_field_pat_mut(&mut self, i: &mut FieldPat) {
         visit_field_pat_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_field_value_mut(&mut self, i: &mut FieldValue) {
         visit_field_value_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_fields_mut(&mut self, i: &mut Fields) {
         visit_fields_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_fields_named_mut(&mut self, i: &mut FieldsNamed) {
         visit_fields_named_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_fields_unnamed_mut(&mut self, i: &mut FieldsUnnamed) {
         visit_fields_unnamed_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_file_mut(&mut self, i: &mut File) {
         visit_file_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_fn_arg_mut(&mut self, i: &mut FnArg) {
         visit_fn_arg_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_foreign_item_mut(&mut self, i: &mut ForeignItem) {
         visit_foreign_item_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_foreign_item_fn_mut(&mut self, i: &mut ForeignItemFn) {
         visit_foreign_item_fn_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_foreign_item_macro_mut(&mut self, i: &mut ForeignItemMacro) {
         visit_foreign_item_macro_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_foreign_item_static_mut(&mut self, i: &mut ForeignItemStatic) {
         visit_foreign_item_static_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_foreign_item_type_mut(&mut self, i: &mut ForeignItemType) {
         visit_foreign_item_type_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_generic_argument_mut(&mut self, i: &mut GenericArgument) {
         visit_generic_argument_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_generic_param_mut(&mut self, i: &mut GenericParam) {
         visit_generic_param_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_generics_mut(&mut self, i: &mut Generics) {
         visit_generics_mut(self, i);
     }
@@ -336,98 +411,122 @@ pub trait VisitMut {
         visit_ident_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_impl_item_mut(&mut self, i: &mut ImplItem) {
         visit_impl_item_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_impl_item_const_mut(&mut self, i: &mut ImplItemConst) {
         visit_impl_item_const_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_impl_item_fn_mut(&mut self, i: &mut ImplItemFn) {
         visit_impl_item_fn_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_impl_item_macro_mut(&mut self, i: &mut ImplItemMacro) {
         visit_impl_item_macro_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_impl_item_type_mut(&mut self, i: &mut ImplItemType) {
         visit_impl_item_type_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_impl_restriction_mut(&mut self, i: &mut ImplRestriction) {
         visit_impl_restriction_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_index_mut(&mut self, i: &mut Index) {
         visit_index_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_item_mut(&mut self, i: &mut Item) {
         visit_item_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_item_const_mut(&mut self, i: &mut ItemConst) {
         visit_item_const_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_item_enum_mut(&mut self, i: &mut ItemEnum) {
         visit_item_enum_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_item_extern_crate_mut(&mut self, i: &mut ItemExternCrate) {
         visit_item_extern_crate_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_item_fn_mut(&mut self, i: &mut ItemFn) {
         visit_item_fn_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_item_foreign_mod_mut(&mut self, i: &mut ItemForeignMod) {
         visit_item_foreign_mod_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_item_impl_mut(&mut self, i: &mut ItemImpl) {
         visit_item_impl_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_item_macro_mut(&mut self, i: &mut ItemMacro) {
         visit_item_macro_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_item_mod_mut(&mut self, i: &mut ItemMod) {
         visit_item_mod_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_item_static_mut(&mut self, i: &mut ItemStatic) {
         visit_item_static_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_item_struct_mut(&mut self, i: &mut ItemStruct) {
         visit_item_struct_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_item_trait_mut(&mut self, i: &mut ItemTrait) {
         visit_item_trait_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_item_trait_alias_mut(&mut self, i: &mut ItemTraitAlias) {
         visit_item_trait_alias_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_item_type_mut(&mut self, i: &mut ItemType) {
         visit_item_type_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_item_union_mut(&mut self, i: &mut ItemUnion) {
         visit_item_union_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_item_use_mut(&mut self, i: &mut ItemUse) {
         visit_item_use_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_label_mut(&mut self, i: &mut Label) {
         visit_label_mut(self, i);
     }
@@ -435,6 +534,7 @@ pub trait VisitMut {
         visit_lifetime_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_lifetime_param_mut(&mut self, i: &mut LifetimeParam) {
         visit_lifetime_param_mut(self, i);
     }
@@ -463,38 +563,47 @@ pub trait VisitMut {
         visit_lit_str_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_local_mut(&mut self, i: &mut Local) {
         visit_local_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_local_init_mut(&mut self, i: &mut LocalInit) {
         visit_local_init_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_macro_mut(&mut self, i: &mut Macro) {
         visit_macro_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_macro_delimiter_mut(&mut self, i: &mut MacroDelimiter) {
         visit_macro_delimiter_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_member_mut(&mut self, i: &mut Member) {
         visit_member_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_meta_mut(&mut self, i: &mut Meta) {
         visit_meta_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_meta_list_mut(&mut self, i: &mut MetaList) {
         visit_meta_list_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_meta_name_value_mut(&mut self, i: &mut MetaNameValue) {
         visit_meta_name_value_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_parenthesized_generic_arguments_mut(
         &mut self,
         i: &mut ParenthesizedGenericArguments,
@@ -502,90 +611,112 @@ pub trait VisitMut {
         visit_parenthesized_generic_arguments_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_pat_mut(&mut self, i: &mut Pat) {
         visit_pat_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_pat_ident_mut(&mut self, i: &mut PatIdent) {
         visit_pat_ident_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_pat_or_mut(&mut self, i: &mut PatOr) {
         visit_pat_or_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_pat_paren_mut(&mut self, i: &mut PatParen) {
         visit_pat_paren_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_pat_reference_mut(&mut self, i: &mut PatReference) {
         visit_pat_reference_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_pat_rest_mut(&mut self, i: &mut PatRest) {
         visit_pat_rest_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_pat_slice_mut(&mut self, i: &mut PatSlice) {
         visit_pat_slice_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_pat_struct_mut(&mut self, i: &mut PatStruct) {
         visit_pat_struct_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_pat_tuple_mut(&mut self, i: &mut PatTuple) {
         visit_pat_tuple_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_pat_tuple_struct_mut(&mut self, i: &mut PatTupleStruct) {
         visit_pat_tuple_struct_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_pat_type_mut(&mut self, i: &mut PatType) {
         visit_pat_type_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_pat_wild_mut(&mut self, i: &mut PatWild) {
         visit_pat_wild_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_path_mut(&mut self, i: &mut Path) {
         visit_path_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_path_arguments_mut(&mut self, i: &mut PathArguments) {
         visit_path_arguments_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_path_segment_mut(&mut self, i: &mut PathSegment) {
         visit_path_segment_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_predicate_lifetime_mut(&mut self, i: &mut PredicateLifetime) {
         visit_predicate_lifetime_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_predicate_type_mut(&mut self, i: &mut PredicateType) {
         visit_predicate_type_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_qself_mut(&mut self, i: &mut QSelf) {
         visit_qself_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_range_limits_mut(&mut self, i: &mut RangeLimits) {
         visit_range_limits_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_receiver_mut(&mut self, i: &mut Receiver) {
         visit_receiver_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_return_type_mut(&mut self, i: &mut ReturnType) {
         visit_return_type_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_signature_mut(&mut self, i: &mut Signature) {
         visit_signature_mut(self, i);
     }
@@ -593,167 +724,208 @@ pub trait VisitMut {
         visit_span_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_static_mutability_mut(&mut self, i: &mut StaticMutability) {
         visit_static_mutability_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_stmt_mut(&mut self, i: &mut Stmt) {
         visit_stmt_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_stmt_macro_mut(&mut self, i: &mut StmtMacro) {
         visit_stmt_macro_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_trait_bound_mut(&mut self, i: &mut TraitBound) {
         visit_trait_bound_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_trait_bound_modifier_mut(&mut self, i: &mut TraitBoundModifier) {
         visit_trait_bound_modifier_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_trait_item_mut(&mut self, i: &mut TraitItem) {
         visit_trait_item_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_trait_item_const_mut(&mut self, i: &mut TraitItemConst) {
         visit_trait_item_const_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_trait_item_fn_mut(&mut self, i: &mut TraitItemFn) {
         visit_trait_item_fn_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_trait_item_macro_mut(&mut self, i: &mut TraitItemMacro) {
         visit_trait_item_macro_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_trait_item_type_mut(&mut self, i: &mut TraitItemType) {
         visit_trait_item_type_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_type_mut(&mut self, i: &mut Type) {
         visit_type_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_type_array_mut(&mut self, i: &mut TypeArray) {
         visit_type_array_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_type_bare_fn_mut(&mut self, i: &mut TypeBareFn) {
         visit_type_bare_fn_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_type_group_mut(&mut self, i: &mut TypeGroup) {
         visit_type_group_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_type_impl_trait_mut(&mut self, i: &mut TypeImplTrait) {
         visit_type_impl_trait_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_type_infer_mut(&mut self, i: &mut TypeInfer) {
         visit_type_infer_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_type_macro_mut(&mut self, i: &mut TypeMacro) {
         visit_type_macro_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_type_never_mut(&mut self, i: &mut TypeNever) {
         visit_type_never_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_type_param_mut(&mut self, i: &mut TypeParam) {
         visit_type_param_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_type_param_bound_mut(&mut self, i: &mut TypeParamBound) {
         visit_type_param_bound_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_type_paren_mut(&mut self, i: &mut TypeParen) {
         visit_type_paren_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_type_path_mut(&mut self, i: &mut TypePath) {
         visit_type_path_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_type_ptr_mut(&mut self, i: &mut TypePtr) {
         visit_type_ptr_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_type_reference_mut(&mut self, i: &mut TypeReference) {
         visit_type_reference_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_type_slice_mut(&mut self, i: &mut TypeSlice) {
         visit_type_slice_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_type_trait_object_mut(&mut self, i: &mut TypeTraitObject) {
         visit_type_trait_object_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_type_tuple_mut(&mut self, i: &mut TypeTuple) {
         visit_type_tuple_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_un_op_mut(&mut self, i: &mut UnOp) {
         visit_un_op_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_use_glob_mut(&mut self, i: &mut UseGlob) {
         visit_use_glob_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_use_group_mut(&mut self, i: &mut UseGroup) {
         visit_use_group_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_use_name_mut(&mut self, i: &mut UseName) {
         visit_use_name_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_use_path_mut(&mut self, i: &mut UsePath) {
         visit_use_path_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_use_rename_mut(&mut self, i: &mut UseRename) {
         visit_use_rename_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_use_tree_mut(&mut self, i: &mut UseTree) {
         visit_use_tree_mut(self, i);
     }
     #[cfg(feature = "full")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
     fn visit_variadic_mut(&mut self, i: &mut Variadic) {
         visit_variadic_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_variant_mut(&mut self, i: &mut Variant) {
         visit_variant_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_vis_restricted_mut(&mut self, i: &mut VisRestricted) {
         visit_vis_restricted_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_visibility_mut(&mut self, i: &mut Visibility) {
         visit_visibility_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_where_clause_mut(&mut self, i: &mut WhereClause) {
         visit_where_clause_mut(self, i);
     }
     #[cfg(any(feature = "derive", feature = "full"))]
+    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
     fn visit_where_predicate_mut(&mut self, i: &mut WherePredicate) {
         visit_where_predicate_mut(self, i);
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_abi_mut<V>(v: &mut V, node: &mut Abi)
 where
     V: VisitMut + ?Sized,
@@ -764,6 +936,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_angle_bracketed_generic_arguments_mut<V>(
     v: &mut V,
     node: &mut AngleBracketedGenericArguments,
@@ -780,6 +953,7 @@ where
     skip!(node.gt_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_arm_mut<V>(v: &mut V, node: &mut Arm)
 where
     V: VisitMut + ?Sized,
@@ -797,6 +971,7 @@ where
     skip!(node.comma);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_assoc_const_mut<V>(v: &mut V, node: &mut AssocConst)
 where
     V: VisitMut + ?Sized,
@@ -809,6 +984,7 @@ where
     v.visit_expr_mut(&mut node.value);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_assoc_type_mut<V>(v: &mut V, node: &mut AssocType)
 where
     V: VisitMut + ?Sized,
@@ -821,6 +997,7 @@ where
     v.visit_type_mut(&mut node.ty);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_attr_style_mut<V>(v: &mut V, node: &mut AttrStyle)
 where
     V: VisitMut + ?Sized,
@@ -833,6 +1010,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_attribute_mut<V>(v: &mut V, node: &mut Attribute)
 where
     V: VisitMut + ?Sized,
@@ -843,6 +1021,7 @@ where
     v.visit_meta_mut(&mut node.meta);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_bare_fn_arg_mut<V>(v: &mut V, node: &mut BareFnArg)
 where
     V: VisitMut + ?Sized,
@@ -857,6 +1036,7 @@ where
     v.visit_type_mut(&mut node.ty);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_bare_variadic_mut<V>(v: &mut V, node: &mut BareVariadic)
 where
     V: VisitMut + ?Sized,
@@ -872,6 +1052,7 @@ where
     skip!(node.comma);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_bin_op_mut<V>(v: &mut V, node: &mut BinOp)
 where
     V: VisitMut + ?Sized,
@@ -964,6 +1145,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_block_mut<V>(v: &mut V, node: &mut Block)
 where
     V: VisitMut + ?Sized,
@@ -974,6 +1156,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_bound_lifetimes_mut<V>(v: &mut V, node: &mut BoundLifetimes)
 where
     V: VisitMut + ?Sized,
@@ -987,6 +1170,7 @@ where
     skip!(node.gt_token);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_const_param_mut<V>(v: &mut V, node: &mut ConstParam)
 where
     V: VisitMut + ?Sized,
@@ -1004,6 +1188,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_constraint_mut<V>(v: &mut V, node: &mut Constraint)
 where
     V: VisitMut + ?Sized,
@@ -1019,6 +1204,7 @@ where
     }
 }
 #[cfg(feature = "derive")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
 pub fn visit_data_mut<V>(v: &mut V, node: &mut Data)
 where
     V: VisitMut + ?Sized,
@@ -1036,6 +1222,7 @@ where
     }
 }
 #[cfg(feature = "derive")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
 pub fn visit_data_enum_mut<V>(v: &mut V, node: &mut DataEnum)
 where
     V: VisitMut + ?Sized,
@@ -1048,6 +1235,7 @@ where
     }
 }
 #[cfg(feature = "derive")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
 pub fn visit_data_struct_mut<V>(v: &mut V, node: &mut DataStruct)
 where
     V: VisitMut + ?Sized,
@@ -1057,6 +1245,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "derive")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
 pub fn visit_data_union_mut<V>(v: &mut V, node: &mut DataUnion)
 where
     V: VisitMut + ?Sized,
@@ -1065,6 +1254,7 @@ where
     v.visit_fields_named_mut(&mut node.fields);
 }
 #[cfg(feature = "derive")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
 pub fn visit_derive_input_mut<V>(v: &mut V, node: &mut DeriveInput)
 where
     V: VisitMut + ?Sized,
@@ -1078,6 +1268,7 @@ where
     v.visit_data_mut(&mut node.data);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_expr_mut<V>(v: &mut V, node: &mut Expr)
 where
     V: VisitMut + ?Sized,
@@ -1203,6 +1394,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_array_mut<V>(v: &mut V, node: &mut ExprArray)
 where
     V: VisitMut + ?Sized,
@@ -1217,6 +1409,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_assign_mut<V>(v: &mut V, node: &mut ExprAssign)
 where
     V: VisitMut + ?Sized,
@@ -1229,6 +1422,7 @@ where
     v.visit_expr_mut(&mut *node.right);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_async_mut<V>(v: &mut V, node: &mut ExprAsync)
 where
     V: VisitMut + ?Sized,
@@ -1241,6 +1435,7 @@ where
     v.visit_block_mut(&mut node.block);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_await_mut<V>(v: &mut V, node: &mut ExprAwait)
 where
     V: VisitMut + ?Sized,
@@ -1253,6 +1448,7 @@ where
     skip!(node.await_token);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_expr_binary_mut<V>(v: &mut V, node: &mut ExprBinary)
 where
     V: VisitMut + ?Sized,
@@ -1265,6 +1461,7 @@ where
     v.visit_expr_mut(&mut *node.right);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_block_mut<V>(v: &mut V, node: &mut ExprBlock)
 where
     V: VisitMut + ?Sized,
@@ -1278,6 +1475,7 @@ where
     v.visit_block_mut(&mut node.block);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_break_mut<V>(v: &mut V, node: &mut ExprBreak)
 where
     V: VisitMut + ?Sized,
@@ -1294,6 +1492,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_expr_call_mut<V>(v: &mut V, node: &mut ExprCall)
 where
     V: VisitMut + ?Sized,
@@ -1309,6 +1508,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_expr_cast_mut<V>(v: &mut V, node: &mut ExprCast)
 where
     V: VisitMut + ?Sized,
@@ -1321,6 +1521,7 @@ where
     v.visit_type_mut(&mut *node.ty);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_closure_mut<V>(v: &mut V, node: &mut ExprClosure)
 where
     V: VisitMut + ?Sized,
@@ -1345,6 +1546,7 @@ where
     v.visit_expr_mut(&mut *node.body);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_const_mut<V>(v: &mut V, node: &mut ExprConst)
 where
     V: VisitMut + ?Sized,
@@ -1356,6 +1558,7 @@ where
     v.visit_block_mut(&mut node.block);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_continue_mut<V>(v: &mut V, node: &mut ExprContinue)
 where
     V: VisitMut + ?Sized,
@@ -1369,6 +1572,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_expr_field_mut<V>(v: &mut V, node: &mut ExprField)
 where
     V: VisitMut + ?Sized,
@@ -1381,6 +1585,7 @@ where
     v.visit_member_mut(&mut node.member);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_for_loop_mut<V>(v: &mut V, node: &mut ExprForLoop)
 where
     V: VisitMut + ?Sized,
@@ -1398,6 +1603,7 @@ where
     v.visit_block_mut(&mut node.body);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_expr_group_mut<V>(v: &mut V, node: &mut ExprGroup)
 where
     V: VisitMut + ?Sized,
@@ -1409,6 +1615,7 @@ where
     v.visit_expr_mut(&mut *node.expr);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_if_mut<V>(v: &mut V, node: &mut ExprIf)
 where
     V: VisitMut + ?Sized,
@@ -1425,6 +1632,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_expr_index_mut<V>(v: &mut V, node: &mut ExprIndex)
 where
     V: VisitMut + ?Sized,
@@ -1437,6 +1645,7 @@ where
     v.visit_expr_mut(&mut *node.index);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_infer_mut<V>(v: &mut V, node: &mut ExprInfer)
 where
     V: VisitMut + ?Sized,
@@ -1447,6 +1656,7 @@ where
     skip!(node.underscore_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_let_mut<V>(v: &mut V, node: &mut ExprLet)
 where
     V: VisitMut + ?Sized,
@@ -1460,6 +1670,7 @@ where
     v.visit_expr_mut(&mut *node.expr);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_expr_lit_mut<V>(v: &mut V, node: &mut ExprLit)
 where
     V: VisitMut + ?Sized,
@@ -1470,6 +1681,7 @@ where
     v.visit_lit_mut(&mut node.lit);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_loop_mut<V>(v: &mut V, node: &mut ExprLoop)
 where
     V: VisitMut + ?Sized,
@@ -1484,6 +1696,7 @@ where
     v.visit_block_mut(&mut node.body);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_expr_macro_mut<V>(v: &mut V, node: &mut ExprMacro)
 where
     V: VisitMut + ?Sized,
@@ -1494,6 +1707,7 @@ where
     v.visit_macro_mut(&mut node.mac);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_match_mut<V>(v: &mut V, node: &mut ExprMatch)
 where
     V: VisitMut + ?Sized,
@@ -1509,6 +1723,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_expr_method_call_mut<V>(v: &mut V, node: &mut ExprMethodCall)
 where
     V: VisitMut + ?Sized,
@@ -1529,6 +1744,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_expr_paren_mut<V>(v: &mut V, node: &mut ExprParen)
 where
     V: VisitMut + ?Sized,
@@ -1540,6 +1756,7 @@ where
     v.visit_expr_mut(&mut *node.expr);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_expr_path_mut<V>(v: &mut V, node: &mut ExprPath)
 where
     V: VisitMut + ?Sized,
@@ -1553,6 +1770,7 @@ where
     v.visit_path_mut(&mut node.path);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_range_mut<V>(v: &mut V, node: &mut ExprRange)
 where
     V: VisitMut + ?Sized,
@@ -1569,6 +1787,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_expr_reference_mut<V>(v: &mut V, node: &mut ExprReference)
 where
     V: VisitMut + ?Sized,
@@ -1581,6 +1800,7 @@ where
     v.visit_expr_mut(&mut *node.expr);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_repeat_mut<V>(v: &mut V, node: &mut ExprRepeat)
 where
     V: VisitMut + ?Sized,
@@ -1594,6 +1814,7 @@ where
     v.visit_expr_mut(&mut *node.len);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_return_mut<V>(v: &mut V, node: &mut ExprReturn)
 where
     V: VisitMut + ?Sized,
@@ -1607,6 +1828,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_struct_mut<V>(v: &mut V, node: &mut ExprStruct)
 where
     V: VisitMut + ?Sized,
@@ -1629,6 +1851,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_try_mut<V>(v: &mut V, node: &mut ExprTry)
 where
     V: VisitMut + ?Sized,
@@ -1640,6 +1863,7 @@ where
     skip!(node.question_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_try_block_mut<V>(v: &mut V, node: &mut ExprTryBlock)
 where
     V: VisitMut + ?Sized,
@@ -1651,6 +1875,7 @@ where
     v.visit_block_mut(&mut node.block);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_tuple_mut<V>(v: &mut V, node: &mut ExprTuple)
 where
     V: VisitMut + ?Sized,
@@ -1665,6 +1890,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_expr_unary_mut<V>(v: &mut V, node: &mut ExprUnary)
 where
     V: VisitMut + ?Sized,
@@ -1676,6 +1902,7 @@ where
     v.visit_expr_mut(&mut *node.expr);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_unsafe_mut<V>(v: &mut V, node: &mut ExprUnsafe)
 where
     V: VisitMut + ?Sized,
@@ -1687,6 +1914,7 @@ where
     v.visit_block_mut(&mut node.block);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_while_mut<V>(v: &mut V, node: &mut ExprWhile)
 where
     V: VisitMut + ?Sized,
@@ -1702,6 +1930,7 @@ where
     v.visit_block_mut(&mut node.body);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_expr_yield_mut<V>(v: &mut V, node: &mut ExprYield)
 where
     V: VisitMut + ?Sized,
@@ -1715,6 +1944,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_field_mut<V>(v: &mut V, node: &mut Field)
 where
     V: VisitMut + ?Sized,
@@ -1731,6 +1961,7 @@ where
     v.visit_type_mut(&mut node.ty);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_field_mutability_mut<V>(v: &mut V, node: &mut FieldMutability)
 where
     V: VisitMut + ?Sized,
@@ -1740,6 +1971,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_field_pat_mut<V>(v: &mut V, node: &mut FieldPat)
 where
     V: VisitMut + ?Sized,
@@ -1752,6 +1984,7 @@ where
     v.visit_pat_mut(&mut *node.pat);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_field_value_mut<V>(v: &mut V, node: &mut FieldValue)
 where
     V: VisitMut + ?Sized,
@@ -1764,6 +1997,7 @@ where
     v.visit_expr_mut(&mut node.expr);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_fields_mut<V>(v: &mut V, node: &mut Fields)
 where
     V: VisitMut + ?Sized,
@@ -1779,6 +2013,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_fields_named_mut<V>(v: &mut V, node: &mut FieldsNamed)
 where
     V: VisitMut + ?Sized,
@@ -1790,6 +2025,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_fields_unnamed_mut<V>(v: &mut V, node: &mut FieldsUnnamed)
 where
     V: VisitMut + ?Sized,
@@ -1801,6 +2037,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_file_mut<V>(v: &mut V, node: &mut File)
 where
     V: VisitMut + ?Sized,
@@ -1814,6 +2051,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_fn_arg_mut<V>(v: &mut V, node: &mut FnArg)
 where
     V: VisitMut + ?Sized,
@@ -1828,6 +2066,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_foreign_item_mut<V>(v: &mut V, node: &mut ForeignItem)
 where
     V: VisitMut + ?Sized,
@@ -1851,6 +2090,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_foreign_item_fn_mut<V>(v: &mut V, node: &mut ForeignItemFn)
 where
     V: VisitMut + ?Sized,
@@ -1863,6 +2103,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_foreign_item_macro_mut<V>(v: &mut V, node: &mut ForeignItemMacro)
 where
     V: VisitMut + ?Sized,
@@ -1874,6 +2115,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_foreign_item_static_mut<V>(v: &mut V, node: &mut ForeignItemStatic)
 where
     V: VisitMut + ?Sized,
@@ -1890,6 +2132,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_foreign_item_type_mut<V>(v: &mut V, node: &mut ForeignItemType)
 where
     V: VisitMut + ?Sized,
@@ -1904,6 +2147,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_generic_argument_mut<V>(v: &mut V, node: &mut GenericArgument)
 where
     V: VisitMut + ?Sized,
@@ -1930,6 +2174,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_generic_param_mut<V>(v: &mut V, node: &mut GenericParam)
 where
     V: VisitMut + ?Sized,
@@ -1947,6 +2192,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_generics_mut<V>(v: &mut V, node: &mut Generics)
 where
     V: VisitMut + ?Sized,
@@ -1970,6 +2216,7 @@ where
     node.set_span(span);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_impl_item_mut<V>(v: &mut V, node: &mut ImplItem)
 where
     V: VisitMut + ?Sized,
@@ -1993,6 +2240,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_impl_item_const_mut<V>(v: &mut V, node: &mut ImplItemConst)
 where
     V: VisitMut + ?Sized,
@@ -2012,6 +2260,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_impl_item_fn_mut<V>(v: &mut V, node: &mut ImplItemFn)
 where
     V: VisitMut + ?Sized,
@@ -2025,6 +2274,7 @@ where
     v.visit_block_mut(&mut node.block);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_impl_item_macro_mut<V>(v: &mut V, node: &mut ImplItemMacro)
 where
     V: VisitMut + ?Sized,
@@ -2036,6 +2286,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_impl_item_type_mut<V>(v: &mut V, node: &mut ImplItemType)
 where
     V: VisitMut + ?Sized,
@@ -2053,6 +2304,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_impl_restriction_mut<V>(v: &mut V, node: &mut ImplRestriction)
 where
     V: VisitMut + ?Sized,
@@ -2060,6 +2312,7 @@ where
     match *node {}
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_index_mut<V>(v: &mut V, node: &mut Index)
 where
     V: VisitMut + ?Sized,
@@ -2068,6 +2321,7 @@ where
     v.visit_span_mut(&mut node.span);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_item_mut<V>(v: &mut V, node: &mut Item)
 where
     V: VisitMut + ?Sized,
@@ -2124,6 +2378,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_item_const_mut<V>(v: &mut V, node: &mut ItemConst)
 where
     V: VisitMut + ?Sized,
@@ -2142,6 +2397,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_item_enum_mut<V>(v: &mut V, node: &mut ItemEnum)
 where
     V: VisitMut + ?Sized,
@@ -2160,6 +2416,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_item_extern_crate_mut<V>(v: &mut V, node: &mut ItemExternCrate)
 where
     V: VisitMut + ?Sized,
@@ -2178,6 +2435,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_item_fn_mut<V>(v: &mut V, node: &mut ItemFn)
 where
     V: VisitMut + ?Sized,
@@ -2190,6 +2448,7 @@ where
     v.visit_block_mut(&mut *node.block);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_item_foreign_mod_mut<V>(v: &mut V, node: &mut ItemForeignMod)
 where
     V: VisitMut + ?Sized,
@@ -2205,6 +2464,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_item_impl_mut<V>(v: &mut V, node: &mut ItemImpl)
 where
     V: VisitMut + ?Sized,
@@ -2228,6 +2488,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_item_macro_mut<V>(v: &mut V, node: &mut ItemMacro)
 where
     V: VisitMut + ?Sized,
@@ -2242,6 +2503,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_item_mod_mut<V>(v: &mut V, node: &mut ItemMod)
 where
     V: VisitMut + ?Sized,
@@ -2262,6 +2524,7 @@ where
     skip!(node.semi);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_item_static_mut<V>(v: &mut V, node: &mut ItemStatic)
 where
     V: VisitMut + ?Sized,
@@ -2280,6 +2543,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_item_struct_mut<V>(v: &mut V, node: &mut ItemStruct)
 where
     V: VisitMut + ?Sized,
@@ -2295,6 +2559,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_item_trait_mut<V>(v: &mut V, node: &mut ItemTrait)
 where
     V: VisitMut + ?Sized,
@@ -2322,6 +2587,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_item_trait_alias_mut<V>(v: &mut V, node: &mut ItemTraitAlias)
 where
     V: VisitMut + ?Sized,
@@ -2341,6 +2607,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_item_type_mut<V>(v: &mut V, node: &mut ItemType)
 where
     V: VisitMut + ?Sized,
@@ -2357,6 +2624,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_item_union_mut<V>(v: &mut V, node: &mut ItemUnion)
 where
     V: VisitMut + ?Sized,
@@ -2371,6 +2639,7 @@ where
     v.visit_fields_named_mut(&mut node.fields);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_item_use_mut<V>(v: &mut V, node: &mut ItemUse)
 where
     V: VisitMut + ?Sized,
@@ -2385,6 +2654,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_label_mut<V>(v: &mut V, node: &mut Label)
 where
     V: VisitMut + ?Sized,
@@ -2400,6 +2670,7 @@ where
     v.visit_ident_mut(&mut node.ident);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_lifetime_param_mut<V>(v: &mut V, node: &mut LifetimeParam)
 where
     V: VisitMut + ?Sized,
@@ -2477,6 +2748,7 @@ where
     V: VisitMut + ?Sized,
 {}
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_local_mut<V>(v: &mut V, node: &mut Local)
 where
     V: VisitMut + ?Sized,
@@ -2492,6 +2764,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_local_init_mut<V>(v: &mut V, node: &mut LocalInit)
 where
     V: VisitMut + ?Sized,
@@ -2504,6 +2777,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_macro_mut<V>(v: &mut V, node: &mut Macro)
 where
     V: VisitMut + ?Sized,
@@ -2514,6 +2788,7 @@ where
     skip!(node.tokens);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_macro_delimiter_mut<V>(v: &mut V, node: &mut MacroDelimiter)
 where
     V: VisitMut + ?Sized,
@@ -2531,6 +2806,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_member_mut<V>(v: &mut V, node: &mut Member)
 where
     V: VisitMut + ?Sized,
@@ -2545,6 +2821,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_meta_mut<V>(v: &mut V, node: &mut Meta)
 where
     V: VisitMut + ?Sized,
@@ -2562,6 +2839,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_meta_list_mut<V>(v: &mut V, node: &mut MetaList)
 where
     V: VisitMut + ?Sized,
@@ -2571,6 +2849,7 @@ where
     skip!(node.tokens);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_meta_name_value_mut<V>(v: &mut V, node: &mut MetaNameValue)
 where
     V: VisitMut + ?Sized,
@@ -2580,6 +2859,7 @@ where
     v.visit_expr_mut(&mut node.value);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_parenthesized_generic_arguments_mut<V>(
     v: &mut V,
     node: &mut ParenthesizedGenericArguments,
@@ -2595,6 +2875,7 @@ where
     v.visit_return_type_mut(&mut node.output);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_pat_mut<V>(v: &mut V, node: &mut Pat)
 where
     V: VisitMut + ?Sized,
@@ -2654,6 +2935,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_pat_ident_mut<V>(v: &mut V, node: &mut PatIdent)
 where
     V: VisitMut + ?Sized,
@@ -2670,6 +2952,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_pat_or_mut<V>(v: &mut V, node: &mut PatOr)
 where
     V: VisitMut + ?Sized,
@@ -2684,6 +2967,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_pat_paren_mut<V>(v: &mut V, node: &mut PatParen)
 where
     V: VisitMut + ?Sized,
@@ -2695,6 +2979,7 @@ where
     v.visit_pat_mut(&mut *node.pat);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_pat_reference_mut<V>(v: &mut V, node: &mut PatReference)
 where
     V: VisitMut + ?Sized,
@@ -2707,6 +2992,7 @@ where
     v.visit_pat_mut(&mut *node.pat);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_pat_rest_mut<V>(v: &mut V, node: &mut PatRest)
 where
     V: VisitMut + ?Sized,
@@ -2717,6 +3003,7 @@ where
     skip!(node.dot2_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_pat_slice_mut<V>(v: &mut V, node: &mut PatSlice)
 where
     V: VisitMut + ?Sized,
@@ -2731,6 +3018,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_pat_struct_mut<V>(v: &mut V, node: &mut PatStruct)
 where
     V: VisitMut + ?Sized,
@@ -2752,6 +3040,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_pat_tuple_mut<V>(v: &mut V, node: &mut PatTuple)
 where
     V: VisitMut + ?Sized,
@@ -2766,6 +3055,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_pat_tuple_struct_mut<V>(v: &mut V, node: &mut PatTupleStruct)
 where
     V: VisitMut + ?Sized,
@@ -2784,6 +3074,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_pat_type_mut<V>(v: &mut V, node: &mut PatType)
 where
     V: VisitMut + ?Sized,
@@ -2796,6 +3087,7 @@ where
     v.visit_type_mut(&mut *node.ty);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_pat_wild_mut<V>(v: &mut V, node: &mut PatWild)
 where
     V: VisitMut + ?Sized,
@@ -2806,6 +3098,7 @@ where
     skip!(node.underscore_token);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_path_mut<V>(v: &mut V, node: &mut Path)
 where
     V: VisitMut + ?Sized,
@@ -2817,6 +3110,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_path_arguments_mut<V>(v: &mut V, node: &mut PathArguments)
 where
     V: VisitMut + ?Sized,
@@ -2832,6 +3126,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_path_segment_mut<V>(v: &mut V, node: &mut PathSegment)
 where
     V: VisitMut + ?Sized,
@@ -2840,6 +3135,7 @@ where
     v.visit_path_arguments_mut(&mut node.arguments);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_predicate_lifetime_mut<V>(v: &mut V, node: &mut PredicateLifetime)
 where
     V: VisitMut + ?Sized,
@@ -2852,6 +3148,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_predicate_type_mut<V>(v: &mut V, node: &mut PredicateType)
 where
     V: VisitMut + ?Sized,
@@ -2867,6 +3164,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_qself_mut<V>(v: &mut V, node: &mut QSelf)
 where
     V: VisitMut + ?Sized,
@@ -2878,6 +3176,7 @@ where
     skip!(node.gt_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_range_limits_mut<V>(v: &mut V, node: &mut RangeLimits)
 where
     V: VisitMut + ?Sized,
@@ -2892,6 +3191,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_receiver_mut<V>(v: &mut V, node: &mut Receiver)
 where
     V: VisitMut + ?Sized,
@@ -2911,6 +3211,7 @@ where
     v.visit_type_mut(&mut *node.ty);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_return_type_mut<V>(v: &mut V, node: &mut ReturnType)
 where
     V: VisitMut + ?Sized,
@@ -2924,6 +3225,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_signature_mut<V>(v: &mut V, node: &mut Signature)
 where
     V: VisitMut + ?Sized,
@@ -2952,6 +3254,7 @@ where
     V: VisitMut + ?Sized,
 {}
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_static_mutability_mut<V>(v: &mut V, node: &mut StaticMutability)
 where
     V: VisitMut + ?Sized,
@@ -2964,6 +3267,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_stmt_mut<V>(v: &mut V, node: &mut Stmt)
 where
     V: VisitMut + ?Sized,
@@ -2985,6 +3289,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_stmt_macro_mut<V>(v: &mut V, node: &mut StmtMacro)
 where
     V: VisitMut + ?Sized,
@@ -2996,6 +3301,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_trait_bound_mut<V>(v: &mut V, node: &mut TraitBound)
 where
     V: VisitMut + ?Sized,
@@ -3008,6 +3314,7 @@ where
     v.visit_path_mut(&mut node.path);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_trait_bound_modifier_mut<V>(v: &mut V, node: &mut TraitBoundModifier)
 where
     V: VisitMut + ?Sized,
@@ -3020,6 +3327,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_trait_item_mut<V>(v: &mut V, node: &mut TraitItem)
 where
     V: VisitMut + ?Sized,
@@ -3043,6 +3351,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_trait_item_const_mut<V>(v: &mut V, node: &mut TraitItemConst)
 where
     V: VisitMut + ?Sized,
@@ -3062,6 +3371,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_trait_item_fn_mut<V>(v: &mut V, node: &mut TraitItemFn)
 where
     V: VisitMut + ?Sized,
@@ -3076,6 +3386,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_trait_item_macro_mut<V>(v: &mut V, node: &mut TraitItemMacro)
 where
     V: VisitMut + ?Sized,
@@ -3087,6 +3398,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_trait_item_type_mut<V>(v: &mut V, node: &mut TraitItemType)
 where
     V: VisitMut + ?Sized,
@@ -3109,6 +3421,7 @@ where
     skip!(node.semi_token);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_type_mut<V>(v: &mut V, node: &mut Type)
 where
     V: VisitMut + ?Sized,
@@ -3162,6 +3475,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_type_array_mut<V>(v: &mut V, node: &mut TypeArray)
 where
     V: VisitMut + ?Sized,
@@ -3172,6 +3486,7 @@ where
     v.visit_expr_mut(&mut node.len);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_type_bare_fn_mut<V>(v: &mut V, node: &mut TypeBareFn)
 where
     V: VisitMut + ?Sized,
@@ -3195,6 +3510,7 @@ where
     v.visit_return_type_mut(&mut node.output);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_type_group_mut<V>(v: &mut V, node: &mut TypeGroup)
 where
     V: VisitMut + ?Sized,
@@ -3203,6 +3519,7 @@ where
     v.visit_type_mut(&mut *node.elem);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_type_impl_trait_mut<V>(v: &mut V, node: &mut TypeImplTrait)
 where
     V: VisitMut + ?Sized,
@@ -3214,6 +3531,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_type_infer_mut<V>(v: &mut V, node: &mut TypeInfer)
 where
     V: VisitMut + ?Sized,
@@ -3221,6 +3539,7 @@ where
     skip!(node.underscore_token);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_type_macro_mut<V>(v: &mut V, node: &mut TypeMacro)
 where
     V: VisitMut + ?Sized,
@@ -3228,6 +3547,7 @@ where
     v.visit_macro_mut(&mut node.mac);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_type_never_mut<V>(v: &mut V, node: &mut TypeNever)
 where
     V: VisitMut + ?Sized,
@@ -3235,6 +3555,7 @@ where
     skip!(node.bang_token);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_type_param_mut<V>(v: &mut V, node: &mut TypeParam)
 where
     V: VisitMut + ?Sized,
@@ -3254,6 +3575,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_type_param_bound_mut<V>(v: &mut V, node: &mut TypeParamBound)
 where
     V: VisitMut + ?Sized,
@@ -3271,6 +3593,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_type_paren_mut<V>(v: &mut V, node: &mut TypeParen)
 where
     V: VisitMut + ?Sized,
@@ -3279,6 +3602,7 @@ where
     v.visit_type_mut(&mut *node.elem);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_type_path_mut<V>(v: &mut V, node: &mut TypePath)
 where
     V: VisitMut + ?Sized,
@@ -3289,6 +3613,7 @@ where
     v.visit_path_mut(&mut node.path);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_type_ptr_mut<V>(v: &mut V, node: &mut TypePtr)
 where
     V: VisitMut + ?Sized,
@@ -3299,6 +3624,7 @@ where
     v.visit_type_mut(&mut *node.elem);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_type_reference_mut<V>(v: &mut V, node: &mut TypeReference)
 where
     V: VisitMut + ?Sized,
@@ -3311,6 +3637,7 @@ where
     v.visit_type_mut(&mut *node.elem);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_type_slice_mut<V>(v: &mut V, node: &mut TypeSlice)
 where
     V: VisitMut + ?Sized,
@@ -3319,6 +3646,7 @@ where
     v.visit_type_mut(&mut *node.elem);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_type_trait_object_mut<V>(v: &mut V, node: &mut TypeTraitObject)
 where
     V: VisitMut + ?Sized,
@@ -3330,6 +3658,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_type_tuple_mut<V>(v: &mut V, node: &mut TypeTuple)
 where
     V: VisitMut + ?Sized,
@@ -3341,6 +3670,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_un_op_mut<V>(v: &mut V, node: &mut UnOp)
 where
     V: VisitMut + ?Sized,
@@ -3358,6 +3688,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_use_glob_mut<V>(v: &mut V, node: &mut UseGlob)
 where
     V: VisitMut + ?Sized,
@@ -3365,6 +3696,7 @@ where
     skip!(node.star_token);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_use_group_mut<V>(v: &mut V, node: &mut UseGroup)
 where
     V: VisitMut + ?Sized,
@@ -3376,6 +3708,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_use_name_mut<V>(v: &mut V, node: &mut UseName)
 where
     V: VisitMut + ?Sized,
@@ -3383,6 +3716,7 @@ where
     v.visit_ident_mut(&mut node.ident);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_use_path_mut<V>(v: &mut V, node: &mut UsePath)
 where
     V: VisitMut + ?Sized,
@@ -3392,6 +3726,7 @@ where
     v.visit_use_tree_mut(&mut *node.tree);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_use_rename_mut<V>(v: &mut V, node: &mut UseRename)
 where
     V: VisitMut + ?Sized,
@@ -3401,6 +3736,7 @@ where
     v.visit_ident_mut(&mut node.rename);
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_use_tree_mut<V>(v: &mut V, node: &mut UseTree)
 where
     V: VisitMut + ?Sized,
@@ -3424,6 +3760,7 @@ where
     }
 }
 #[cfg(feature = "full")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
 pub fn visit_variadic_mut<V>(v: &mut V, node: &mut Variadic)
 where
     V: VisitMut + ?Sized,
@@ -3439,6 +3776,7 @@ where
     skip!(node.comma);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_variant_mut<V>(v: &mut V, node: &mut Variant)
 where
     V: VisitMut + ?Sized,
@@ -3454,6 +3792,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_vis_restricted_mut<V>(v: &mut V, node: &mut VisRestricted)
 where
     V: VisitMut + ?Sized,
@@ -3464,6 +3803,7 @@ where
     v.visit_path_mut(&mut *node.path);
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_visibility_mut<V>(v: &mut V, node: &mut Visibility)
 where
     V: VisitMut + ?Sized,
@@ -3479,6 +3819,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_where_clause_mut<V>(v: &mut V, node: &mut WhereClause)
 where
     V: VisitMut + ?Sized,
@@ -3490,6 +3831,7 @@ where
     }
 }
 #[cfg(any(feature = "derive", feature = "full"))]
+#[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
 pub fn visit_where_predicate_mut<V>(v: &mut V, node: &mut WherePredicate)
 where
     V: VisitMut + ?Sized,