diff --git a/Cargo.toml b/Cargo.toml
index 5ac44c9..16b72d0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -16,6 +16,7 @@
 parsing = ["quote", "synom/parsing"]
 printing = ["quote", "synom/printing"]
 visit = []
+visit_mut = []
 fold = []
 clone-impls = ["synom/clone-impls"]
 extra-traits = ["synom/extra-traits"]
diff --git a/src/gen/fold.rs b/src/gen/fold.rs
index 6f5e77f..459370f 100644
--- a/src/gen/fold.rs
+++ b/src/gen/fold.rs
@@ -7,7 +7,7 @@
 // Unreachable code is generated sometimes without the full feature.
 #![allow(unreachable_code)]
 
-use super::*;
+use *;
 use synom::delimited::Delimited;
 
 trait FoldHelper {
@@ -58,357 +58,357 @@
 /// new default implementation gets introduced.)
 pub trait Folder {
 
-fn fold_abi(&mut self, i: Abi) -> Abi { walk_abi(self, i) }
+fn fold_abi(&mut self, i: Abi) -> Abi { fold_abi(self, i) }
 
-fn fold_abi_kind(&mut self, i: AbiKind) -> AbiKind { walk_abi_kind(self, i) }
+fn fold_abi_kind(&mut self, i: AbiKind) -> AbiKind { fold_abi_kind(self, i) }
 
-fn fold_angle_bracketed_parameter_data(&mut self, i: AngleBracketedParameterData) -> AngleBracketedParameterData { walk_angle_bracketed_parameter_data(self, i) }
+fn fold_angle_bracketed_parameter_data(&mut self, i: AngleBracketedParameterData) -> AngleBracketedParameterData { fold_angle_bracketed_parameter_data(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_arg_captured(&mut self, i: ArgCaptured) -> ArgCaptured { walk_arg_captured(self, i) }
+fn fold_arg_captured(&mut self, i: ArgCaptured) -> ArgCaptured { fold_arg_captured(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_arg_self(&mut self, i: ArgSelf) -> ArgSelf { walk_arg_self(self, i) }
+fn fold_arg_self(&mut self, i: ArgSelf) -> ArgSelf { fold_arg_self(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_arg_self_ref(&mut self, i: ArgSelfRef) -> ArgSelfRef { walk_arg_self_ref(self, i) }
+fn fold_arg_self_ref(&mut self, i: ArgSelfRef) -> ArgSelfRef { fold_arg_self_ref(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_arm(&mut self, i: Arm) -> Arm { walk_arm(self, i) }
+fn fold_arm(&mut self, i: Arm) -> Arm { fold_arm(self, i) }
 
-fn fold_attr_style(&mut self, i: AttrStyle) -> AttrStyle { walk_attr_style(self, i) }
+fn fold_attr_style(&mut self, i: AttrStyle) -> AttrStyle { fold_attr_style(self, i) }
 
-fn fold_attribute(&mut self, i: Attribute) -> Attribute { walk_attribute(self, i) }
+fn fold_attribute(&mut self, i: Attribute) -> Attribute { fold_attribute(self, i) }
 
-fn fold_bare_fn_arg(&mut self, i: BareFnArg) -> BareFnArg { walk_bare_fn_arg(self, i) }
+fn fold_bare_fn_arg(&mut self, i: BareFnArg) -> BareFnArg { fold_bare_fn_arg(self, i) }
 
-fn fold_bare_fn_arg_name(&mut self, i: BareFnArgName) -> BareFnArgName { walk_bare_fn_arg_name(self, i) }
+fn fold_bare_fn_arg_name(&mut self, i: BareFnArgName) -> BareFnArgName { fold_bare_fn_arg_name(self, i) }
 
-fn fold_bare_fn_ty(&mut self, i: BareFnTy) -> BareFnTy { walk_bare_fn_ty(self, i) }
+fn fold_bare_fn_ty(&mut self, i: BareFnTy) -> BareFnTy { fold_bare_fn_ty(self, i) }
 
-fn fold_bin_op(&mut self, i: BinOp) -> BinOp { walk_bin_op(self, i) }
+fn fold_bin_op(&mut self, i: BinOp) -> BinOp { fold_bin_op(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_binding_mode(&mut self, i: BindingMode) -> BindingMode { walk_binding_mode(self, i) }
+fn fold_binding_mode(&mut self, i: BindingMode) -> BindingMode { fold_binding_mode(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_block(&mut self, i: Block) -> Block { walk_block(self, i) }
+fn fold_block(&mut self, i: Block) -> Block { fold_block(self, i) }
 
-fn fold_body(&mut self, i: Body) -> Body { walk_body(self, i) }
+fn fold_body(&mut self, i: Body) -> Body { fold_body(self, i) }
 
-fn fold_body_enum(&mut self, i: BodyEnum) -> BodyEnum { walk_body_enum(self, i) }
+fn fold_body_enum(&mut self, i: BodyEnum) -> BodyEnum { fold_body_enum(self, i) }
 
-fn fold_body_struct(&mut self, i: BodyStruct) -> BodyStruct { walk_body_struct(self, i) }
+fn fold_body_struct(&mut self, i: BodyStruct) -> BodyStruct { fold_body_struct(self, i) }
 
-fn fold_bound_lifetimes(&mut self, i: BoundLifetimes) -> BoundLifetimes { walk_bound_lifetimes(self, i) }
+fn fold_bound_lifetimes(&mut self, i: BoundLifetimes) -> BoundLifetimes { fold_bound_lifetimes(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_capture_by(&mut self, i: CaptureBy) -> CaptureBy { walk_capture_by(self, i) }
+fn fold_capture_by(&mut self, i: CaptureBy) -> CaptureBy { fold_capture_by(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_constness(&mut self, i: Constness) -> Constness { walk_constness(self, i) }
+fn fold_constness(&mut self, i: Constness) -> Constness { fold_constness(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_defaultness(&mut self, i: Defaultness) -> Defaultness { walk_defaultness(self, i) }
+fn fold_defaultness(&mut self, i: Defaultness) -> Defaultness { fold_defaultness(self, i) }
 
-fn fold_derive_input(&mut self, i: DeriveInput) -> DeriveInput { walk_derive_input(self, i) }
+fn fold_derive_input(&mut self, i: DeriveInput) -> DeriveInput { fold_derive_input(self, i) }
 
-fn fold_expr(&mut self, i: Expr) -> Expr { walk_expr(self, i) }
+fn fold_expr(&mut self, i: Expr) -> Expr { fold_expr(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_expr_addr_of(&mut self, i: ExprAddrOf) -> ExprAddrOf { walk_expr_addr_of(self, i) }
+fn fold_expr_addr_of(&mut self, i: ExprAddrOf) -> ExprAddrOf { fold_expr_addr_of(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_expr_array(&mut self, i: ExprArray) -> ExprArray { walk_expr_array(self, i) }
+fn fold_expr_array(&mut self, i: ExprArray) -> ExprArray { fold_expr_array(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_expr_assign(&mut self, i: ExprAssign) -> ExprAssign { walk_expr_assign(self, i) }
+fn fold_expr_assign(&mut self, i: ExprAssign) -> ExprAssign { fold_expr_assign(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_expr_assign_op(&mut self, i: ExprAssignOp) -> ExprAssignOp { walk_expr_assign_op(self, i) }
+fn fold_expr_assign_op(&mut self, i: ExprAssignOp) -> ExprAssignOp { fold_expr_assign_op(self, i) }
 
-fn fold_expr_binary(&mut self, i: ExprBinary) -> ExprBinary { walk_expr_binary(self, i) }
+fn fold_expr_binary(&mut self, i: ExprBinary) -> ExprBinary { fold_expr_binary(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_expr_block(&mut self, i: ExprBlock) -> ExprBlock { walk_expr_block(self, i) }
+fn fold_expr_block(&mut self, i: ExprBlock) -> ExprBlock { fold_expr_block(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_expr_box(&mut self, i: ExprBox) -> ExprBox { walk_expr_box(self, i) }
+fn fold_expr_box(&mut self, i: ExprBox) -> ExprBox { fold_expr_box(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_expr_break(&mut self, i: ExprBreak) -> ExprBreak { walk_expr_break(self, i) }
+fn fold_expr_break(&mut self, i: ExprBreak) -> ExprBreak { fold_expr_break(self, i) }
 
-fn fold_expr_call(&mut self, i: ExprCall) -> ExprCall { walk_expr_call(self, i) }
+fn fold_expr_call(&mut self, i: ExprCall) -> ExprCall { fold_expr_call(self, i) }
 
-fn fold_expr_cast(&mut self, i: ExprCast) -> ExprCast { walk_expr_cast(self, i) }
+fn fold_expr_cast(&mut self, i: ExprCast) -> ExprCast { fold_expr_cast(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_expr_catch(&mut self, i: ExprCatch) -> ExprCatch { walk_expr_catch(self, i) }
+fn fold_expr_catch(&mut self, i: ExprCatch) -> ExprCatch { fold_expr_catch(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_expr_closure(&mut self, i: ExprClosure) -> ExprClosure { walk_expr_closure(self, i) }
+fn fold_expr_closure(&mut self, i: ExprClosure) -> ExprClosure { fold_expr_closure(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_expr_continue(&mut self, i: ExprContinue) -> ExprContinue { walk_expr_continue(self, i) }
+fn fold_expr_continue(&mut self, i: ExprContinue) -> ExprContinue { fold_expr_continue(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_expr_field(&mut self, i: ExprField) -> ExprField { walk_expr_field(self, i) }
+fn fold_expr_field(&mut self, i: ExprField) -> ExprField { fold_expr_field(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_expr_for_loop(&mut self, i: ExprForLoop) -> ExprForLoop { walk_expr_for_loop(self, i) }
+fn fold_expr_for_loop(&mut self, i: ExprForLoop) -> ExprForLoop { fold_expr_for_loop(self, i) }
 
-fn fold_expr_group(&mut self, i: ExprGroup) -> ExprGroup { walk_expr_group(self, i) }
+fn fold_expr_group(&mut self, i: ExprGroup) -> ExprGroup { fold_expr_group(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_expr_if(&mut self, i: ExprIf) -> ExprIf { walk_expr_if(self, i) }
+fn fold_expr_if(&mut self, i: ExprIf) -> ExprIf { fold_expr_if(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_expr_if_let(&mut self, i: ExprIfLet) -> ExprIfLet { walk_expr_if_let(self, i) }
+fn fold_expr_if_let(&mut self, i: ExprIfLet) -> ExprIfLet { fold_expr_if_let(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_expr_in_place(&mut self, i: ExprInPlace) -> ExprInPlace { walk_expr_in_place(self, i) }
+fn fold_expr_in_place(&mut self, i: ExprInPlace) -> ExprInPlace { fold_expr_in_place(self, i) }
 
-fn fold_expr_index(&mut self, i: ExprIndex) -> ExprIndex { walk_expr_index(self, i) }
+fn fold_expr_index(&mut self, i: ExprIndex) -> ExprIndex { fold_expr_index(self, i) }
 
-fn fold_expr_kind(&mut self, i: ExprKind) -> ExprKind { walk_expr_kind(self, i) }
+fn fold_expr_kind(&mut self, i: ExprKind) -> ExprKind { fold_expr_kind(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_expr_loop(&mut self, i: ExprLoop) -> ExprLoop { walk_expr_loop(self, i) }
+fn fold_expr_loop(&mut self, i: ExprLoop) -> ExprLoop { fold_expr_loop(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_expr_match(&mut self, i: ExprMatch) -> ExprMatch { walk_expr_match(self, i) }
+fn fold_expr_match(&mut self, i: ExprMatch) -> ExprMatch { fold_expr_match(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_expr_method_call(&mut self, i: ExprMethodCall) -> ExprMethodCall { walk_expr_method_call(self, i) }
+fn fold_expr_method_call(&mut self, i: ExprMethodCall) -> ExprMethodCall { fold_expr_method_call(self, i) }
 
-fn fold_expr_paren(&mut self, i: ExprParen) -> ExprParen { walk_expr_paren(self, i) }
+fn fold_expr_paren(&mut self, i: ExprParen) -> ExprParen { fold_expr_paren(self, i) }
 
-fn fold_expr_path(&mut self, i: ExprPath) -> ExprPath { walk_expr_path(self, i) }
+fn fold_expr_path(&mut self, i: ExprPath) -> ExprPath { fold_expr_path(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_expr_range(&mut self, i: ExprRange) -> ExprRange { walk_expr_range(self, i) }
+fn fold_expr_range(&mut self, i: ExprRange) -> ExprRange { fold_expr_range(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_expr_repeat(&mut self, i: ExprRepeat) -> ExprRepeat { walk_expr_repeat(self, i) }
+fn fold_expr_repeat(&mut self, i: ExprRepeat) -> ExprRepeat { fold_expr_repeat(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_expr_ret(&mut self, i: ExprRet) -> ExprRet { walk_expr_ret(self, i) }
+fn fold_expr_ret(&mut self, i: ExprRet) -> ExprRet { fold_expr_ret(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_expr_struct(&mut self, i: ExprStruct) -> ExprStruct { walk_expr_struct(self, i) }
+fn fold_expr_struct(&mut self, i: ExprStruct) -> ExprStruct { fold_expr_struct(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_expr_try(&mut self, i: ExprTry) -> ExprTry { walk_expr_try(self, i) }
+fn fold_expr_try(&mut self, i: ExprTry) -> ExprTry { fold_expr_try(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_expr_tup(&mut self, i: ExprTup) -> ExprTup { walk_expr_tup(self, i) }
+fn fold_expr_tup(&mut self, i: ExprTup) -> ExprTup { fold_expr_tup(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_expr_tup_field(&mut self, i: ExprTupField) -> ExprTupField { walk_expr_tup_field(self, i) }
+fn fold_expr_tup_field(&mut self, i: ExprTupField) -> ExprTupField { fold_expr_tup_field(self, i) }
 
-fn fold_expr_type(&mut self, i: ExprType) -> ExprType { walk_expr_type(self, i) }
+fn fold_expr_type(&mut self, i: ExprType) -> ExprType { fold_expr_type(self, i) }
 
-fn fold_expr_unary(&mut self, i: ExprUnary) -> ExprUnary { walk_expr_unary(self, i) }
+fn fold_expr_unary(&mut self, i: ExprUnary) -> ExprUnary { fold_expr_unary(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_expr_while(&mut self, i: ExprWhile) -> ExprWhile { walk_expr_while(self, i) }
+fn fold_expr_while(&mut self, i: ExprWhile) -> ExprWhile { fold_expr_while(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_expr_while_let(&mut self, i: ExprWhileLet) -> ExprWhileLet { walk_expr_while_let(self, i) }
+fn fold_expr_while_let(&mut self, i: ExprWhileLet) -> ExprWhileLet { fold_expr_while_let(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_expr_yield(&mut self, i: ExprYield) -> ExprYield { walk_expr_yield(self, i) }
+fn fold_expr_yield(&mut self, i: ExprYield) -> ExprYield { fold_expr_yield(self, i) }
 
-fn fold_field(&mut self, i: Field) -> Field { walk_field(self, i) }
+fn fold_field(&mut self, i: Field) -> Field { fold_field(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_field_pat(&mut self, i: FieldPat) -> FieldPat { walk_field_pat(self, i) }
+fn fold_field_pat(&mut self, i: FieldPat) -> FieldPat { fold_field_pat(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_field_value(&mut self, i: FieldValue) -> FieldValue { walk_field_value(self, i) }
+fn fold_field_value(&mut self, i: FieldValue) -> FieldValue { fold_field_value(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_file(&mut self, i: File) -> File { walk_file(self, i) }
+fn fold_file(&mut self, i: File) -> File { fold_file(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_fn_arg(&mut self, i: FnArg) -> FnArg { walk_fn_arg(self, i) }
+fn fold_fn_arg(&mut self, i: FnArg) -> FnArg { fold_fn_arg(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_fn_decl(&mut self, i: FnDecl) -> FnDecl { walk_fn_decl(self, i) }
+fn fold_fn_decl(&mut self, i: FnDecl) -> FnDecl { fold_fn_decl(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_foreign_item(&mut self, i: ForeignItem) -> ForeignItem { walk_foreign_item(self, i) }
+fn fold_foreign_item(&mut self, i: ForeignItem) -> ForeignItem { fold_foreign_item(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_foreign_item_fn(&mut self, i: ForeignItemFn) -> ForeignItemFn { walk_foreign_item_fn(self, i) }
+fn fold_foreign_item_fn(&mut self, i: ForeignItemFn) -> ForeignItemFn { fold_foreign_item_fn(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_foreign_item_kind(&mut self, i: ForeignItemKind) -> ForeignItemKind { walk_foreign_item_kind(self, i) }
+fn fold_foreign_item_kind(&mut self, i: ForeignItemKind) -> ForeignItemKind { fold_foreign_item_kind(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_foreign_item_static(&mut self, i: ForeignItemStatic) -> ForeignItemStatic { walk_foreign_item_static(self, i) }
+fn fold_foreign_item_static(&mut self, i: ForeignItemStatic) -> ForeignItemStatic { fold_foreign_item_static(self, i) }
 
-fn fold_function_ret_ty(&mut self, i: FunctionRetTy) -> FunctionRetTy { walk_function_ret_ty(self, i) }
+fn fold_function_ret_ty(&mut self, i: FunctionRetTy) -> FunctionRetTy { fold_function_ret_ty(self, i) }
 
-fn fold_generics(&mut self, i: Generics) -> Generics { walk_generics(self, i) }
+fn fold_generics(&mut self, i: Generics) -> Generics { fold_generics(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_impl_item(&mut self, i: ImplItem) -> ImplItem { walk_impl_item(self, i) }
+fn fold_impl_item(&mut self, i: ImplItem) -> ImplItem { fold_impl_item(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_impl_item_const(&mut self, i: ImplItemConst) -> ImplItemConst { walk_impl_item_const(self, i) }
+fn fold_impl_item_const(&mut self, i: ImplItemConst) -> ImplItemConst { fold_impl_item_const(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_impl_item_kind(&mut self, i: ImplItemKind) -> ImplItemKind { walk_impl_item_kind(self, i) }
+fn fold_impl_item_kind(&mut self, i: ImplItemKind) -> ImplItemKind { fold_impl_item_kind(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_impl_item_method(&mut self, i: ImplItemMethod) -> ImplItemMethod { walk_impl_item_method(self, i) }
+fn fold_impl_item_method(&mut self, i: ImplItemMethod) -> ImplItemMethod { fold_impl_item_method(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_impl_item_type(&mut self, i: ImplItemType) -> ImplItemType { walk_impl_item_type(self, i) }
+fn fold_impl_item_type(&mut self, i: ImplItemType) -> ImplItemType { fold_impl_item_type(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_impl_polarity(&mut self, i: ImplPolarity) -> ImplPolarity { walk_impl_polarity(self, i) }
+fn fold_impl_polarity(&mut self, i: ImplPolarity) -> ImplPolarity { fold_impl_polarity(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_in_place_kind(&mut self, i: InPlaceKind) -> InPlaceKind { walk_in_place_kind(self, i) }
+fn fold_in_place_kind(&mut self, i: InPlaceKind) -> InPlaceKind { fold_in_place_kind(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_item(&mut self, i: Item) -> Item { walk_item(self, i) }
+fn fold_item(&mut self, i: Item) -> Item { fold_item(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_item_const(&mut self, i: ItemConst) -> ItemConst { walk_item_const(self, i) }
+fn fold_item_const(&mut self, i: ItemConst) -> ItemConst { fold_item_const(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_item_default_impl(&mut self, i: ItemDefaultImpl) -> ItemDefaultImpl { walk_item_default_impl(self, i) }
+fn fold_item_default_impl(&mut self, i: ItemDefaultImpl) -> ItemDefaultImpl { fold_item_default_impl(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_item_enum(&mut self, i: ItemEnum) -> ItemEnum { walk_item_enum(self, i) }
+fn fold_item_enum(&mut self, i: ItemEnum) -> ItemEnum { fold_item_enum(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_item_extern_crate(&mut self, i: ItemExternCrate) -> ItemExternCrate { walk_item_extern_crate(self, i) }
+fn fold_item_extern_crate(&mut self, i: ItemExternCrate) -> ItemExternCrate { fold_item_extern_crate(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_item_fn(&mut self, i: ItemFn) -> ItemFn { walk_item_fn(self, i) }
+fn fold_item_fn(&mut self, i: ItemFn) -> ItemFn { fold_item_fn(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_item_foreign_mod(&mut self, i: ItemForeignMod) -> ItemForeignMod { walk_item_foreign_mod(self, i) }
+fn fold_item_foreign_mod(&mut self, i: ItemForeignMod) -> ItemForeignMod { fold_item_foreign_mod(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_item_impl(&mut self, i: ItemImpl) -> ItemImpl { walk_item_impl(self, i) }
+fn fold_item_impl(&mut self, i: ItemImpl) -> ItemImpl { fold_item_impl(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_item_kind(&mut self, i: ItemKind) -> ItemKind { walk_item_kind(self, i) }
+fn fold_item_kind(&mut self, i: ItemKind) -> ItemKind { fold_item_kind(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_item_mod(&mut self, i: ItemMod) -> ItemMod { walk_item_mod(self, i) }
+fn fold_item_mod(&mut self, i: ItemMod) -> ItemMod { fold_item_mod(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_item_static(&mut self, i: ItemStatic) -> ItemStatic { walk_item_static(self, i) }
+fn fold_item_static(&mut self, i: ItemStatic) -> ItemStatic { fold_item_static(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_item_struct(&mut self, i: ItemStruct) -> ItemStruct { walk_item_struct(self, i) }
+fn fold_item_struct(&mut self, i: ItemStruct) -> ItemStruct { fold_item_struct(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_item_trait(&mut self, i: ItemTrait) -> ItemTrait { walk_item_trait(self, i) }
+fn fold_item_trait(&mut self, i: ItemTrait) -> ItemTrait { fold_item_trait(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_item_ty(&mut self, i: ItemTy) -> ItemTy { walk_item_ty(self, i) }
+fn fold_item_ty(&mut self, i: ItemTy) -> ItemTy { fold_item_ty(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_item_union(&mut self, i: ItemUnion) -> ItemUnion { walk_item_union(self, i) }
+fn fold_item_union(&mut self, i: ItemUnion) -> ItemUnion { fold_item_union(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_item_use(&mut self, i: ItemUse) -> ItemUse { walk_item_use(self, i) }
+fn fold_item_use(&mut self, i: ItemUse) -> ItemUse { fold_item_use(self, i) }
 
-fn fold_lifetime_def(&mut self, i: LifetimeDef) -> LifetimeDef { walk_lifetime_def(self, i) }
+fn fold_lifetime_def(&mut self, i: LifetimeDef) -> LifetimeDef { fold_lifetime_def(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_local(&mut self, i: Local) -> Local { walk_local(self, i) }
+fn fold_local(&mut self, i: Local) -> Local { fold_local(self, i) }
 
-fn fold_mac(&mut self, i: Mac) -> Mac { walk_mac(self, i) }
+fn fold_mac(&mut self, i: Mac) -> Mac { fold_mac(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_mac_stmt_style(&mut self, i: MacStmtStyle) -> MacStmtStyle { walk_mac_stmt_style(self, i) }
+fn fold_mac_stmt_style(&mut self, i: MacStmtStyle) -> MacStmtStyle { fold_mac_stmt_style(self, i) }
 
-fn fold_meta_item(&mut self, i: MetaItem) -> MetaItem { walk_meta_item(self, i) }
+fn fold_meta_item(&mut self, i: MetaItem) -> MetaItem { fold_meta_item(self, i) }
 
-fn fold_meta_item_list(&mut self, i: MetaItemList) -> MetaItemList { walk_meta_item_list(self, i) }
+fn fold_meta_item_list(&mut self, i: MetaItemList) -> MetaItemList { fold_meta_item_list(self, i) }
 
-fn fold_meta_name_value(&mut self, i: MetaNameValue) -> MetaNameValue { walk_meta_name_value(self, i) }
+fn fold_meta_name_value(&mut self, i: MetaNameValue) -> MetaNameValue { fold_meta_name_value(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_method_sig(&mut self, i: MethodSig) -> MethodSig { walk_method_sig(self, i) }
+fn fold_method_sig(&mut self, i: MethodSig) -> MethodSig { fold_method_sig(self, i) }
 
-fn fold_mut_ty(&mut self, i: MutTy) -> MutTy { walk_mut_ty(self, i) }
+fn fold_mut_ty(&mut self, i: MutTy) -> MutTy { fold_mut_ty(self, i) }
 
-fn fold_mutability(&mut self, i: Mutability) -> Mutability { walk_mutability(self, i) }
+fn fold_mutability(&mut self, i: Mutability) -> Mutability { fold_mutability(self, i) }
 
-fn fold_nested_meta_item(&mut self, i: NestedMetaItem) -> NestedMetaItem { walk_nested_meta_item(self, i) }
+fn fold_nested_meta_item(&mut self, i: NestedMetaItem) -> NestedMetaItem { fold_nested_meta_item(self, i) }
 
-fn fold_parenthesized_parameter_data(&mut self, i: ParenthesizedParameterData) -> ParenthesizedParameterData { walk_parenthesized_parameter_data(self, i) }
+fn fold_parenthesized_parameter_data(&mut self, i: ParenthesizedParameterData) -> ParenthesizedParameterData { fold_parenthesized_parameter_data(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_pat(&mut self, i: Pat) -> Pat { walk_pat(self, i) }
+fn fold_pat(&mut self, i: Pat) -> Pat { fold_pat(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_pat_box(&mut self, i: PatBox) -> PatBox { walk_pat_box(self, i) }
+fn fold_pat_box(&mut self, i: PatBox) -> PatBox { fold_pat_box(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_pat_ident(&mut self, i: PatIdent) -> PatIdent { walk_pat_ident(self, i) }
+fn fold_pat_ident(&mut self, i: PatIdent) -> PatIdent { fold_pat_ident(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_pat_lit(&mut self, i: PatLit) -> PatLit { walk_pat_lit(self, i) }
+fn fold_pat_lit(&mut self, i: PatLit) -> PatLit { fold_pat_lit(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_pat_path(&mut self, i: PatPath) -> PatPath { walk_pat_path(self, i) }
+fn fold_pat_path(&mut self, i: PatPath) -> PatPath { fold_pat_path(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_pat_range(&mut self, i: PatRange) -> PatRange { walk_pat_range(self, i) }
+fn fold_pat_range(&mut self, i: PatRange) -> PatRange { fold_pat_range(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_pat_ref(&mut self, i: PatRef) -> PatRef { walk_pat_ref(self, i) }
+fn fold_pat_ref(&mut self, i: PatRef) -> PatRef { fold_pat_ref(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_pat_slice(&mut self, i: PatSlice) -> PatSlice { walk_pat_slice(self, i) }
+fn fold_pat_slice(&mut self, i: PatSlice) -> PatSlice { fold_pat_slice(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_pat_struct(&mut self, i: PatStruct) -> PatStruct { walk_pat_struct(self, i) }
+fn fold_pat_struct(&mut self, i: PatStruct) -> PatStruct { fold_pat_struct(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_pat_tuple(&mut self, i: PatTuple) -> PatTuple { walk_pat_tuple(self, i) }
+fn fold_pat_tuple(&mut self, i: PatTuple) -> PatTuple { fold_pat_tuple(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_pat_tuple_struct(&mut self, i: PatTupleStruct) -> PatTupleStruct { walk_pat_tuple_struct(self, i) }
+fn fold_pat_tuple_struct(&mut self, i: PatTupleStruct) -> PatTupleStruct { fold_pat_tuple_struct(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_pat_wild(&mut self, i: PatWild) -> PatWild { walk_pat_wild(self, i) }
+fn fold_pat_wild(&mut self, i: PatWild) -> PatWild { fold_pat_wild(self, i) }
 
-fn fold_path(&mut self, i: Path) -> Path { walk_path(self, i) }
+fn fold_path(&mut self, i: Path) -> Path { fold_path(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_path_glob(&mut self, i: PathGlob) -> PathGlob { walk_path_glob(self, i) }
+fn fold_path_glob(&mut self, i: PathGlob) -> PathGlob { fold_path_glob(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_path_list(&mut self, i: PathList) -> PathList { walk_path_list(self, i) }
+fn fold_path_list(&mut self, i: PathList) -> PathList { fold_path_list(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_path_list_item(&mut self, i: PathListItem) -> PathListItem { walk_path_list_item(self, i) }
+fn fold_path_list_item(&mut self, i: PathListItem) -> PathListItem { fold_path_list_item(self, i) }
 
-fn fold_path_parameters(&mut self, i: PathParameters) -> PathParameters { walk_path_parameters(self, i) }
+fn fold_path_parameters(&mut self, i: PathParameters) -> PathParameters { fold_path_parameters(self, i) }
 
-fn fold_path_segment(&mut self, i: PathSegment) -> PathSegment { walk_path_segment(self, i) }
+fn fold_path_segment(&mut self, i: PathSegment) -> PathSegment { fold_path_segment(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_path_simple(&mut self, i: PathSimple) -> PathSimple { walk_path_simple(self, i) }
+fn fold_path_simple(&mut self, i: PathSimple) -> PathSimple { fold_path_simple(self, i) }
 
-fn fold_poly_trait_ref(&mut self, i: PolyTraitRef) -> PolyTraitRef { walk_poly_trait_ref(self, i) }
+fn fold_poly_trait_ref(&mut self, i: PolyTraitRef) -> PolyTraitRef { fold_poly_trait_ref(self, i) }
 
-fn fold_qself(&mut self, i: QSelf) -> QSelf { walk_qself(self, i) }
+fn fold_qself(&mut self, i: QSelf) -> QSelf { fold_qself(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_range_limits(&mut self, i: RangeLimits) -> RangeLimits { walk_range_limits(self, i) }
+fn fold_range_limits(&mut self, i: RangeLimits) -> RangeLimits { fold_range_limits(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_stmt(&mut self, i: Stmt) -> Stmt { walk_stmt(self, i) }
+fn fold_stmt(&mut self, i: Stmt) -> Stmt { fold_stmt(self, i) }
 
-fn fold_trait_bound_modifier(&mut self, i: TraitBoundModifier) -> TraitBoundModifier { walk_trait_bound_modifier(self, i) }
+fn fold_trait_bound_modifier(&mut self, i: TraitBoundModifier) -> TraitBoundModifier { fold_trait_bound_modifier(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_trait_item(&mut self, i: TraitItem) -> TraitItem { walk_trait_item(self, i) }
+fn fold_trait_item(&mut self, i: TraitItem) -> TraitItem { fold_trait_item(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_trait_item_const(&mut self, i: TraitItemConst) -> TraitItemConst { walk_trait_item_const(self, i) }
+fn fold_trait_item_const(&mut self, i: TraitItemConst) -> TraitItemConst { fold_trait_item_const(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_trait_item_kind(&mut self, i: TraitItemKind) -> TraitItemKind { walk_trait_item_kind(self, i) }
+fn fold_trait_item_kind(&mut self, i: TraitItemKind) -> TraitItemKind { fold_trait_item_kind(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_trait_item_method(&mut self, i: TraitItemMethod) -> TraitItemMethod { walk_trait_item_method(self, i) }
+fn fold_trait_item_method(&mut self, i: TraitItemMethod) -> TraitItemMethod { fold_trait_item_method(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_trait_item_type(&mut self, i: TraitItemType) -> TraitItemType { walk_trait_item_type(self, i) }
+fn fold_trait_item_type(&mut self, i: TraitItemType) -> TraitItemType { fold_trait_item_type(self, i) }
 
-fn fold_ty(&mut self, i: Ty) -> Ty { walk_ty(self, i) }
+fn fold_ty(&mut self, i: Ty) -> Ty { fold_ty(self, i) }
 
-fn fold_ty_array(&mut self, i: TyArray) -> TyArray { walk_ty_array(self, i) }
+fn fold_ty_array(&mut self, i: TyArray) -> TyArray { fold_ty_array(self, i) }
 
-fn fold_ty_bare_fn(&mut self, i: TyBareFn) -> TyBareFn { walk_ty_bare_fn(self, i) }
+fn fold_ty_bare_fn(&mut self, i: TyBareFn) -> TyBareFn { fold_ty_bare_fn(self, i) }
 
-fn fold_ty_group(&mut self, i: TyGroup) -> TyGroup { walk_ty_group(self, i) }
+fn fold_ty_group(&mut self, i: TyGroup) -> TyGroup { fold_ty_group(self, i) }
 
-fn fold_ty_impl_trait(&mut self, i: TyImplTrait) -> TyImplTrait { walk_ty_impl_trait(self, i) }
+fn fold_ty_impl_trait(&mut self, i: TyImplTrait) -> TyImplTrait { fold_ty_impl_trait(self, i) }
 
-fn fold_ty_infer(&mut self, i: TyInfer) -> TyInfer { walk_ty_infer(self, i) }
+fn fold_ty_infer(&mut self, i: TyInfer) -> TyInfer { fold_ty_infer(self, i) }
 
-fn fold_ty_never(&mut self, i: TyNever) -> TyNever { walk_ty_never(self, i) }
+fn fold_ty_never(&mut self, i: TyNever) -> TyNever { fold_ty_never(self, i) }
 
-fn fold_ty_param(&mut self, i: TyParam) -> TyParam { walk_ty_param(self, i) }
+fn fold_ty_param(&mut self, i: TyParam) -> TyParam { fold_ty_param(self, i) }
 
-fn fold_ty_param_bound(&mut self, i: TyParamBound) -> TyParamBound { walk_ty_param_bound(self, i) }
+fn fold_ty_param_bound(&mut self, i: TyParamBound) -> TyParamBound { fold_ty_param_bound(self, i) }
 
-fn fold_ty_paren(&mut self, i: TyParen) -> TyParen { walk_ty_paren(self, i) }
+fn fold_ty_paren(&mut self, i: TyParen) -> TyParen { fold_ty_paren(self, i) }
 
-fn fold_ty_path(&mut self, i: TyPath) -> TyPath { walk_ty_path(self, i) }
+fn fold_ty_path(&mut self, i: TyPath) -> TyPath { fold_ty_path(self, i) }
 
-fn fold_ty_ptr(&mut self, i: TyPtr) -> TyPtr { walk_ty_ptr(self, i) }
+fn fold_ty_ptr(&mut self, i: TyPtr) -> TyPtr { fold_ty_ptr(self, i) }
 
-fn fold_ty_rptr(&mut self, i: TyRptr) -> TyRptr { walk_ty_rptr(self, i) }
+fn fold_ty_rptr(&mut self, i: TyRptr) -> TyRptr { fold_ty_rptr(self, i) }
 
-fn fold_ty_slice(&mut self, i: TySlice) -> TySlice { walk_ty_slice(self, i) }
+fn fold_ty_slice(&mut self, i: TySlice) -> TySlice { fold_ty_slice(self, i) }
 
-fn fold_ty_trait_object(&mut self, i: TyTraitObject) -> TyTraitObject { walk_ty_trait_object(self, i) }
+fn fold_ty_trait_object(&mut self, i: TyTraitObject) -> TyTraitObject { fold_ty_trait_object(self, i) }
 
-fn fold_ty_tup(&mut self, i: TyTup) -> TyTup { walk_ty_tup(self, i) }
+fn fold_ty_tup(&mut self, i: TyTup) -> TyTup { fold_ty_tup(self, i) }
 
-fn fold_type_binding(&mut self, i: TypeBinding) -> TypeBinding { walk_type_binding(self, i) }
+fn fold_type_binding(&mut self, i: TypeBinding) -> TypeBinding { fold_type_binding(self, i) }
 
-fn fold_un_op(&mut self, i: UnOp) -> UnOp { walk_un_op(self, i) }
+fn fold_un_op(&mut self, i: UnOp) -> UnOp { fold_un_op(self, i) }
 
-fn fold_unsafety(&mut self, i: Unsafety) -> Unsafety { walk_unsafety(self, i) }
+fn fold_unsafety(&mut self, i: Unsafety) -> Unsafety { fold_unsafety(self, i) }
 
-fn fold_variant(&mut self, i: Variant) -> Variant { walk_variant(self, i) }
+fn fold_variant(&mut self, i: Variant) -> Variant { fold_variant(self, i) }
 
-fn fold_variant_data(&mut self, i: VariantData) -> VariantData { walk_variant_data(self, i) }
+fn fold_variant_data(&mut self, i: VariantData) -> VariantData { fold_variant_data(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn fold_view_path(&mut self, i: ViewPath) -> ViewPath { walk_view_path(self, i) }
+fn fold_view_path(&mut self, i: ViewPath) -> ViewPath { fold_view_path(self, i) }
 
-fn fold_vis_crate(&mut self, i: VisCrate) -> VisCrate { walk_vis_crate(self, i) }
+fn fold_vis_crate(&mut self, i: VisCrate) -> VisCrate { fold_vis_crate(self, i) }
 
-fn fold_vis_inherited(&mut self, i: VisInherited) -> VisInherited { walk_vis_inherited(self, i) }
+fn fold_vis_inherited(&mut self, i: VisInherited) -> VisInherited { fold_vis_inherited(self, i) }
 
-fn fold_vis_public(&mut self, i: VisPublic) -> VisPublic { walk_vis_public(self, i) }
+fn fold_vis_public(&mut self, i: VisPublic) -> VisPublic { fold_vis_public(self, i) }
 
-fn fold_vis_restricted(&mut self, i: VisRestricted) -> VisRestricted { walk_vis_restricted(self, i) }
+fn fold_vis_restricted(&mut self, i: VisRestricted) -> VisRestricted { fold_vis_restricted(self, i) }
 
-fn fold_visibility(&mut self, i: Visibility) -> Visibility { walk_visibility(self, i) }
+fn fold_visibility(&mut self, i: Visibility) -> Visibility { fold_visibility(self, i) }
 
-fn fold_where_bound_predicate(&mut self, i: WhereBoundPredicate) -> WhereBoundPredicate { walk_where_bound_predicate(self, i) }
+fn fold_where_bound_predicate(&mut self, i: WhereBoundPredicate) -> WhereBoundPredicate { fold_where_bound_predicate(self, i) }
 
-fn fold_where_clause(&mut self, i: WhereClause) -> WhereClause { walk_where_clause(self, i) }
+fn fold_where_clause(&mut self, i: WhereClause) -> WhereClause { fold_where_clause(self, i) }
 
-fn fold_where_eq_predicate(&mut self, i: WhereEqPredicate) -> WhereEqPredicate { walk_where_eq_predicate(self, i) }
+fn fold_where_eq_predicate(&mut self, i: WhereEqPredicate) -> WhereEqPredicate { fold_where_eq_predicate(self, i) }
 
-fn fold_where_predicate(&mut self, i: WherePredicate) -> WherePredicate { walk_where_predicate(self, i) }
+fn fold_where_predicate(&mut self, i: WherePredicate) -> WherePredicate { fold_where_predicate(self, i) }
 
-fn fold_where_region_predicate(&mut self, i: WhereRegionPredicate) -> WhereRegionPredicate { walk_where_region_predicate(self, i) }
+fn fold_where_region_predicate(&mut self, i: WhereRegionPredicate) -> WhereRegionPredicate { fold_where_region_predicate(self, i) }
 
 }
 
 
-pub fn walk_abi<V: Folder + ?Sized>(_visitor: &mut V, _i: Abi) -> Abi {
+pub fn fold_abi<V: Folder + ?Sized>(_visitor: &mut V, _i: Abi) -> Abi {
     Abi {
         extern_token: _i . extern_token,
         kind: _visitor.fold_abi_kind(_i . kind),
     }
 }
 
-pub fn walk_abi_kind<V: Folder + ?Sized>(_visitor: &mut V, _i: AbiKind) -> AbiKind {
+pub fn fold_abi_kind<V: Folder + ?Sized>(_visitor: &mut V, _i: AbiKind) -> AbiKind {
     use ::AbiKind::*;
     match _i {
         Named(_binding_0, ) => {
@@ -420,7 +420,7 @@
     }
 }
 
-pub fn walk_angle_bracketed_parameter_data<V: Folder + ?Sized>(_visitor: &mut V, _i: AngleBracketedParameterData) -> AngleBracketedParameterData {
+pub fn fold_angle_bracketed_parameter_data<V: Folder + ?Sized>(_visitor: &mut V, _i: AngleBracketedParameterData) -> AngleBracketedParameterData {
     AngleBracketedParameterData {
         turbofish: _i . turbofish,
         lt_token: _i . lt_token,
@@ -431,7 +431,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_arg_captured<V: Folder + ?Sized>(_visitor: &mut V, _i: ArgCaptured) -> ArgCaptured {
+pub fn fold_arg_captured<V: Folder + ?Sized>(_visitor: &mut V, _i: ArgCaptured) -> ArgCaptured {
     ArgCaptured {
         pat: _visitor.fold_pat(_i . pat),
         colon_token: _i . colon_token,
@@ -439,14 +439,14 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_arg_self<V: Folder + ?Sized>(_visitor: &mut V, _i: ArgSelf) -> ArgSelf {
+pub fn fold_arg_self<V: Folder + ?Sized>(_visitor: &mut V, _i: ArgSelf) -> ArgSelf {
     ArgSelf {
         mutbl: _visitor.fold_mutability(_i . mutbl),
         self_token: _i . self_token,
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_arg_self_ref<V: Folder + ?Sized>(_visitor: &mut V, _i: ArgSelfRef) -> ArgSelfRef {
+pub fn fold_arg_self_ref<V: Folder + ?Sized>(_visitor: &mut V, _i: ArgSelfRef) -> ArgSelfRef {
     ArgSelfRef {
         and_token: _i . and_token,
         self_token: _i . self_token,
@@ -455,7 +455,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_arm<V: Folder + ?Sized>(_visitor: &mut V, _i: Arm) -> Arm {
+pub fn fold_arm<V: Folder + ?Sized>(_visitor: &mut V, _i: Arm) -> Arm {
     Arm {
         attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
         pats: FoldHelper::lift(_i . pats, |it| { _visitor.fold_pat(it) }),
@@ -467,7 +467,7 @@
     }
 }
 
-pub fn walk_attr_style<V: Folder + ?Sized>(_visitor: &mut V, _i: AttrStyle) -> AttrStyle {
+pub fn fold_attr_style<V: Folder + ?Sized>(_visitor: &mut V, _i: AttrStyle) -> AttrStyle {
     use ::AttrStyle::*;
     match _i {
         Outer => { Outer }
@@ -479,7 +479,7 @@
     }
 }
 
-pub fn walk_attribute<V: Folder + ?Sized>(_visitor: &mut V, _i: Attribute) -> Attribute {
+pub fn fold_attribute<V: Folder + ?Sized>(_visitor: &mut V, _i: Attribute) -> Attribute {
     Attribute {
         style: _visitor.fold_attr_style(_i . style),
         pound_token: _i . pound_token,
@@ -490,14 +490,14 @@
     }
 }
 
-pub fn walk_bare_fn_arg<V: Folder + ?Sized>(_visitor: &mut V, _i: BareFnArg) -> BareFnArg {
+pub fn fold_bare_fn_arg<V: Folder + ?Sized>(_visitor: &mut V, _i: BareFnArg) -> BareFnArg {
     BareFnArg {
         name: _i . name,
         ty: _visitor.fold_ty(_i . ty),
     }
 }
 
-pub fn walk_bare_fn_arg_name<V: Folder + ?Sized>(_visitor: &mut V, _i: BareFnArgName) -> BareFnArgName {
+pub fn fold_bare_fn_arg_name<V: Folder + ?Sized>(_visitor: &mut V, _i: BareFnArgName) -> BareFnArgName {
     use ::BareFnArgName::*;
     match _i {
         Named(_binding_0, ) => {
@@ -513,7 +513,7 @@
     }
 }
 
-pub fn walk_bare_fn_ty<V: Folder + ?Sized>(_visitor: &mut V, _i: BareFnTy) -> BareFnTy {
+pub fn fold_bare_fn_ty<V: Folder + ?Sized>(_visitor: &mut V, _i: BareFnTy) -> BareFnTy {
     BareFnTy {
         lifetimes: (_i . lifetimes).map(|it| { _visitor.fold_bound_lifetimes(it) }),
         unsafety: _visitor.fold_unsafety(_i . unsafety),
@@ -526,7 +526,7 @@
     }
 }
 
-pub fn walk_bin_op<V: Folder + ?Sized>(_visitor: &mut V, _i: BinOp) -> BinOp {
+pub fn fold_bin_op<V: Folder + ?Sized>(_visitor: &mut V, _i: BinOp) -> BinOp {
     use ::BinOp::*;
     match _i {
         Add(_binding_0, ) => {
@@ -672,7 +672,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_binding_mode<V: Folder + ?Sized>(_visitor: &mut V, _i: BindingMode) -> BindingMode {
+pub fn fold_binding_mode<V: Folder + ?Sized>(_visitor: &mut V, _i: BindingMode) -> BindingMode {
     use ::BindingMode::*;
     match _i {
         ByRef(_binding_0, _binding_1, ) => {
@@ -689,14 +689,14 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_block<V: Folder + ?Sized>(_visitor: &mut V, _i: Block) -> Block {
+pub fn fold_block<V: Folder + ?Sized>(_visitor: &mut V, _i: Block) -> Block {
     Block {
         brace_token: _i . brace_token,
         stmts: FoldHelper::lift(_i . stmts, |it| { _visitor.fold_stmt(it) }),
     }
 }
 
-pub fn walk_body<V: Folder + ?Sized>(_visitor: &mut V, _i: Body) -> Body {
+pub fn fold_body<V: Folder + ?Sized>(_visitor: &mut V, _i: Body) -> Body {
     use ::Body::*;
     match _i {
         Enum(_binding_0, ) => {
@@ -712,7 +712,7 @@
     }
 }
 
-pub fn walk_body_enum<V: Folder + ?Sized>(_visitor: &mut V, _i: BodyEnum) -> BodyEnum {
+pub fn fold_body_enum<V: Folder + ?Sized>(_visitor: &mut V, _i: BodyEnum) -> BodyEnum {
     BodyEnum {
         enum_token: _i . enum_token,
         brace_token: _i . brace_token,
@@ -720,7 +720,7 @@
     }
 }
 
-pub fn walk_body_struct<V: Folder + ?Sized>(_visitor: &mut V, _i: BodyStruct) -> BodyStruct {
+pub fn fold_body_struct<V: Folder + ?Sized>(_visitor: &mut V, _i: BodyStruct) -> BodyStruct {
     BodyStruct {
         data: _visitor.fold_variant_data(_i . data),
         struct_token: _i . struct_token,
@@ -728,7 +728,7 @@
     }
 }
 
-pub fn walk_bound_lifetimes<V: Folder + ?Sized>(_visitor: &mut V, _i: BoundLifetimes) -> BoundLifetimes {
+pub fn fold_bound_lifetimes<V: Folder + ?Sized>(_visitor: &mut V, _i: BoundLifetimes) -> BoundLifetimes {
     BoundLifetimes {
         for_token: _i . for_token,
         lt_token: _i . lt_token,
@@ -737,7 +737,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_capture_by<V: Folder + ?Sized>(_visitor: &mut V, _i: CaptureBy) -> CaptureBy {
+pub fn fold_capture_by<V: Folder + ?Sized>(_visitor: &mut V, _i: CaptureBy) -> CaptureBy {
     use ::CaptureBy::*;
     match _i {
         Value(_binding_0, ) => {
@@ -749,7 +749,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_constness<V: Folder + ?Sized>(_visitor: &mut V, _i: Constness) -> Constness {
+pub fn fold_constness<V: Folder + ?Sized>(_visitor: &mut V, _i: Constness) -> Constness {
     use ::Constness::*;
     match _i {
         Const(_binding_0, ) => {
@@ -761,7 +761,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_defaultness<V: Folder + ?Sized>(_visitor: &mut V, _i: Defaultness) -> Defaultness {
+pub fn fold_defaultness<V: Folder + ?Sized>(_visitor: &mut V, _i: Defaultness) -> Defaultness {
     use ::Defaultness::*;
     match _i {
         Default(_binding_0, ) => {
@@ -773,7 +773,7 @@
     }
 }
 
-pub fn walk_derive_input<V: Folder + ?Sized>(_visitor: &mut V, _i: DeriveInput) -> DeriveInput {
+pub fn fold_derive_input<V: Folder + ?Sized>(_visitor: &mut V, _i: DeriveInput) -> DeriveInput {
     DeriveInput {
         ident: _i . ident,
         vis: _visitor.fold_visibility(_i . vis),
@@ -783,14 +783,14 @@
     }
 }
 
-pub fn walk_expr<V: Folder + ?Sized>(_visitor: &mut V, _i: Expr) -> Expr {
+pub fn fold_expr<V: Folder + ?Sized>(_visitor: &mut V, _i: Expr) -> Expr {
     Expr {
         node: _visitor.fold_expr_kind(_i . node),
         attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_addr_of<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprAddrOf) -> ExprAddrOf {
+pub fn fold_expr_addr_of<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprAddrOf) -> ExprAddrOf {
     ExprAddrOf {
         and_token: _i . and_token,
         mutbl: _visitor.fold_mutability(_i . mutbl),
@@ -798,14 +798,14 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_array<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprArray) -> ExprArray {
+pub fn fold_expr_array<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprArray) -> ExprArray {
     ExprArray {
         exprs: FoldHelper::lift(_i . exprs, |it| { _visitor.fold_expr(it) }),
         bracket_token: _i . bracket_token,
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_assign<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprAssign) -> ExprAssign {
+pub fn fold_expr_assign<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprAssign) -> ExprAssign {
     ExprAssign {
         left: Box::new(_visitor.fold_expr(* _i . left)),
         right: Box::new(_visitor.fold_expr(* _i . right)),
@@ -813,7 +813,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_assign_op<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprAssignOp) -> ExprAssignOp {
+pub fn fold_expr_assign_op<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprAssignOp) -> ExprAssignOp {
     ExprAssignOp {
         op: _visitor.fold_bin_op(_i . op),
         left: Box::new(_visitor.fold_expr(* _i . left)),
@@ -821,7 +821,7 @@
     }
 }
 
-pub fn walk_expr_binary<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprBinary) -> ExprBinary {
+pub fn fold_expr_binary<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprBinary) -> ExprBinary {
     ExprBinary {
         op: _visitor.fold_bin_op(_i . op),
         left: Box::new(_visitor.fold_expr(* _i . left)),
@@ -829,21 +829,21 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_block<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprBlock) -> ExprBlock {
+pub fn fold_expr_block<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprBlock) -> ExprBlock {
     ExprBlock {
         unsafety: _visitor.fold_unsafety(_i . unsafety),
         block: _visitor.fold_block(_i . block),
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_box<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprBox) -> ExprBox {
+pub fn fold_expr_box<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprBox) -> ExprBox {
     ExprBox {
         expr: Box::new(_visitor.fold_expr(* _i . expr)),
         box_token: _i . box_token,
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_break<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprBreak) -> ExprBreak {
+pub fn fold_expr_break<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprBreak) -> ExprBreak {
     ExprBreak {
         label: _i . label,
         expr: (_i . expr).map(|it| { Box::new(_visitor.fold_expr(* it)) }),
@@ -851,7 +851,7 @@
     }
 }
 
-pub fn walk_expr_call<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprCall) -> ExprCall {
+pub fn fold_expr_call<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprCall) -> ExprCall {
     ExprCall {
         func: Box::new(_visitor.fold_expr(* _i . func)),
         args: FoldHelper::lift(_i . args, |it| { _visitor.fold_expr(it) }),
@@ -859,7 +859,7 @@
     }
 }
 
-pub fn walk_expr_cast<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprCast) -> ExprCast {
+pub fn fold_expr_cast<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprCast) -> ExprCast {
     ExprCast {
         expr: Box::new(_visitor.fold_expr(* _i . expr)),
         as_token: _i . as_token,
@@ -867,7 +867,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_catch<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprCatch) -> ExprCatch {
+pub fn fold_expr_catch<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprCatch) -> ExprCatch {
     ExprCatch {
         do_token: _i . do_token,
         catch_token: _i . catch_token,
@@ -875,7 +875,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_closure<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprClosure) -> ExprClosure {
+pub fn fold_expr_closure<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprClosure) -> ExprClosure {
     ExprClosure {
         capture: _visitor.fold_capture_by(_i . capture),
         decl: Box::new(_visitor.fold_fn_decl(* _i . decl)),
@@ -885,14 +885,14 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_continue<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprContinue) -> ExprContinue {
+pub fn fold_expr_continue<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprContinue) -> ExprContinue {
     ExprContinue {
         label: _i . label,
         continue_token: _i . continue_token,
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_field<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprField) -> ExprField {
+pub fn fold_expr_field<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprField) -> ExprField {
     ExprField {
         expr: Box::new(_visitor.fold_expr(* _i . expr)),
         field: _i . field,
@@ -900,7 +900,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_for_loop<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprForLoop) -> ExprForLoop {
+pub fn fold_expr_for_loop<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprForLoop) -> ExprForLoop {
     ExprForLoop {
         pat: Box::new(_visitor.fold_pat(* _i . pat)),
         expr: Box::new(_visitor.fold_expr(* _i . expr)),
@@ -912,14 +912,14 @@
     }
 }
 
-pub fn walk_expr_group<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprGroup) -> ExprGroup {
+pub fn fold_expr_group<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprGroup) -> ExprGroup {
     ExprGroup {
         expr: Box::new(_visitor.fold_expr(* _i . expr)),
         group_token: _i . group_token,
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_if<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprIf) -> ExprIf {
+pub fn fold_expr_if<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprIf) -> ExprIf {
     ExprIf {
         cond: Box::new(_visitor.fold_expr(* _i . cond)),
         if_true: _visitor.fold_block(_i . if_true),
@@ -929,7 +929,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_if_let<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprIfLet) -> ExprIfLet {
+pub fn fold_expr_if_let<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprIfLet) -> ExprIfLet {
     ExprIfLet {
         pat: Box::new(_visitor.fold_pat(* _i . pat)),
         expr: Box::new(_visitor.fold_expr(* _i . expr)),
@@ -942,7 +942,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_in_place<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprInPlace) -> ExprInPlace {
+pub fn fold_expr_in_place<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprInPlace) -> ExprInPlace {
     ExprInPlace {
         place: Box::new(_visitor.fold_expr(* _i . place)),
         kind: _visitor.fold_in_place_kind(_i . kind),
@@ -950,7 +950,7 @@
     }
 }
 
-pub fn walk_expr_index<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprIndex) -> ExprIndex {
+pub fn fold_expr_index<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprIndex) -> ExprIndex {
     ExprIndex {
         expr: Box::new(_visitor.fold_expr(* _i . expr)),
         index: Box::new(_visitor.fold_expr(* _i . index)),
@@ -958,7 +958,7 @@
     }
 }
 
-pub fn walk_expr_kind<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprKind) -> ExprKind {
+pub fn fold_expr_kind<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprKind) -> ExprKind {
     use ::ExprKind::*;
     match _i {
         Box(_binding_0, ) => {
@@ -1159,7 +1159,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_loop<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprLoop) -> ExprLoop {
+pub fn fold_expr_loop<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprLoop) -> ExprLoop {
     ExprLoop {
         body: _visitor.fold_block(_i . body),
         label: _i . label,
@@ -1168,7 +1168,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_match<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprMatch) -> ExprMatch {
+pub fn fold_expr_match<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprMatch) -> ExprMatch {
     ExprMatch {
         match_token: _i . match_token,
         brace_token: _i . brace_token,
@@ -1177,7 +1177,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_method_call<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprMethodCall) -> ExprMethodCall {
+pub fn fold_expr_method_call<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprMethodCall) -> ExprMethodCall {
     ExprMethodCall {
         expr: Box::new(_visitor.fold_expr(* _i . expr)),
         method: _i . method,
@@ -1191,21 +1191,21 @@
     }
 }
 
-pub fn walk_expr_paren<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprParen) -> ExprParen {
+pub fn fold_expr_paren<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprParen) -> ExprParen {
     ExprParen {
         expr: Box::new(_visitor.fold_expr(* _i . expr)),
         paren_token: _i . paren_token,
     }
 }
 
-pub fn walk_expr_path<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprPath) -> ExprPath {
+pub fn fold_expr_path<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprPath) -> ExprPath {
     ExprPath {
         qself: (_i . qself).map(|it| { _visitor.fold_qself(it) }),
         path: _visitor.fold_path(_i . path),
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_range<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprRange) -> ExprRange {
+pub fn fold_expr_range<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprRange) -> ExprRange {
     ExprRange {
         from: (_i . from).map(|it| { Box::new(_visitor.fold_expr(* it)) }),
         to: (_i . to).map(|it| { Box::new(_visitor.fold_expr(* it)) }),
@@ -1213,7 +1213,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_repeat<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprRepeat) -> ExprRepeat {
+pub fn fold_expr_repeat<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprRepeat) -> ExprRepeat {
     ExprRepeat {
         bracket_token: _i . bracket_token,
         semi_token: _i . semi_token,
@@ -1222,14 +1222,14 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_ret<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprRet) -> ExprRet {
+pub fn fold_expr_ret<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprRet) -> ExprRet {
     ExprRet {
         expr: (_i . expr).map(|it| { Box::new(_visitor.fold_expr(* it)) }),
         return_token: _i . return_token,
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_struct<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprStruct) -> ExprStruct {
+pub fn fold_expr_struct<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprStruct) -> ExprStruct {
     ExprStruct {
         path: _visitor.fold_path(_i . path),
         fields: FoldHelper::lift(_i . fields, |it| { _visitor.fold_field_value(it) }),
@@ -1239,14 +1239,14 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_try<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprTry) -> ExprTry {
+pub fn fold_expr_try<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprTry) -> ExprTry {
     ExprTry {
         expr: Box::new(_visitor.fold_expr(* _i . expr)),
         question_token: _i . question_token,
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_tup<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprTup) -> ExprTup {
+pub fn fold_expr_tup<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprTup) -> ExprTup {
     ExprTup {
         args: FoldHelper::lift(_i . args, |it| { _visitor.fold_expr(it) }),
         paren_token: _i . paren_token,
@@ -1254,7 +1254,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_tup_field<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprTupField) -> ExprTupField {
+pub fn fold_expr_tup_field<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprTupField) -> ExprTupField {
     ExprTupField {
         expr: Box::new(_visitor.fold_expr(* _i . expr)),
         field: _i . field,
@@ -1262,7 +1262,7 @@
     }
 }
 
-pub fn walk_expr_type<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprType) -> ExprType {
+pub fn fold_expr_type<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprType) -> ExprType {
     ExprType {
         expr: Box::new(_visitor.fold_expr(* _i . expr)),
         colon_token: _i . colon_token,
@@ -1270,14 +1270,14 @@
     }
 }
 
-pub fn walk_expr_unary<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprUnary) -> ExprUnary {
+pub fn fold_expr_unary<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprUnary) -> ExprUnary {
     ExprUnary {
         op: _visitor.fold_un_op(_i . op),
         expr: Box::new(_visitor.fold_expr(* _i . expr)),
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_while<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprWhile) -> ExprWhile {
+pub fn fold_expr_while<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprWhile) -> ExprWhile {
     ExprWhile {
         cond: Box::new(_visitor.fold_expr(* _i . cond)),
         body: _visitor.fold_block(_i . body),
@@ -1287,7 +1287,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_while_let<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprWhileLet) -> ExprWhileLet {
+pub fn fold_expr_while_let<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprWhileLet) -> ExprWhileLet {
     ExprWhileLet {
         pat: Box::new(_visitor.fold_pat(* _i . pat)),
         expr: Box::new(_visitor.fold_expr(* _i . expr)),
@@ -1300,14 +1300,14 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_yield<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprYield) -> ExprYield {
+pub fn fold_expr_yield<V: Folder + ?Sized>(_visitor: &mut V, _i: ExprYield) -> ExprYield {
     ExprYield {
         yield_token: _i . yield_token,
         expr: (_i . expr).map(|it| { Box::new(_visitor.fold_expr(* it)) }),
     }
 }
 
-pub fn walk_field<V: Folder + ?Sized>(_visitor: &mut V, _i: Field) -> Field {
+pub fn fold_field<V: Folder + ?Sized>(_visitor: &mut V, _i: Field) -> Field {
     Field {
         ident: _i . ident,
         vis: _visitor.fold_visibility(_i . vis),
@@ -1317,7 +1317,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_field_pat<V: Folder + ?Sized>(_visitor: &mut V, _i: FieldPat) -> FieldPat {
+pub fn fold_field_pat<V: Folder + ?Sized>(_visitor: &mut V, _i: FieldPat) -> FieldPat {
     FieldPat {
         ident: _i . ident,
         pat: Box::new(_visitor.fold_pat(* _i . pat)),
@@ -1327,7 +1327,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_field_value<V: Folder + ?Sized>(_visitor: &mut V, _i: FieldValue) -> FieldValue {
+pub fn fold_field_value<V: Folder + ?Sized>(_visitor: &mut V, _i: FieldValue) -> FieldValue {
     FieldValue {
         ident: _i . ident,
         expr: _visitor.fold_expr(_i . expr),
@@ -1337,7 +1337,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_file<V: Folder + ?Sized>(_visitor: &mut V, _i: File) -> File {
+pub fn fold_file<V: Folder + ?Sized>(_visitor: &mut V, _i: File) -> File {
     File {
         shebang: _i . shebang,
         attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
@@ -1345,7 +1345,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_fn_arg<V: Folder + ?Sized>(_visitor: &mut V, _i: FnArg) -> FnArg {
+pub fn fold_fn_arg<V: Folder + ?Sized>(_visitor: &mut V, _i: FnArg) -> FnArg {
     use ::FnArg::*;
     match _i {
         SelfRef(_binding_0, ) => {
@@ -1371,7 +1371,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_fn_decl<V: Folder + ?Sized>(_visitor: &mut V, _i: FnDecl) -> FnDecl {
+pub fn fold_fn_decl<V: Folder + ?Sized>(_visitor: &mut V, _i: FnDecl) -> FnDecl {
     FnDecl {
         fn_token: _i . fn_token,
         paren_token: _i . paren_token,
@@ -1383,7 +1383,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_foreign_item<V: Folder + ?Sized>(_visitor: &mut V, _i: ForeignItem) -> ForeignItem {
+pub fn fold_foreign_item<V: Folder + ?Sized>(_visitor: &mut V, _i: ForeignItem) -> ForeignItem {
     ForeignItem {
         ident: _i . ident,
         attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
@@ -1393,13 +1393,13 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_foreign_item_fn<V: Folder + ?Sized>(_visitor: &mut V, _i: ForeignItemFn) -> ForeignItemFn {
+pub fn fold_foreign_item_fn<V: Folder + ?Sized>(_visitor: &mut V, _i: ForeignItemFn) -> ForeignItemFn {
     ForeignItemFn {
         decl: Box::new(_visitor.fold_fn_decl(* _i . decl)),
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_foreign_item_kind<V: Folder + ?Sized>(_visitor: &mut V, _i: ForeignItemKind) -> ForeignItemKind {
+pub fn fold_foreign_item_kind<V: Folder + ?Sized>(_visitor: &mut V, _i: ForeignItemKind) -> ForeignItemKind {
     use ::ForeignItemKind::*;
     match _i {
         Fn(_binding_0, ) => {
@@ -1415,7 +1415,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_foreign_item_static<V: Folder + ?Sized>(_visitor: &mut V, _i: ForeignItemStatic) -> ForeignItemStatic {
+pub fn fold_foreign_item_static<V: Folder + ?Sized>(_visitor: &mut V, _i: ForeignItemStatic) -> ForeignItemStatic {
     ForeignItemStatic {
         static_token: _i . static_token,
         ty: Box::new(_visitor.fold_ty(* _i . ty)),
@@ -1424,7 +1424,7 @@
     }
 }
 
-pub fn walk_function_ret_ty<V: Folder + ?Sized>(_visitor: &mut V, _i: FunctionRetTy) -> FunctionRetTy {
+pub fn fold_function_ret_ty<V: Folder + ?Sized>(_visitor: &mut V, _i: FunctionRetTy) -> FunctionRetTy {
     use ::FunctionRetTy::*;
     match _i {
         Default => { Default }
@@ -1437,7 +1437,7 @@
     }
 }
 
-pub fn walk_generics<V: Folder + ?Sized>(_visitor: &mut V, _i: Generics) -> Generics {
+pub fn fold_generics<V: Folder + ?Sized>(_visitor: &mut V, _i: Generics) -> Generics {
     Generics {
         lt_token: _i . lt_token,
         gt_token: _i . gt_token,
@@ -1447,14 +1447,14 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_impl_item<V: Folder + ?Sized>(_visitor: &mut V, _i: ImplItem) -> ImplItem {
+pub fn fold_impl_item<V: Folder + ?Sized>(_visitor: &mut V, _i: ImplItem) -> ImplItem {
     ImplItem {
         attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
         node: _visitor.fold_impl_item_kind(_i . node),
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_impl_item_const<V: Folder + ?Sized>(_visitor: &mut V, _i: ImplItemConst) -> ImplItemConst {
+pub fn fold_impl_item_const<V: Folder + ?Sized>(_visitor: &mut V, _i: ImplItemConst) -> ImplItemConst {
     ImplItemConst {
         vis: _visitor.fold_visibility(_i . vis),
         defaultness: _visitor.fold_defaultness(_i . defaultness),
@@ -1468,7 +1468,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_impl_item_kind<V: Folder + ?Sized>(_visitor: &mut V, _i: ImplItemKind) -> ImplItemKind {
+pub fn fold_impl_item_kind<V: Folder + ?Sized>(_visitor: &mut V, _i: ImplItemKind) -> ImplItemKind {
     use ::ImplItemKind::*;
     match _i {
         Const(_binding_0, ) => {
@@ -1494,7 +1494,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_impl_item_method<V: Folder + ?Sized>(_visitor: &mut V, _i: ImplItemMethod) -> ImplItemMethod {
+pub fn fold_impl_item_method<V: Folder + ?Sized>(_visitor: &mut V, _i: ImplItemMethod) -> ImplItemMethod {
     ImplItemMethod {
         vis: _visitor.fold_visibility(_i . vis),
         defaultness: _visitor.fold_defaultness(_i . defaultness),
@@ -1503,7 +1503,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_impl_item_type<V: Folder + ?Sized>(_visitor: &mut V, _i: ImplItemType) -> ImplItemType {
+pub fn fold_impl_item_type<V: Folder + ?Sized>(_visitor: &mut V, _i: ImplItemType) -> ImplItemType {
     ImplItemType {
         vis: _visitor.fold_visibility(_i . vis),
         defaultness: _visitor.fold_defaultness(_i . defaultness),
@@ -1515,7 +1515,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_impl_polarity<V: Folder + ?Sized>(_visitor: &mut V, _i: ImplPolarity) -> ImplPolarity {
+pub fn fold_impl_polarity<V: Folder + ?Sized>(_visitor: &mut V, _i: ImplPolarity) -> ImplPolarity {
     use ::ImplPolarity::*;
     match _i {
         Positive => { Positive }
@@ -1527,7 +1527,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_in_place_kind<V: Folder + ?Sized>(_visitor: &mut V, _i: InPlaceKind) -> InPlaceKind {
+pub fn fold_in_place_kind<V: Folder + ?Sized>(_visitor: &mut V, _i: InPlaceKind) -> InPlaceKind {
     use ::InPlaceKind::*;
     match _i {
         Arrow(_binding_0, ) => {
@@ -1543,14 +1543,14 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item<V: Folder + ?Sized>(_visitor: &mut V, _i: Item) -> Item {
+pub fn fold_item<V: Folder + ?Sized>(_visitor: &mut V, _i: Item) -> Item {
     Item {
         attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
         node: _visitor.fold_item_kind(_i . node),
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_const<V: Folder + ?Sized>(_visitor: &mut V, _i: ItemConst) -> ItemConst {
+pub fn fold_item_const<V: Folder + ?Sized>(_visitor: &mut V, _i: ItemConst) -> ItemConst {
     ItemConst {
         vis: _visitor.fold_visibility(_i . vis),
         const_token: _i . const_token,
@@ -1563,7 +1563,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_default_impl<V: Folder + ?Sized>(_visitor: &mut V, _i: ItemDefaultImpl) -> ItemDefaultImpl {
+pub fn fold_item_default_impl<V: Folder + ?Sized>(_visitor: &mut V, _i: ItemDefaultImpl) -> ItemDefaultImpl {
     ItemDefaultImpl {
         unsafety: _visitor.fold_unsafety(_i . unsafety),
         impl_token: _i . impl_token,
@@ -1574,7 +1574,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_enum<V: Folder + ?Sized>(_visitor: &mut V, _i: ItemEnum) -> ItemEnum {
+pub fn fold_item_enum<V: Folder + ?Sized>(_visitor: &mut V, _i: ItemEnum) -> ItemEnum {
     ItemEnum {
         vis: _visitor.fold_visibility(_i . vis),
         enum_token: _i . enum_token,
@@ -1585,7 +1585,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_extern_crate<V: Folder + ?Sized>(_visitor: &mut V, _i: ItemExternCrate) -> ItemExternCrate {
+pub fn fold_item_extern_crate<V: Folder + ?Sized>(_visitor: &mut V, _i: ItemExternCrate) -> ItemExternCrate {
     ItemExternCrate {
         vis: _visitor.fold_visibility(_i . vis),
         extern_token: _i . extern_token,
@@ -1596,7 +1596,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_fn<V: Folder + ?Sized>(_visitor: &mut V, _i: ItemFn) -> ItemFn {
+pub fn fold_item_fn<V: Folder + ?Sized>(_visitor: &mut V, _i: ItemFn) -> ItemFn {
     ItemFn {
         vis: _visitor.fold_visibility(_i . vis),
         constness: _visitor.fold_constness(_i . constness),
@@ -1608,7 +1608,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_foreign_mod<V: Folder + ?Sized>(_visitor: &mut V, _i: ItemForeignMod) -> ItemForeignMod {
+pub fn fold_item_foreign_mod<V: Folder + ?Sized>(_visitor: &mut V, _i: ItemForeignMod) -> ItemForeignMod {
     ItemForeignMod {
         abi: _visitor.fold_abi(_i . abi),
         brace_token: _i . brace_token,
@@ -1616,7 +1616,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_impl<V: Folder + ?Sized>(_visitor: &mut V, _i: ItemImpl) -> ItemImpl {
+pub fn fold_item_impl<V: Folder + ?Sized>(_visitor: &mut V, _i: ItemImpl) -> ItemImpl {
     ItemImpl {
         defaultness: _visitor.fold_defaultness(_i . defaultness),
         unsafety: _visitor.fold_unsafety(_i . unsafety),
@@ -1629,7 +1629,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_kind<V: Folder + ?Sized>(_visitor: &mut V, _i: ItemKind) -> ItemKind {
+pub fn fold_item_kind<V: Folder + ?Sized>(_visitor: &mut V, _i: ItemKind) -> ItemKind {
     use ::ItemKind::*;
     match _i {
         ExternCrate(_binding_0, ) => {
@@ -1710,7 +1710,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_mod<V: Folder + ?Sized>(_visitor: &mut V, _i: ItemMod) -> ItemMod {
+pub fn fold_item_mod<V: Folder + ?Sized>(_visitor: &mut V, _i: ItemMod) -> ItemMod {
     ItemMod {
         vis: _visitor.fold_visibility(_i . vis),
         mod_token: _i . mod_token,
@@ -1720,7 +1720,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_static<V: Folder + ?Sized>(_visitor: &mut V, _i: ItemStatic) -> ItemStatic {
+pub fn fold_item_static<V: Folder + ?Sized>(_visitor: &mut V, _i: ItemStatic) -> ItemStatic {
     ItemStatic {
         vis: _visitor.fold_visibility(_i . vis),
         static_token: _i . static_token,
@@ -1734,7 +1734,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_struct<V: Folder + ?Sized>(_visitor: &mut V, _i: ItemStruct) -> ItemStruct {
+pub fn fold_item_struct<V: Folder + ?Sized>(_visitor: &mut V, _i: ItemStruct) -> ItemStruct {
     ItemStruct {
         vis: _visitor.fold_visibility(_i . vis),
         struct_token: _i . struct_token,
@@ -1745,7 +1745,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_trait<V: Folder + ?Sized>(_visitor: &mut V, _i: ItemTrait) -> ItemTrait {
+pub fn fold_item_trait<V: Folder + ?Sized>(_visitor: &mut V, _i: ItemTrait) -> ItemTrait {
     ItemTrait {
         vis: _visitor.fold_visibility(_i . vis),
         unsafety: _visitor.fold_unsafety(_i . unsafety),
@@ -1759,7 +1759,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_ty<V: Folder + ?Sized>(_visitor: &mut V, _i: ItemTy) -> ItemTy {
+pub fn fold_item_ty<V: Folder + ?Sized>(_visitor: &mut V, _i: ItemTy) -> ItemTy {
     ItemTy {
         vis: _visitor.fold_visibility(_i . vis),
         type_token: _i . type_token,
@@ -1771,7 +1771,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_union<V: Folder + ?Sized>(_visitor: &mut V, _i: ItemUnion) -> ItemUnion {
+pub fn fold_item_union<V: Folder + ?Sized>(_visitor: &mut V, _i: ItemUnion) -> ItemUnion {
     ItemUnion {
         vis: _visitor.fold_visibility(_i . vis),
         union_token: _i . union_token,
@@ -1781,7 +1781,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_use<V: Folder + ?Sized>(_visitor: &mut V, _i: ItemUse) -> ItemUse {
+pub fn fold_item_use<V: Folder + ?Sized>(_visitor: &mut V, _i: ItemUse) -> ItemUse {
     ItemUse {
         vis: _visitor.fold_visibility(_i . vis),
         use_token: _i . use_token,
@@ -1790,7 +1790,7 @@
     }
 }
 
-pub fn walk_lifetime_def<V: Folder + ?Sized>(_visitor: &mut V, _i: LifetimeDef) -> LifetimeDef {
+pub fn fold_lifetime_def<V: Folder + ?Sized>(_visitor: &mut V, _i: LifetimeDef) -> LifetimeDef {
     LifetimeDef {
         attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
         lifetime: _i . lifetime,
@@ -1799,7 +1799,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_local<V: Folder + ?Sized>(_visitor: &mut V, _i: Local) -> Local {
+pub fn fold_local<V: Folder + ?Sized>(_visitor: &mut V, _i: Local) -> Local {
     Local {
         let_token: _i . let_token,
         colon_token: _i . colon_token,
@@ -1812,7 +1812,7 @@
     }
 }
 
-pub fn walk_mac<V: Folder + ?Sized>(_visitor: &mut V, _i: Mac) -> Mac {
+pub fn fold_mac<V: Folder + ?Sized>(_visitor: &mut V, _i: Mac) -> Mac {
     Mac {
         path: _visitor.fold_path(_i . path),
         bang_token: _i . bang_token,
@@ -1821,7 +1821,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_mac_stmt_style<V: Folder + ?Sized>(_visitor: &mut V, _i: MacStmtStyle) -> MacStmtStyle {
+pub fn fold_mac_stmt_style<V: Folder + ?Sized>(_visitor: &mut V, _i: MacStmtStyle) -> MacStmtStyle {
     use ::MacStmtStyle::*;
     match _i {
         Semicolon(_binding_0, ) => {
@@ -1834,7 +1834,7 @@
     }
 }
 
-pub fn walk_meta_item<V: Folder + ?Sized>(_visitor: &mut V, _i: MetaItem) -> MetaItem {
+pub fn fold_meta_item<V: Folder + ?Sized>(_visitor: &mut V, _i: MetaItem) -> MetaItem {
     use ::MetaItem::*;
     match _i {
         Term(_binding_0, ) => {
@@ -1855,7 +1855,7 @@
     }
 }
 
-pub fn walk_meta_item_list<V: Folder + ?Sized>(_visitor: &mut V, _i: MetaItemList) -> MetaItemList {
+pub fn fold_meta_item_list<V: Folder + ?Sized>(_visitor: &mut V, _i: MetaItemList) -> MetaItemList {
     MetaItemList {
         ident: _i . ident,
         paren_token: _i . paren_token,
@@ -1863,7 +1863,7 @@
     }
 }
 
-pub fn walk_meta_name_value<V: Folder + ?Sized>(_visitor: &mut V, _i: MetaNameValue) -> MetaNameValue {
+pub fn fold_meta_name_value<V: Folder + ?Sized>(_visitor: &mut V, _i: MetaNameValue) -> MetaNameValue {
     MetaNameValue {
         ident: _i . ident,
         eq_token: _i . eq_token,
@@ -1871,7 +1871,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_method_sig<V: Folder + ?Sized>(_visitor: &mut V, _i: MethodSig) -> MethodSig {
+pub fn fold_method_sig<V: Folder + ?Sized>(_visitor: &mut V, _i: MethodSig) -> MethodSig {
     MethodSig {
         constness: _visitor.fold_constness(_i . constness),
         unsafety: _visitor.fold_unsafety(_i . unsafety),
@@ -1881,14 +1881,14 @@
     }
 }
 
-pub fn walk_mut_ty<V: Folder + ?Sized>(_visitor: &mut V, _i: MutTy) -> MutTy {
+pub fn fold_mut_ty<V: Folder + ?Sized>(_visitor: &mut V, _i: MutTy) -> MutTy {
     MutTy {
         ty: _visitor.fold_ty(_i . ty),
         mutability: _visitor.fold_mutability(_i . mutability),
     }
 }
 
-pub fn walk_mutability<V: Folder + ?Sized>(_visitor: &mut V, _i: Mutability) -> Mutability {
+pub fn fold_mutability<V: Folder + ?Sized>(_visitor: &mut V, _i: Mutability) -> Mutability {
     use ::Mutability::*;
     match _i {
         Mutable(_binding_0, ) => {
@@ -1900,7 +1900,7 @@
     }
 }
 
-pub fn walk_nested_meta_item<V: Folder + ?Sized>(_visitor: &mut V, _i: NestedMetaItem) -> NestedMetaItem {
+pub fn fold_nested_meta_item<V: Folder + ?Sized>(_visitor: &mut V, _i: NestedMetaItem) -> NestedMetaItem {
     use ::NestedMetaItem::*;
     match _i {
         MetaItem(_binding_0, ) => {
@@ -1916,7 +1916,7 @@
     }
 }
 
-pub fn walk_parenthesized_parameter_data<V: Folder + ?Sized>(_visitor: &mut V, _i: ParenthesizedParameterData) -> ParenthesizedParameterData {
+pub fn fold_parenthesized_parameter_data<V: Folder + ?Sized>(_visitor: &mut V, _i: ParenthesizedParameterData) -> ParenthesizedParameterData {
     ParenthesizedParameterData {
         paren_token: _i . paren_token,
         inputs: FoldHelper::lift(_i . inputs, |it| { _visitor.fold_ty(it) }),
@@ -1924,7 +1924,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat<V: Folder + ?Sized>(_visitor: &mut V, _i: Pat) -> Pat {
+pub fn fold_pat<V: Folder + ?Sized>(_visitor: &mut V, _i: Pat) -> Pat {
     use ::Pat::*;
     match _i {
         Wild(_binding_0, ) => {
@@ -1990,14 +1990,14 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat_box<V: Folder + ?Sized>(_visitor: &mut V, _i: PatBox) -> PatBox {
+pub fn fold_pat_box<V: Folder + ?Sized>(_visitor: &mut V, _i: PatBox) -> PatBox {
     PatBox {
         pat: Box::new(_visitor.fold_pat(* _i . pat)),
         box_token: _i . box_token,
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat_ident<V: Folder + ?Sized>(_visitor: &mut V, _i: PatIdent) -> PatIdent {
+pub fn fold_pat_ident<V: Folder + ?Sized>(_visitor: &mut V, _i: PatIdent) -> PatIdent {
     PatIdent {
         mode: _visitor.fold_binding_mode(_i . mode),
         ident: _i . ident,
@@ -2006,20 +2006,20 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat_lit<V: Folder + ?Sized>(_visitor: &mut V, _i: PatLit) -> PatLit {
+pub fn fold_pat_lit<V: Folder + ?Sized>(_visitor: &mut V, _i: PatLit) -> PatLit {
     PatLit {
         expr: Box::new(_visitor.fold_expr(* _i . expr)),
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat_path<V: Folder + ?Sized>(_visitor: &mut V, _i: PatPath) -> PatPath {
+pub fn fold_pat_path<V: Folder + ?Sized>(_visitor: &mut V, _i: PatPath) -> PatPath {
     PatPath {
         qself: (_i . qself).map(|it| { _visitor.fold_qself(it) }),
         path: _visitor.fold_path(_i . path),
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat_range<V: Folder + ?Sized>(_visitor: &mut V, _i: PatRange) -> PatRange {
+pub fn fold_pat_range<V: Folder + ?Sized>(_visitor: &mut V, _i: PatRange) -> PatRange {
     PatRange {
         lo: Box::new(_visitor.fold_expr(* _i . lo)),
         hi: Box::new(_visitor.fold_expr(* _i . hi)),
@@ -2027,7 +2027,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat_ref<V: Folder + ?Sized>(_visitor: &mut V, _i: PatRef) -> PatRef {
+pub fn fold_pat_ref<V: Folder + ?Sized>(_visitor: &mut V, _i: PatRef) -> PatRef {
     PatRef {
         pat: Box::new(_visitor.fold_pat(* _i . pat)),
         mutbl: _visitor.fold_mutability(_i . mutbl),
@@ -2035,7 +2035,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat_slice<V: Folder + ?Sized>(_visitor: &mut V, _i: PatSlice) -> PatSlice {
+pub fn fold_pat_slice<V: Folder + ?Sized>(_visitor: &mut V, _i: PatSlice) -> PatSlice {
     PatSlice {
         front: FoldHelper::lift(_i . front, |it| { _visitor.fold_pat(it) }),
         middle: (_i . middle).map(|it| { Box::new(_visitor.fold_pat(* it)) }),
@@ -2046,7 +2046,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat_struct<V: Folder + ?Sized>(_visitor: &mut V, _i: PatStruct) -> PatStruct {
+pub fn fold_pat_struct<V: Folder + ?Sized>(_visitor: &mut V, _i: PatStruct) -> PatStruct {
     PatStruct {
         path: _visitor.fold_path(_i . path),
         fields: FoldHelper::lift(_i . fields, |it| { _visitor.fold_field_pat(it) }),
@@ -2055,7 +2055,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat_tuple<V: Folder + ?Sized>(_visitor: &mut V, _i: PatTuple) -> PatTuple {
+pub fn fold_pat_tuple<V: Folder + ?Sized>(_visitor: &mut V, _i: PatTuple) -> PatTuple {
     PatTuple {
         pats: FoldHelper::lift(_i . pats, |it| { _visitor.fold_pat(it) }),
         dots_pos: _i . dots_pos,
@@ -2065,27 +2065,27 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat_tuple_struct<V: Folder + ?Sized>(_visitor: &mut V, _i: PatTupleStruct) -> PatTupleStruct {
+pub fn fold_pat_tuple_struct<V: Folder + ?Sized>(_visitor: &mut V, _i: PatTupleStruct) -> PatTupleStruct {
     PatTupleStruct {
         path: _visitor.fold_path(_i . path),
         pat: _visitor.fold_pat_tuple(_i . pat),
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat_wild<V: Folder + ?Sized>(_visitor: &mut V, _i: PatWild) -> PatWild {
+pub fn fold_pat_wild<V: Folder + ?Sized>(_visitor: &mut V, _i: PatWild) -> PatWild {
     PatWild {
         underscore_token: _i . underscore_token,
     }
 }
 
-pub fn walk_path<V: Folder + ?Sized>(_visitor: &mut V, _i: Path) -> Path {
+pub fn fold_path<V: Folder + ?Sized>(_visitor: &mut V, _i: Path) -> Path {
     Path {
         leading_colon: _i . leading_colon,
         segments: FoldHelper::lift(_i . segments, |it| { _visitor.fold_path_segment(it) }),
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_path_glob<V: Folder + ?Sized>(_visitor: &mut V, _i: PathGlob) -> PathGlob {
+pub fn fold_path_glob<V: Folder + ?Sized>(_visitor: &mut V, _i: PathGlob) -> PathGlob {
     PathGlob {
         path: _visitor.fold_path(_i . path),
         colon2_token: _i . colon2_token,
@@ -2093,7 +2093,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_path_list<V: Folder + ?Sized>(_visitor: &mut V, _i: PathList) -> PathList {
+pub fn fold_path_list<V: Folder + ?Sized>(_visitor: &mut V, _i: PathList) -> PathList {
     PathList {
         path: _visitor.fold_path(_i . path),
         colon2_token: _i . colon2_token,
@@ -2102,7 +2102,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_path_list_item<V: Folder + ?Sized>(_visitor: &mut V, _i: PathListItem) -> PathListItem {
+pub fn fold_path_list_item<V: Folder + ?Sized>(_visitor: &mut V, _i: PathListItem) -> PathListItem {
     PathListItem {
         name: _i . name,
         rename: _i . rename,
@@ -2110,7 +2110,7 @@
     }
 }
 
-pub fn walk_path_parameters<V: Folder + ?Sized>(_visitor: &mut V, _i: PathParameters) -> PathParameters {
+pub fn fold_path_parameters<V: Folder + ?Sized>(_visitor: &mut V, _i: PathParameters) -> PathParameters {
     use ::PathParameters::*;
     match _i {
         None => { None }
@@ -2127,14 +2127,14 @@
     }
 }
 
-pub fn walk_path_segment<V: Folder + ?Sized>(_visitor: &mut V, _i: PathSegment) -> PathSegment {
+pub fn fold_path_segment<V: Folder + ?Sized>(_visitor: &mut V, _i: PathSegment) -> PathSegment {
     PathSegment {
         ident: _i . ident,
         parameters: _visitor.fold_path_parameters(_i . parameters),
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_path_simple<V: Folder + ?Sized>(_visitor: &mut V, _i: PathSimple) -> PathSimple {
+pub fn fold_path_simple<V: Folder + ?Sized>(_visitor: &mut V, _i: PathSimple) -> PathSimple {
     PathSimple {
         path: _visitor.fold_path(_i . path),
         as_token: _i . as_token,
@@ -2142,14 +2142,14 @@
     }
 }
 
-pub fn walk_poly_trait_ref<V: Folder + ?Sized>(_visitor: &mut V, _i: PolyTraitRef) -> PolyTraitRef {
+pub fn fold_poly_trait_ref<V: Folder + ?Sized>(_visitor: &mut V, _i: PolyTraitRef) -> PolyTraitRef {
     PolyTraitRef {
         bound_lifetimes: (_i . bound_lifetimes).map(|it| { _visitor.fold_bound_lifetimes(it) }),
         trait_ref: _visitor.fold_path(_i . trait_ref),
     }
 }
 
-pub fn walk_qself<V: Folder + ?Sized>(_visitor: &mut V, _i: QSelf) -> QSelf {
+pub fn fold_qself<V: Folder + ?Sized>(_visitor: &mut V, _i: QSelf) -> QSelf {
     QSelf {
         lt_token: _i . lt_token,
         ty: Box::new(_visitor.fold_ty(* _i . ty)),
@@ -2159,7 +2159,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_range_limits<V: Folder + ?Sized>(_visitor: &mut V, _i: RangeLimits) -> RangeLimits {
+pub fn fold_range_limits<V: Folder + ?Sized>(_visitor: &mut V, _i: RangeLimits) -> RangeLimits {
     use ::RangeLimits::*;
     match _i {
         HalfOpen(_binding_0, ) => {
@@ -2175,7 +2175,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_stmt<V: Folder + ?Sized>(_visitor: &mut V, _i: Stmt) -> Stmt {
+pub fn fold_stmt<V: Folder + ?Sized>(_visitor: &mut V, _i: Stmt) -> Stmt {
     use ::Stmt::*;
     match _i {
         Local(_binding_0, ) => {
@@ -2207,7 +2207,7 @@
     }
 }
 
-pub fn walk_trait_bound_modifier<V: Folder + ?Sized>(_visitor: &mut V, _i: TraitBoundModifier) -> TraitBoundModifier {
+pub fn fold_trait_bound_modifier<V: Folder + ?Sized>(_visitor: &mut V, _i: TraitBoundModifier) -> TraitBoundModifier {
     use ::TraitBoundModifier::*;
     match _i {
         None => { None }
@@ -2219,14 +2219,14 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_trait_item<V: Folder + ?Sized>(_visitor: &mut V, _i: TraitItem) -> TraitItem {
+pub fn fold_trait_item<V: Folder + ?Sized>(_visitor: &mut V, _i: TraitItem) -> TraitItem {
     TraitItem {
         attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
         node: _visitor.fold_trait_item_kind(_i . node),
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_trait_item_const<V: Folder + ?Sized>(_visitor: &mut V, _i: TraitItemConst) -> TraitItemConst {
+pub fn fold_trait_item_const<V: Folder + ?Sized>(_visitor: &mut V, _i: TraitItemConst) -> TraitItemConst {
     TraitItemConst {
         const_token: _i . const_token,
         ident: _i . ident,
@@ -2237,7 +2237,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_trait_item_kind<V: Folder + ?Sized>(_visitor: &mut V, _i: TraitItemKind) -> TraitItemKind {
+pub fn fold_trait_item_kind<V: Folder + ?Sized>(_visitor: &mut V, _i: TraitItemKind) -> TraitItemKind {
     use ::TraitItemKind::*;
     match _i {
         Const(_binding_0, ) => {
@@ -2263,7 +2263,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_trait_item_method<V: Folder + ?Sized>(_visitor: &mut V, _i: TraitItemMethod) -> TraitItemMethod {
+pub fn fold_trait_item_method<V: Folder + ?Sized>(_visitor: &mut V, _i: TraitItemMethod) -> TraitItemMethod {
     TraitItemMethod {
         sig: _visitor.fold_method_sig(_i . sig),
         default: (_i . default).map(|it| { _visitor.fold_block(it) }),
@@ -2271,7 +2271,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_trait_item_type<V: Folder + ?Sized>(_visitor: &mut V, _i: TraitItemType) -> TraitItemType {
+pub fn fold_trait_item_type<V: Folder + ?Sized>(_visitor: &mut V, _i: TraitItemType) -> TraitItemType {
     TraitItemType {
         type_token: _i . type_token,
         ident: _i . ident,
@@ -2282,7 +2282,7 @@
     }
 }
 
-pub fn walk_ty<V: Folder + ?Sized>(_visitor: &mut V, _i: Ty) -> Ty {
+pub fn fold_ty<V: Folder + ?Sized>(_visitor: &mut V, _i: Ty) -> Ty {
     use ::Ty::*;
     match _i {
         Slice(_binding_0, ) => {
@@ -2358,7 +2358,7 @@
     }
 }
 
-pub fn walk_ty_array<V: Folder + ?Sized>(_visitor: &mut V, _i: TyArray) -> TyArray {
+pub fn fold_ty_array<V: Folder + ?Sized>(_visitor: &mut V, _i: TyArray) -> TyArray {
     TyArray {
         bracket_token: _i . bracket_token,
         ty: Box::new(_visitor.fold_ty(* _i . ty)),
@@ -2367,39 +2367,39 @@
     }
 }
 
-pub fn walk_ty_bare_fn<V: Folder + ?Sized>(_visitor: &mut V, _i: TyBareFn) -> TyBareFn {
+pub fn fold_ty_bare_fn<V: Folder + ?Sized>(_visitor: &mut V, _i: TyBareFn) -> TyBareFn {
     TyBareFn {
         ty: Box::new(_visitor.fold_bare_fn_ty(* _i . ty)),
     }
 }
 
-pub fn walk_ty_group<V: Folder + ?Sized>(_visitor: &mut V, _i: TyGroup) -> TyGroup {
+pub fn fold_ty_group<V: Folder + ?Sized>(_visitor: &mut V, _i: TyGroup) -> TyGroup {
     TyGroup {
         group_token: _i . group_token,
         ty: Box::new(_visitor.fold_ty(* _i . ty)),
     }
 }
 
-pub fn walk_ty_impl_trait<V: Folder + ?Sized>(_visitor: &mut V, _i: TyImplTrait) -> TyImplTrait {
+pub fn fold_ty_impl_trait<V: Folder + ?Sized>(_visitor: &mut V, _i: TyImplTrait) -> TyImplTrait {
     TyImplTrait {
         impl_token: _i . impl_token,
         bounds: FoldHelper::lift(_i . bounds, |it| { _visitor.fold_ty_param_bound(it) }),
     }
 }
 
-pub fn walk_ty_infer<V: Folder + ?Sized>(_visitor: &mut V, _i: TyInfer) -> TyInfer {
+pub fn fold_ty_infer<V: Folder + ?Sized>(_visitor: &mut V, _i: TyInfer) -> TyInfer {
     TyInfer {
         underscore_token: _i . underscore_token,
     }
 }
 
-pub fn walk_ty_never<V: Folder + ?Sized>(_visitor: &mut V, _i: TyNever) -> TyNever {
+pub fn fold_ty_never<V: Folder + ?Sized>(_visitor: &mut V, _i: TyNever) -> TyNever {
     TyNever {
         bang_token: _i . bang_token,
     }
 }
 
-pub fn walk_ty_param<V: Folder + ?Sized>(_visitor: &mut V, _i: TyParam) -> TyParam {
+pub fn fold_ty_param<V: Folder + ?Sized>(_visitor: &mut V, _i: TyParam) -> TyParam {
     TyParam {
         attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
         ident: _i . ident,
@@ -2410,7 +2410,7 @@
     }
 }
 
-pub fn walk_ty_param_bound<V: Folder + ?Sized>(_visitor: &mut V, _i: TyParamBound) -> TyParamBound {
+pub fn fold_ty_param_bound<V: Folder + ?Sized>(_visitor: &mut V, _i: TyParamBound) -> TyParamBound {
     use ::TyParamBound::*;
     match _i {
         Trait(_binding_0, _binding_1, ) => {
@@ -2427,21 +2427,21 @@
     }
 }
 
-pub fn walk_ty_paren<V: Folder + ?Sized>(_visitor: &mut V, _i: TyParen) -> TyParen {
+pub fn fold_ty_paren<V: Folder + ?Sized>(_visitor: &mut V, _i: TyParen) -> TyParen {
     TyParen {
         paren_token: _i . paren_token,
         ty: Box::new(_visitor.fold_ty(* _i . ty)),
     }
 }
 
-pub fn walk_ty_path<V: Folder + ?Sized>(_visitor: &mut V, _i: TyPath) -> TyPath {
+pub fn fold_ty_path<V: Folder + ?Sized>(_visitor: &mut V, _i: TyPath) -> TyPath {
     TyPath {
         qself: (_i . qself).map(|it| { _visitor.fold_qself(it) }),
         path: _visitor.fold_path(_i . path),
     }
 }
 
-pub fn walk_ty_ptr<V: Folder + ?Sized>(_visitor: &mut V, _i: TyPtr) -> TyPtr {
+pub fn fold_ty_ptr<V: Folder + ?Sized>(_visitor: &mut V, _i: TyPtr) -> TyPtr {
     TyPtr {
         star_token: _i . star_token,
         const_token: _i . const_token,
@@ -2449,7 +2449,7 @@
     }
 }
 
-pub fn walk_ty_rptr<V: Folder + ?Sized>(_visitor: &mut V, _i: TyRptr) -> TyRptr {
+pub fn fold_ty_rptr<V: Folder + ?Sized>(_visitor: &mut V, _i: TyRptr) -> TyRptr {
     TyRptr {
         and_token: _i . and_token,
         lifetime: _i . lifetime,
@@ -2457,20 +2457,20 @@
     }
 }
 
-pub fn walk_ty_slice<V: Folder + ?Sized>(_visitor: &mut V, _i: TySlice) -> TySlice {
+pub fn fold_ty_slice<V: Folder + ?Sized>(_visitor: &mut V, _i: TySlice) -> TySlice {
     TySlice {
         ty: Box::new(_visitor.fold_ty(* _i . ty)),
         bracket_token: _i . bracket_token,
     }
 }
 
-pub fn walk_ty_trait_object<V: Folder + ?Sized>(_visitor: &mut V, _i: TyTraitObject) -> TyTraitObject {
+pub fn fold_ty_trait_object<V: Folder + ?Sized>(_visitor: &mut V, _i: TyTraitObject) -> TyTraitObject {
     TyTraitObject {
         bounds: FoldHelper::lift(_i . bounds, |it| { _visitor.fold_ty_param_bound(it) }),
     }
 }
 
-pub fn walk_ty_tup<V: Folder + ?Sized>(_visitor: &mut V, _i: TyTup) -> TyTup {
+pub fn fold_ty_tup<V: Folder + ?Sized>(_visitor: &mut V, _i: TyTup) -> TyTup {
     TyTup {
         paren_token: _i . paren_token,
         tys: FoldHelper::lift(_i . tys, |it| { _visitor.fold_ty(it) }),
@@ -2478,7 +2478,7 @@
     }
 }
 
-pub fn walk_type_binding<V: Folder + ?Sized>(_visitor: &mut V, _i: TypeBinding) -> TypeBinding {
+pub fn fold_type_binding<V: Folder + ?Sized>(_visitor: &mut V, _i: TypeBinding) -> TypeBinding {
     TypeBinding {
         ident: _i . ident,
         eq_token: _i . eq_token,
@@ -2486,7 +2486,7 @@
     }
 }
 
-pub fn walk_un_op<V: Folder + ?Sized>(_visitor: &mut V, _i: UnOp) -> UnOp {
+pub fn fold_un_op<V: Folder + ?Sized>(_visitor: &mut V, _i: UnOp) -> UnOp {
     use ::UnOp::*;
     match _i {
         Deref(_binding_0, ) => {
@@ -2507,7 +2507,7 @@
     }
 }
 
-pub fn walk_unsafety<V: Folder + ?Sized>(_visitor: &mut V, _i: Unsafety) -> Unsafety {
+pub fn fold_unsafety<V: Folder + ?Sized>(_visitor: &mut V, _i: Unsafety) -> Unsafety {
     use ::Unsafety::*;
     match _i {
         Unsafe(_binding_0, ) => {
@@ -2519,7 +2519,7 @@
     }
 }
 
-pub fn walk_variant<V: Folder + ?Sized>(_visitor: &mut V, _i: Variant) -> Variant {
+pub fn fold_variant<V: Folder + ?Sized>(_visitor: &mut V, _i: Variant) -> Variant {
     Variant {
         ident: _i . ident,
         attrs: FoldHelper::lift(_i . attrs, |it| { _visitor.fold_attribute(it) }),
@@ -2529,7 +2529,7 @@
     }
 }
 
-pub fn walk_variant_data<V: Folder + ?Sized>(_visitor: &mut V, _i: VariantData) -> VariantData {
+pub fn fold_variant_data<V: Folder + ?Sized>(_visitor: &mut V, _i: VariantData) -> VariantData {
     use ::VariantData::*;
     match _i {
         Struct(_binding_0, _binding_1, ) => {
@@ -2548,7 +2548,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_view_path<V: Folder + ?Sized>(_visitor: &mut V, _i: ViewPath) -> ViewPath {
+pub fn fold_view_path<V: Folder + ?Sized>(_visitor: &mut V, _i: ViewPath) -> ViewPath {
     use ::ViewPath::*;
     match _i {
         Simple(_binding_0, ) => {
@@ -2569,7 +2569,7 @@
     }
 }
 
-pub fn walk_vis_crate<V: Folder + ?Sized>(_visitor: &mut V, _i: VisCrate) -> VisCrate {
+pub fn fold_vis_crate<V: Folder + ?Sized>(_visitor: &mut V, _i: VisCrate) -> VisCrate {
     VisCrate {
         pub_token: _i . pub_token,
         paren_token: _i . paren_token,
@@ -2577,18 +2577,18 @@
     }
 }
 
-pub fn walk_vis_inherited<V: Folder + ?Sized>(_visitor: &mut V, _i: VisInherited) -> VisInherited {
+pub fn fold_vis_inherited<V: Folder + ?Sized>(_visitor: &mut V, _i: VisInherited) -> VisInherited {
     VisInherited {
     }
 }
 
-pub fn walk_vis_public<V: Folder + ?Sized>(_visitor: &mut V, _i: VisPublic) -> VisPublic {
+pub fn fold_vis_public<V: Folder + ?Sized>(_visitor: &mut V, _i: VisPublic) -> VisPublic {
     VisPublic {
         pub_token: _i . pub_token,
     }
 }
 
-pub fn walk_vis_restricted<V: Folder + ?Sized>(_visitor: &mut V, _i: VisRestricted) -> VisRestricted {
+pub fn fold_vis_restricted<V: Folder + ?Sized>(_visitor: &mut V, _i: VisRestricted) -> VisRestricted {
     VisRestricted {
         pub_token: _i . pub_token,
         paren_token: _i . paren_token,
@@ -2597,7 +2597,7 @@
     }
 }
 
-pub fn walk_visibility<V: Folder + ?Sized>(_visitor: &mut V, _i: Visibility) -> Visibility {
+pub fn fold_visibility<V: Folder + ?Sized>(_visitor: &mut V, _i: Visibility) -> Visibility {
     use ::Visibility::*;
     match _i {
         Public(_binding_0, ) => {
@@ -2623,7 +2623,7 @@
     }
 }
 
-pub fn walk_where_bound_predicate<V: Folder + ?Sized>(_visitor: &mut V, _i: WhereBoundPredicate) -> WhereBoundPredicate {
+pub fn fold_where_bound_predicate<V: Folder + ?Sized>(_visitor: &mut V, _i: WhereBoundPredicate) -> WhereBoundPredicate {
     WhereBoundPredicate {
         bound_lifetimes: (_i . bound_lifetimes).map(|it| { _visitor.fold_bound_lifetimes(it) }),
         bounded_ty: _visitor.fold_ty(_i . bounded_ty),
@@ -2632,14 +2632,14 @@
     }
 }
 
-pub fn walk_where_clause<V: Folder + ?Sized>(_visitor: &mut V, _i: WhereClause) -> WhereClause {
+pub fn fold_where_clause<V: Folder + ?Sized>(_visitor: &mut V, _i: WhereClause) -> WhereClause {
     WhereClause {
         where_token: _i . where_token,
         predicates: FoldHelper::lift(_i . predicates, |it| { _visitor.fold_where_predicate(it) }),
     }
 }
 
-pub fn walk_where_eq_predicate<V: Folder + ?Sized>(_visitor: &mut V, _i: WhereEqPredicate) -> WhereEqPredicate {
+pub fn fold_where_eq_predicate<V: Folder + ?Sized>(_visitor: &mut V, _i: WhereEqPredicate) -> WhereEqPredicate {
     WhereEqPredicate {
         lhs_ty: _visitor.fold_ty(_i . lhs_ty),
         eq_token: _i . eq_token,
@@ -2647,7 +2647,7 @@
     }
 }
 
-pub fn walk_where_predicate<V: Folder + ?Sized>(_visitor: &mut V, _i: WherePredicate) -> WherePredicate {
+pub fn fold_where_predicate<V: Folder + ?Sized>(_visitor: &mut V, _i: WherePredicate) -> WherePredicate {
     use ::WherePredicate::*;
     match _i {
         BoundPredicate(_binding_0, ) => {
@@ -2668,7 +2668,7 @@
     }
 }
 
-pub fn walk_where_region_predicate<V: Folder + ?Sized>(_visitor: &mut V, _i: WhereRegionPredicate) -> WhereRegionPredicate {
+pub fn fold_where_region_predicate<V: Folder + ?Sized>(_visitor: &mut V, _i: WhereRegionPredicate) -> WhereRegionPredicate {
     WhereRegionPredicate {
         lifetime: _i . lifetime,
         colon_token: _i . colon_token,
diff --git a/src/gen/visit.rs b/src/gen/visit.rs
index d908aef..2ed90cf 100644
--- a/src/gen/visit.rs
+++ b/src/gen/visit.rs
@@ -6,7 +6,7 @@
 //! call `visit::walk_*` to apply the default traversal algorithm, or prevent
 //! deeper traversal by doing nothing.
 
-use super::*;
+use *;
 
 
 #[cfg(feature = "full")]
@@ -31,355 +31,355 @@
 /// new default implementation gets introduced.)
 pub trait Visitor {
 
-fn visit_abi(&mut self, i: &Abi) { walk_abi(self, i) }
+fn visit_abi(&mut self, i: &Abi) { visit_abi(self, i) }
 
-fn visit_abi_kind(&mut self, i: &AbiKind) { walk_abi_kind(self, i) }
+fn visit_abi_kind(&mut self, i: &AbiKind) { visit_abi_kind(self, i) }
 
-fn visit_angle_bracketed_parameter_data(&mut self, i: &AngleBracketedParameterData) { walk_angle_bracketed_parameter_data(self, i) }
+fn visit_angle_bracketed_parameter_data(&mut self, i: &AngleBracketedParameterData) { visit_angle_bracketed_parameter_data(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_arg_captured(&mut self, i: &ArgCaptured) { walk_arg_captured(self, i) }
+fn visit_arg_captured(&mut self, i: &ArgCaptured) { visit_arg_captured(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_arg_self(&mut self, i: &ArgSelf) { walk_arg_self(self, i) }
+fn visit_arg_self(&mut self, i: &ArgSelf) { visit_arg_self(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_arg_self_ref(&mut self, i: &ArgSelfRef) { walk_arg_self_ref(self, i) }
+fn visit_arg_self_ref(&mut self, i: &ArgSelfRef) { visit_arg_self_ref(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_arm(&mut self, i: &Arm) { walk_arm(self, i) }
+fn visit_arm(&mut self, i: &Arm) { visit_arm(self, i) }
 
-fn visit_attr_style(&mut self, i: &AttrStyle) { walk_attr_style(self, i) }
+fn visit_attr_style(&mut self, i: &AttrStyle) { visit_attr_style(self, i) }
 
-fn visit_attribute(&mut self, i: &Attribute) { walk_attribute(self, i) }
+fn visit_attribute(&mut self, i: &Attribute) { visit_attribute(self, i) }
 
-fn visit_bare_fn_arg(&mut self, i: &BareFnArg) { walk_bare_fn_arg(self, i) }
+fn visit_bare_fn_arg(&mut self, i: &BareFnArg) { visit_bare_fn_arg(self, i) }
 
-fn visit_bare_fn_arg_name(&mut self, i: &BareFnArgName) { walk_bare_fn_arg_name(self, i) }
+fn visit_bare_fn_arg_name(&mut self, i: &BareFnArgName) { visit_bare_fn_arg_name(self, i) }
 
-fn visit_bare_fn_ty(&mut self, i: &BareFnTy) { walk_bare_fn_ty(self, i) }
+fn visit_bare_fn_ty(&mut self, i: &BareFnTy) { visit_bare_fn_ty(self, i) }
 
-fn visit_bin_op(&mut self, i: &BinOp) { walk_bin_op(self, i) }
+fn visit_bin_op(&mut self, i: &BinOp) { visit_bin_op(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_binding_mode(&mut self, i: &BindingMode) { walk_binding_mode(self, i) }
+fn visit_binding_mode(&mut self, i: &BindingMode) { visit_binding_mode(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_block(&mut self, i: &Block) { walk_block(self, i) }
+fn visit_block(&mut self, i: &Block) { visit_block(self, i) }
 
-fn visit_body(&mut self, i: &Body) { walk_body(self, i) }
+fn visit_body(&mut self, i: &Body) { visit_body(self, i) }
 
-fn visit_body_enum(&mut self, i: &BodyEnum) { walk_body_enum(self, i) }
+fn visit_body_enum(&mut self, i: &BodyEnum) { visit_body_enum(self, i) }
 
-fn visit_body_struct(&mut self, i: &BodyStruct) { walk_body_struct(self, i) }
+fn visit_body_struct(&mut self, i: &BodyStruct) { visit_body_struct(self, i) }
 
-fn visit_bound_lifetimes(&mut self, i: &BoundLifetimes) { walk_bound_lifetimes(self, i) }
+fn visit_bound_lifetimes(&mut self, i: &BoundLifetimes) { visit_bound_lifetimes(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_capture_by(&mut self, i: &CaptureBy) { walk_capture_by(self, i) }
+fn visit_capture_by(&mut self, i: &CaptureBy) { visit_capture_by(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_constness(&mut self, i: &Constness) { walk_constness(self, i) }
+fn visit_constness(&mut self, i: &Constness) { visit_constness(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_defaultness(&mut self, i: &Defaultness) { walk_defaultness(self, i) }
+fn visit_defaultness(&mut self, i: &Defaultness) { visit_defaultness(self, i) }
 
-fn visit_derive_input(&mut self, i: &DeriveInput) { walk_derive_input(self, i) }
+fn visit_derive_input(&mut self, i: &DeriveInput) { visit_derive_input(self, i) }
 
-fn visit_expr(&mut self, i: &Expr) { walk_expr(self, i) }
+fn visit_expr(&mut self, i: &Expr) { visit_expr(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_addr_of(&mut self, i: &ExprAddrOf) { walk_expr_addr_of(self, i) }
+fn visit_expr_addr_of(&mut self, i: &ExprAddrOf) { visit_expr_addr_of(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_array(&mut self, i: &ExprArray) { walk_expr_array(self, i) }
+fn visit_expr_array(&mut self, i: &ExprArray) { visit_expr_array(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_assign(&mut self, i: &ExprAssign) { walk_expr_assign(self, i) }
+fn visit_expr_assign(&mut self, i: &ExprAssign) { visit_expr_assign(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_assign_op(&mut self, i: &ExprAssignOp) { walk_expr_assign_op(self, i) }
+fn visit_expr_assign_op(&mut self, i: &ExprAssignOp) { visit_expr_assign_op(self, i) }
 
-fn visit_expr_binary(&mut self, i: &ExprBinary) { walk_expr_binary(self, i) }
+fn visit_expr_binary(&mut self, i: &ExprBinary) { visit_expr_binary(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_block(&mut self, i: &ExprBlock) { walk_expr_block(self, i) }
+fn visit_expr_block(&mut self, i: &ExprBlock) { visit_expr_block(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_box(&mut self, i: &ExprBox) { walk_expr_box(self, i) }
+fn visit_expr_box(&mut self, i: &ExprBox) { visit_expr_box(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_break(&mut self, i: &ExprBreak) { walk_expr_break(self, i) }
+fn visit_expr_break(&mut self, i: &ExprBreak) { visit_expr_break(self, i) }
 
-fn visit_expr_call(&mut self, i: &ExprCall) { walk_expr_call(self, i) }
+fn visit_expr_call(&mut self, i: &ExprCall) { visit_expr_call(self, i) }
 
-fn visit_expr_cast(&mut self, i: &ExprCast) { walk_expr_cast(self, i) }
+fn visit_expr_cast(&mut self, i: &ExprCast) { visit_expr_cast(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_catch(&mut self, i: &ExprCatch) { walk_expr_catch(self, i) }
+fn visit_expr_catch(&mut self, i: &ExprCatch) { visit_expr_catch(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_closure(&mut self, i: &ExprClosure) { walk_expr_closure(self, i) }
+fn visit_expr_closure(&mut self, i: &ExprClosure) { visit_expr_closure(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_continue(&mut self, i: &ExprContinue) { walk_expr_continue(self, i) }
+fn visit_expr_continue(&mut self, i: &ExprContinue) { visit_expr_continue(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_field(&mut self, i: &ExprField) { walk_expr_field(self, i) }
+fn visit_expr_field(&mut self, i: &ExprField) { visit_expr_field(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_for_loop(&mut self, i: &ExprForLoop) { walk_expr_for_loop(self, i) }
+fn visit_expr_for_loop(&mut self, i: &ExprForLoop) { visit_expr_for_loop(self, i) }
 
-fn visit_expr_group(&mut self, i: &ExprGroup) { walk_expr_group(self, i) }
+fn visit_expr_group(&mut self, i: &ExprGroup) { visit_expr_group(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_if(&mut self, i: &ExprIf) { walk_expr_if(self, i) }
+fn visit_expr_if(&mut self, i: &ExprIf) { visit_expr_if(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_if_let(&mut self, i: &ExprIfLet) { walk_expr_if_let(self, i) }
+fn visit_expr_if_let(&mut self, i: &ExprIfLet) { visit_expr_if_let(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_in_place(&mut self, i: &ExprInPlace) { walk_expr_in_place(self, i) }
+fn visit_expr_in_place(&mut self, i: &ExprInPlace) { visit_expr_in_place(self, i) }
 
-fn visit_expr_index(&mut self, i: &ExprIndex) { walk_expr_index(self, i) }
+fn visit_expr_index(&mut self, i: &ExprIndex) { visit_expr_index(self, i) }
 
-fn visit_expr_kind(&mut self, i: &ExprKind) { walk_expr_kind(self, i) }
+fn visit_expr_kind(&mut self, i: &ExprKind) { visit_expr_kind(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_loop(&mut self, i: &ExprLoop) { walk_expr_loop(self, i) }
+fn visit_expr_loop(&mut self, i: &ExprLoop) { visit_expr_loop(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_match(&mut self, i: &ExprMatch) { walk_expr_match(self, i) }
+fn visit_expr_match(&mut self, i: &ExprMatch) { visit_expr_match(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_method_call(&mut self, i: &ExprMethodCall) { walk_expr_method_call(self, i) }
+fn visit_expr_method_call(&mut self, i: &ExprMethodCall) { visit_expr_method_call(self, i) }
 
-fn visit_expr_paren(&mut self, i: &ExprParen) { walk_expr_paren(self, i) }
+fn visit_expr_paren(&mut self, i: &ExprParen) { visit_expr_paren(self, i) }
 
-fn visit_expr_path(&mut self, i: &ExprPath) { walk_expr_path(self, i) }
+fn visit_expr_path(&mut self, i: &ExprPath) { visit_expr_path(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_range(&mut self, i: &ExprRange) { walk_expr_range(self, i) }
+fn visit_expr_range(&mut self, i: &ExprRange) { visit_expr_range(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_repeat(&mut self, i: &ExprRepeat) { walk_expr_repeat(self, i) }
+fn visit_expr_repeat(&mut self, i: &ExprRepeat) { visit_expr_repeat(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_ret(&mut self, i: &ExprRet) { walk_expr_ret(self, i) }
+fn visit_expr_ret(&mut self, i: &ExprRet) { visit_expr_ret(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_struct(&mut self, i: &ExprStruct) { walk_expr_struct(self, i) }
+fn visit_expr_struct(&mut self, i: &ExprStruct) { visit_expr_struct(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_try(&mut self, i: &ExprTry) { walk_expr_try(self, i) }
+fn visit_expr_try(&mut self, i: &ExprTry) { visit_expr_try(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_tup(&mut self, i: &ExprTup) { walk_expr_tup(self, i) }
+fn visit_expr_tup(&mut self, i: &ExprTup) { visit_expr_tup(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_tup_field(&mut self, i: &ExprTupField) { walk_expr_tup_field(self, i) }
+fn visit_expr_tup_field(&mut self, i: &ExprTupField) { visit_expr_tup_field(self, i) }
 
-fn visit_expr_type(&mut self, i: &ExprType) { walk_expr_type(self, i) }
+fn visit_expr_type(&mut self, i: &ExprType) { visit_expr_type(self, i) }
 
-fn visit_expr_unary(&mut self, i: &ExprUnary) { walk_expr_unary(self, i) }
+fn visit_expr_unary(&mut self, i: &ExprUnary) { visit_expr_unary(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_while(&mut self, i: &ExprWhile) { walk_expr_while(self, i) }
+fn visit_expr_while(&mut self, i: &ExprWhile) { visit_expr_while(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_while_let(&mut self, i: &ExprWhileLet) { walk_expr_while_let(self, i) }
+fn visit_expr_while_let(&mut self, i: &ExprWhileLet) { visit_expr_while_let(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_yield(&mut self, i: &ExprYield) { walk_expr_yield(self, i) }
+fn visit_expr_yield(&mut self, i: &ExprYield) { visit_expr_yield(self, i) }
 
-fn visit_field(&mut self, i: &Field) { walk_field(self, i) }
+fn visit_field(&mut self, i: &Field) { visit_field(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_field_pat(&mut self, i: &FieldPat) { walk_field_pat(self, i) }
+fn visit_field_pat(&mut self, i: &FieldPat) { visit_field_pat(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_field_value(&mut self, i: &FieldValue) { walk_field_value(self, i) }
+fn visit_field_value(&mut self, i: &FieldValue) { visit_field_value(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_file(&mut self, i: &File) { walk_file(self, i) }
+fn visit_file(&mut self, i: &File) { visit_file(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_fn_arg(&mut self, i: &FnArg) { walk_fn_arg(self, i) }
+fn visit_fn_arg(&mut self, i: &FnArg) { visit_fn_arg(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_fn_decl(&mut self, i: &FnDecl) { walk_fn_decl(self, i) }
+fn visit_fn_decl(&mut self, i: &FnDecl) { visit_fn_decl(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_foreign_item(&mut self, i: &ForeignItem) { walk_foreign_item(self, i) }
+fn visit_foreign_item(&mut self, i: &ForeignItem) { visit_foreign_item(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_foreign_item_fn(&mut self, i: &ForeignItemFn) { walk_foreign_item_fn(self, i) }
+fn visit_foreign_item_fn(&mut self, i: &ForeignItemFn) { visit_foreign_item_fn(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_foreign_item_kind(&mut self, i: &ForeignItemKind) { walk_foreign_item_kind(self, i) }
+fn visit_foreign_item_kind(&mut self, i: &ForeignItemKind) { visit_foreign_item_kind(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_foreign_item_static(&mut self, i: &ForeignItemStatic) { walk_foreign_item_static(self, i) }
+fn visit_foreign_item_static(&mut self, i: &ForeignItemStatic) { visit_foreign_item_static(self, i) }
 
-fn visit_function_ret_ty(&mut self, i: &FunctionRetTy) { walk_function_ret_ty(self, i) }
+fn visit_function_ret_ty(&mut self, i: &FunctionRetTy) { visit_function_ret_ty(self, i) }
 
-fn visit_generics(&mut self, i: &Generics) { walk_generics(self, i) }
+fn visit_generics(&mut self, i: &Generics) { visit_generics(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_impl_item(&mut self, i: &ImplItem) { walk_impl_item(self, i) }
+fn visit_impl_item(&mut self, i: &ImplItem) { visit_impl_item(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_impl_item_const(&mut self, i: &ImplItemConst) { walk_impl_item_const(self, i) }
+fn visit_impl_item_const(&mut self, i: &ImplItemConst) { visit_impl_item_const(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_impl_item_kind(&mut self, i: &ImplItemKind) { walk_impl_item_kind(self, i) }
+fn visit_impl_item_kind(&mut self, i: &ImplItemKind) { visit_impl_item_kind(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_impl_item_method(&mut self, i: &ImplItemMethod) { walk_impl_item_method(self, i) }
+fn visit_impl_item_method(&mut self, i: &ImplItemMethod) { visit_impl_item_method(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_impl_item_type(&mut self, i: &ImplItemType) { walk_impl_item_type(self, i) }
+fn visit_impl_item_type(&mut self, i: &ImplItemType) { visit_impl_item_type(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_impl_polarity(&mut self, i: &ImplPolarity) { walk_impl_polarity(self, i) }
+fn visit_impl_polarity(&mut self, i: &ImplPolarity) { visit_impl_polarity(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_in_place_kind(&mut self, i: &InPlaceKind) { walk_in_place_kind(self, i) }
+fn visit_in_place_kind(&mut self, i: &InPlaceKind) { visit_in_place_kind(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_item(&mut self, i: &Item) { walk_item(self, i) }
+fn visit_item(&mut self, i: &Item) { visit_item(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_item_const(&mut self, i: &ItemConst) { walk_item_const(self, i) }
+fn visit_item_const(&mut self, i: &ItemConst) { visit_item_const(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_item_default_impl(&mut self, i: &ItemDefaultImpl) { walk_item_default_impl(self, i) }
+fn visit_item_default_impl(&mut self, i: &ItemDefaultImpl) { visit_item_default_impl(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_item_enum(&mut self, i: &ItemEnum) { walk_item_enum(self, i) }
+fn visit_item_enum(&mut self, i: &ItemEnum) { visit_item_enum(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_item_extern_crate(&mut self, i: &ItemExternCrate) { walk_item_extern_crate(self, i) }
+fn visit_item_extern_crate(&mut self, i: &ItemExternCrate) { visit_item_extern_crate(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_item_fn(&mut self, i: &ItemFn) { walk_item_fn(self, i) }
+fn visit_item_fn(&mut self, i: &ItemFn) { visit_item_fn(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_item_foreign_mod(&mut self, i: &ItemForeignMod) { walk_item_foreign_mod(self, i) }
+fn visit_item_foreign_mod(&mut self, i: &ItemForeignMod) { visit_item_foreign_mod(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_item_impl(&mut self, i: &ItemImpl) { walk_item_impl(self, i) }
+fn visit_item_impl(&mut self, i: &ItemImpl) { visit_item_impl(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_item_kind(&mut self, i: &ItemKind) { walk_item_kind(self, i) }
+fn visit_item_kind(&mut self, i: &ItemKind) { visit_item_kind(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_item_mod(&mut self, i: &ItemMod) { walk_item_mod(self, i) }
+fn visit_item_mod(&mut self, i: &ItemMod) { visit_item_mod(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_item_static(&mut self, i: &ItemStatic) { walk_item_static(self, i) }
+fn visit_item_static(&mut self, i: &ItemStatic) { visit_item_static(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_item_struct(&mut self, i: &ItemStruct) { walk_item_struct(self, i) }
+fn visit_item_struct(&mut self, i: &ItemStruct) { visit_item_struct(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_item_trait(&mut self, i: &ItemTrait) { walk_item_trait(self, i) }
+fn visit_item_trait(&mut self, i: &ItemTrait) { visit_item_trait(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_item_ty(&mut self, i: &ItemTy) { walk_item_ty(self, i) }
+fn visit_item_ty(&mut self, i: &ItemTy) { visit_item_ty(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_item_union(&mut self, i: &ItemUnion) { walk_item_union(self, i) }
+fn visit_item_union(&mut self, i: &ItemUnion) { visit_item_union(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_item_use(&mut self, i: &ItemUse) { walk_item_use(self, i) }
+fn visit_item_use(&mut self, i: &ItemUse) { visit_item_use(self, i) }
 
-fn visit_lifetime_def(&mut self, i: &LifetimeDef) { walk_lifetime_def(self, i) }
+fn visit_lifetime_def(&mut self, i: &LifetimeDef) { visit_lifetime_def(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_local(&mut self, i: &Local) { walk_local(self, i) }
+fn visit_local(&mut self, i: &Local) { visit_local(self, i) }
 
-fn visit_mac(&mut self, i: &Mac) { walk_mac(self, i) }
+fn visit_mac(&mut self, i: &Mac) { visit_mac(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_mac_stmt_style(&mut self, i: &MacStmtStyle) { walk_mac_stmt_style(self, i) }
+fn visit_mac_stmt_style(&mut self, i: &MacStmtStyle) { visit_mac_stmt_style(self, i) }
 
-fn visit_meta_item(&mut self, i: &MetaItem) { walk_meta_item(self, i) }
+fn visit_meta_item(&mut self, i: &MetaItem) { visit_meta_item(self, i) }
 
-fn visit_meta_item_list(&mut self, i: &MetaItemList) { walk_meta_item_list(self, i) }
+fn visit_meta_item_list(&mut self, i: &MetaItemList) { visit_meta_item_list(self, i) }
 
-fn visit_meta_name_value(&mut self, i: &MetaNameValue) { walk_meta_name_value(self, i) }
+fn visit_meta_name_value(&mut self, i: &MetaNameValue) { visit_meta_name_value(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_method_sig(&mut self, i: &MethodSig) { walk_method_sig(self, i) }
+fn visit_method_sig(&mut self, i: &MethodSig) { visit_method_sig(self, i) }
 
-fn visit_mut_ty(&mut self, i: &MutTy) { walk_mut_ty(self, i) }
+fn visit_mut_ty(&mut self, i: &MutTy) { visit_mut_ty(self, i) }
 
-fn visit_mutability(&mut self, i: &Mutability) { walk_mutability(self, i) }
+fn visit_mutability(&mut self, i: &Mutability) { visit_mutability(self, i) }
 
-fn visit_nested_meta_item(&mut self, i: &NestedMetaItem) { walk_nested_meta_item(self, i) }
+fn visit_nested_meta_item(&mut self, i: &NestedMetaItem) { visit_nested_meta_item(self, i) }
 
-fn visit_parenthesized_parameter_data(&mut self, i: &ParenthesizedParameterData) { walk_parenthesized_parameter_data(self, i) }
+fn visit_parenthesized_parameter_data(&mut self, i: &ParenthesizedParameterData) { visit_parenthesized_parameter_data(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_pat(&mut self, i: &Pat) { walk_pat(self, i) }
+fn visit_pat(&mut self, i: &Pat) { visit_pat(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_pat_box(&mut self, i: &PatBox) { walk_pat_box(self, i) }
+fn visit_pat_box(&mut self, i: &PatBox) { visit_pat_box(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_pat_ident(&mut self, i: &PatIdent) { walk_pat_ident(self, i) }
+fn visit_pat_ident(&mut self, i: &PatIdent) { visit_pat_ident(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_pat_lit(&mut self, i: &PatLit) { walk_pat_lit(self, i) }
+fn visit_pat_lit(&mut self, i: &PatLit) { visit_pat_lit(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_pat_path(&mut self, i: &PatPath) { walk_pat_path(self, i) }
+fn visit_pat_path(&mut self, i: &PatPath) { visit_pat_path(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_pat_range(&mut self, i: &PatRange) { walk_pat_range(self, i) }
+fn visit_pat_range(&mut self, i: &PatRange) { visit_pat_range(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_pat_ref(&mut self, i: &PatRef) { walk_pat_ref(self, i) }
+fn visit_pat_ref(&mut self, i: &PatRef) { visit_pat_ref(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_pat_slice(&mut self, i: &PatSlice) { walk_pat_slice(self, i) }
+fn visit_pat_slice(&mut self, i: &PatSlice) { visit_pat_slice(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_pat_struct(&mut self, i: &PatStruct) { walk_pat_struct(self, i) }
+fn visit_pat_struct(&mut self, i: &PatStruct) { visit_pat_struct(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_pat_tuple(&mut self, i: &PatTuple) { walk_pat_tuple(self, i) }
+fn visit_pat_tuple(&mut self, i: &PatTuple) { visit_pat_tuple(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_pat_tuple_struct(&mut self, i: &PatTupleStruct) { walk_pat_tuple_struct(self, i) }
+fn visit_pat_tuple_struct(&mut self, i: &PatTupleStruct) { visit_pat_tuple_struct(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_pat_wild(&mut self, i: &PatWild) { walk_pat_wild(self, i) }
+fn visit_pat_wild(&mut self, i: &PatWild) { visit_pat_wild(self, i) }
 
-fn visit_path(&mut self, i: &Path) { walk_path(self, i) }
+fn visit_path(&mut self, i: &Path) { visit_path(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_path_glob(&mut self, i: &PathGlob) { walk_path_glob(self, i) }
+fn visit_path_glob(&mut self, i: &PathGlob) { visit_path_glob(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_path_list(&mut self, i: &PathList) { walk_path_list(self, i) }
+fn visit_path_list(&mut self, i: &PathList) { visit_path_list(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_path_list_item(&mut self, i: &PathListItem) { walk_path_list_item(self, i) }
+fn visit_path_list_item(&mut self, i: &PathListItem) { visit_path_list_item(self, i) }
 
-fn visit_path_parameters(&mut self, i: &PathParameters) { walk_path_parameters(self, i) }
+fn visit_path_parameters(&mut self, i: &PathParameters) { visit_path_parameters(self, i) }
 
-fn visit_path_segment(&mut self, i: &PathSegment) { walk_path_segment(self, i) }
+fn visit_path_segment(&mut self, i: &PathSegment) { visit_path_segment(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_path_simple(&mut self, i: &PathSimple) { walk_path_simple(self, i) }
+fn visit_path_simple(&mut self, i: &PathSimple) { visit_path_simple(self, i) }
 
-fn visit_poly_trait_ref(&mut self, i: &PolyTraitRef) { walk_poly_trait_ref(self, i) }
+fn visit_poly_trait_ref(&mut self, i: &PolyTraitRef) { visit_poly_trait_ref(self, i) }
 
-fn visit_qself(&mut self, i: &QSelf) { walk_qself(self, i) }
+fn visit_qself(&mut self, i: &QSelf) { visit_qself(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_range_limits(&mut self, i: &RangeLimits) { walk_range_limits(self, i) }
+fn visit_range_limits(&mut self, i: &RangeLimits) { visit_range_limits(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_stmt(&mut self, i: &Stmt) { walk_stmt(self, i) }
+fn visit_stmt(&mut self, i: &Stmt) { visit_stmt(self, i) }
 
-fn visit_trait_bound_modifier(&mut self, i: &TraitBoundModifier) { walk_trait_bound_modifier(self, i) }
+fn visit_trait_bound_modifier(&mut self, i: &TraitBoundModifier) { visit_trait_bound_modifier(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_trait_item(&mut self, i: &TraitItem) { walk_trait_item(self, i) }
+fn visit_trait_item(&mut self, i: &TraitItem) { visit_trait_item(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_trait_item_const(&mut self, i: &TraitItemConst) { walk_trait_item_const(self, i) }
+fn visit_trait_item_const(&mut self, i: &TraitItemConst) { visit_trait_item_const(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_trait_item_kind(&mut self, i: &TraitItemKind) { walk_trait_item_kind(self, i) }
+fn visit_trait_item_kind(&mut self, i: &TraitItemKind) { visit_trait_item_kind(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_trait_item_method(&mut self, i: &TraitItemMethod) { walk_trait_item_method(self, i) }
+fn visit_trait_item_method(&mut self, i: &TraitItemMethod) { visit_trait_item_method(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_trait_item_type(&mut self, i: &TraitItemType) { walk_trait_item_type(self, i) }
+fn visit_trait_item_type(&mut self, i: &TraitItemType) { visit_trait_item_type(self, i) }
 
-fn visit_ty(&mut self, i: &Ty) { walk_ty(self, i) }
+fn visit_ty(&mut self, i: &Ty) { visit_ty(self, i) }
 
-fn visit_ty_array(&mut self, i: &TyArray) { walk_ty_array(self, i) }
+fn visit_ty_array(&mut self, i: &TyArray) { visit_ty_array(self, i) }
 
-fn visit_ty_bare_fn(&mut self, i: &TyBareFn) { walk_ty_bare_fn(self, i) }
+fn visit_ty_bare_fn(&mut self, i: &TyBareFn) { visit_ty_bare_fn(self, i) }
 
-fn visit_ty_group(&mut self, i: &TyGroup) { walk_ty_group(self, i) }
+fn visit_ty_group(&mut self, i: &TyGroup) { visit_ty_group(self, i) }
 
-fn visit_ty_impl_trait(&mut self, i: &TyImplTrait) { walk_ty_impl_trait(self, i) }
+fn visit_ty_impl_trait(&mut self, i: &TyImplTrait) { visit_ty_impl_trait(self, i) }
 
-fn visit_ty_infer(&mut self, i: &TyInfer) { walk_ty_infer(self, i) }
+fn visit_ty_infer(&mut self, i: &TyInfer) { visit_ty_infer(self, i) }
 
-fn visit_ty_never(&mut self, i: &TyNever) { walk_ty_never(self, i) }
+fn visit_ty_never(&mut self, i: &TyNever) { visit_ty_never(self, i) }
 
-fn visit_ty_param(&mut self, i: &TyParam) { walk_ty_param(self, i) }
+fn visit_ty_param(&mut self, i: &TyParam) { visit_ty_param(self, i) }
 
-fn visit_ty_param_bound(&mut self, i: &TyParamBound) { walk_ty_param_bound(self, i) }
+fn visit_ty_param_bound(&mut self, i: &TyParamBound) { visit_ty_param_bound(self, i) }
 
-fn visit_ty_paren(&mut self, i: &TyParen) { walk_ty_paren(self, i) }
+fn visit_ty_paren(&mut self, i: &TyParen) { visit_ty_paren(self, i) }
 
-fn visit_ty_path(&mut self, i: &TyPath) { walk_ty_path(self, i) }
+fn visit_ty_path(&mut self, i: &TyPath) { visit_ty_path(self, i) }
 
-fn visit_ty_ptr(&mut self, i: &TyPtr) { walk_ty_ptr(self, i) }
+fn visit_ty_ptr(&mut self, i: &TyPtr) { visit_ty_ptr(self, i) }
 
-fn visit_ty_rptr(&mut self, i: &TyRptr) { walk_ty_rptr(self, i) }
+fn visit_ty_rptr(&mut self, i: &TyRptr) { visit_ty_rptr(self, i) }
 
-fn visit_ty_slice(&mut self, i: &TySlice) { walk_ty_slice(self, i) }
+fn visit_ty_slice(&mut self, i: &TySlice) { visit_ty_slice(self, i) }
 
-fn visit_ty_trait_object(&mut self, i: &TyTraitObject) { walk_ty_trait_object(self, i) }
+fn visit_ty_trait_object(&mut self, i: &TyTraitObject) { visit_ty_trait_object(self, i) }
 
-fn visit_ty_tup(&mut self, i: &TyTup) { walk_ty_tup(self, i) }
+fn visit_ty_tup(&mut self, i: &TyTup) { visit_ty_tup(self, i) }
 
-fn visit_type_binding(&mut self, i: &TypeBinding) { walk_type_binding(self, i) }
+fn visit_type_binding(&mut self, i: &TypeBinding) { visit_type_binding(self, i) }
 
-fn visit_un_op(&mut self, i: &UnOp) { walk_un_op(self, i) }
+fn visit_un_op(&mut self, i: &UnOp) { visit_un_op(self, i) }
 
-fn visit_unsafety(&mut self, i: &Unsafety) { walk_unsafety(self, i) }
+fn visit_unsafety(&mut self, i: &Unsafety) { visit_unsafety(self, i) }
 
-fn visit_variant(&mut self, i: &Variant) { walk_variant(self, i) }
+fn visit_variant(&mut self, i: &Variant) { visit_variant(self, i) }
 
-fn visit_variant_data(&mut self, i: &VariantData) { walk_variant_data(self, i) }
+fn visit_variant_data(&mut self, i: &VariantData) { visit_variant_data(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_view_path(&mut self, i: &ViewPath) { walk_view_path(self, i) }
+fn visit_view_path(&mut self, i: &ViewPath) { visit_view_path(self, i) }
 
-fn visit_vis_crate(&mut self, i: &VisCrate) { walk_vis_crate(self, i) }
+fn visit_vis_crate(&mut self, i: &VisCrate) { visit_vis_crate(self, i) }
 
-fn visit_vis_inherited(&mut self, i: &VisInherited) { walk_vis_inherited(self, i) }
+fn visit_vis_inherited(&mut self, i: &VisInherited) { visit_vis_inherited(self, i) }
 
-fn visit_vis_public(&mut self, i: &VisPublic) { walk_vis_public(self, i) }
+fn visit_vis_public(&mut self, i: &VisPublic) { visit_vis_public(self, i) }
 
-fn visit_vis_restricted(&mut self, i: &VisRestricted) { walk_vis_restricted(self, i) }
+fn visit_vis_restricted(&mut self, i: &VisRestricted) { visit_vis_restricted(self, i) }
 
-fn visit_visibility(&mut self, i: &Visibility) { walk_visibility(self, i) }
+fn visit_visibility(&mut self, i: &Visibility) { visit_visibility(self, i) }
 
-fn visit_where_bound_predicate(&mut self, i: &WhereBoundPredicate) { walk_where_bound_predicate(self, i) }
+fn visit_where_bound_predicate(&mut self, i: &WhereBoundPredicate) { visit_where_bound_predicate(self, i) }
 
-fn visit_where_clause(&mut self, i: &WhereClause) { walk_where_clause(self, i) }
+fn visit_where_clause(&mut self, i: &WhereClause) { visit_where_clause(self, i) }
 
-fn visit_where_eq_predicate(&mut self, i: &WhereEqPredicate) { walk_where_eq_predicate(self, i) }
+fn visit_where_eq_predicate(&mut self, i: &WhereEqPredicate) { visit_where_eq_predicate(self, i) }
 
-fn visit_where_predicate(&mut self, i: &WherePredicate) { walk_where_predicate(self, i) }
+fn visit_where_predicate(&mut self, i: &WherePredicate) { visit_where_predicate(self, i) }
 
-fn visit_where_region_predicate(&mut self, i: &WhereRegionPredicate) { walk_where_region_predicate(self, i) }
+fn visit_where_region_predicate(&mut self, i: &WhereRegionPredicate) { visit_where_region_predicate(self, i) }
 
 }
 
 
-pub fn walk_abi<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Abi) {
+pub fn visit_abi<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Abi) {
     // Skipped field _i . extern_token;
     _visitor.visit_abi_kind(&_i . kind);
 }
 
-pub fn walk_abi_kind<V: Visitor + ?Sized>(_visitor: &mut V, _i: &AbiKind) {
+pub fn visit_abi_kind<V: Visitor + ?Sized>(_visitor: &mut V, _i: &AbiKind) {
     use ::AbiKind::*;
     match *_i {
         Named(ref _binding_0, ) => {
@@ -389,7 +389,7 @@
     }
 }
 
-pub fn walk_angle_bracketed_parameter_data<V: Visitor + ?Sized>(_visitor: &mut V, _i: &AngleBracketedParameterData) {
+pub fn visit_angle_bracketed_parameter_data<V: Visitor + ?Sized>(_visitor: &mut V, _i: &AngleBracketedParameterData) {
     // Skipped field _i . turbofish;
     // Skipped field _i . lt_token;
     // Skipped field _i . lifetimes;
@@ -398,25 +398,25 @@
     // Skipped field _i . gt_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_arg_captured<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ArgCaptured) {
+pub fn visit_arg_captured<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ArgCaptured) {
     _visitor.visit_pat(&_i . pat);
     // Skipped field _i . colon_token;
     _visitor.visit_ty(&_i . ty);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_arg_self<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ArgSelf) {
+pub fn visit_arg_self<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ArgSelf) {
     _visitor.visit_mutability(&_i . mutbl);
     // Skipped field _i . self_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_arg_self_ref<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ArgSelfRef) {
+pub fn visit_arg_self_ref<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ArgSelfRef) {
     // Skipped field _i . and_token;
     // Skipped field _i . self_token;
     // Skipped field _i . lifetime;
     _visitor.visit_mutability(&_i . mutbl);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_arm<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Arm) {
+pub fn visit_arm<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Arm) {
     for it in (_i . attrs).iter() { _visitor.visit_attribute(&it) };
     for el in (_i . pats).iter() { let it = el.item(); _visitor.visit_pat(&it) };
     // Skipped field _i . if_token;
@@ -426,7 +426,7 @@
     // Skipped field _i . comma;
 }
 
-pub fn walk_attr_style<V: Visitor + ?Sized>(_visitor: &mut V, _i: &AttrStyle) {
+pub fn visit_attr_style<V: Visitor + ?Sized>(_visitor: &mut V, _i: &AttrStyle) {
     use ::AttrStyle::*;
     match *_i {
         Outer => { }
@@ -436,7 +436,7 @@
     }
 }
 
-pub fn walk_attribute<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Attribute) {
+pub fn visit_attribute<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Attribute) {
     _visitor.visit_attr_style(&_i . style);
     // Skipped field _i . pound_token;
     // Skipped field _i . bracket_token;
@@ -445,12 +445,12 @@
     // Skipped field _i . is_sugared_doc;
 }
 
-pub fn walk_bare_fn_arg<V: Visitor + ?Sized>(_visitor: &mut V, _i: &BareFnArg) {
+pub fn visit_bare_fn_arg<V: Visitor + ?Sized>(_visitor: &mut V, _i: &BareFnArg) {
     // Skipped field _i . name;
     _visitor.visit_ty(&_i . ty);
 }
 
-pub fn walk_bare_fn_arg_name<V: Visitor + ?Sized>(_visitor: &mut V, _i: &BareFnArgName) {
+pub fn visit_bare_fn_arg_name<V: Visitor + ?Sized>(_visitor: &mut V, _i: &BareFnArgName) {
     use ::BareFnArgName::*;
     match *_i {
         Named(ref _binding_0, ) => {
@@ -462,7 +462,7 @@
     }
 }
 
-pub fn walk_bare_fn_ty<V: Visitor + ?Sized>(_visitor: &mut V, _i: &BareFnTy) {
+pub fn visit_bare_fn_ty<V: Visitor + ?Sized>(_visitor: &mut V, _i: &BareFnTy) {
     if let Some(ref it) = _i . lifetimes { _visitor.visit_bound_lifetimes(&* it) };
     _visitor.visit_unsafety(&_i . unsafety);
     if let Some(ref it) = _i . abi { _visitor.visit_abi(&* it) };
@@ -473,7 +473,7 @@
     _visitor.visit_function_ret_ty(&_i . output);
 }
 
-pub fn walk_bin_op<V: Visitor + ?Sized>(_visitor: &mut V, _i: &BinOp) {
+pub fn visit_bin_op<V: Visitor + ?Sized>(_visitor: &mut V, _i: &BinOp) {
     use ::BinOp::*;
     match *_i {
         Add(ref _binding_0, ) => {
@@ -563,7 +563,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_binding_mode<V: Visitor + ?Sized>(_visitor: &mut V, _i: &BindingMode) {
+pub fn visit_binding_mode<V: Visitor + ?Sized>(_visitor: &mut V, _i: &BindingMode) {
     use ::BindingMode::*;
     match *_i {
         ByRef(ref _binding_0, ref _binding_1, ) => {
@@ -576,12 +576,12 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_block<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Block) {
+pub fn visit_block<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Block) {
     // Skipped field _i . brace_token;
     for it in (_i . stmts).iter() { _visitor.visit_stmt(&it) };
 }
 
-pub fn walk_body<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Body) {
+pub fn visit_body<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Body) {
     use ::Body::*;
     match *_i {
         Enum(ref _binding_0, ) => {
@@ -593,26 +593,26 @@
     }
 }
 
-pub fn walk_body_enum<V: Visitor + ?Sized>(_visitor: &mut V, _i: &BodyEnum) {
+pub fn visit_body_enum<V: Visitor + ?Sized>(_visitor: &mut V, _i: &BodyEnum) {
     // Skipped field _i . enum_token;
     // Skipped field _i . brace_token;
     for el in (_i . variants).iter() { let it = el.item(); _visitor.visit_variant(&it) };
 }
 
-pub fn walk_body_struct<V: Visitor + ?Sized>(_visitor: &mut V, _i: &BodyStruct) {
+pub fn visit_body_struct<V: Visitor + ?Sized>(_visitor: &mut V, _i: &BodyStruct) {
     _visitor.visit_variant_data(&_i . data);
     // Skipped field _i . struct_token;
     // Skipped field _i . semi_token;
 }
 
-pub fn walk_bound_lifetimes<V: Visitor + ?Sized>(_visitor: &mut V, _i: &BoundLifetimes) {
+pub fn visit_bound_lifetimes<V: Visitor + ?Sized>(_visitor: &mut V, _i: &BoundLifetimes) {
     // Skipped field _i . for_token;
     // Skipped field _i . lt_token;
     for el in (_i . lifetimes).iter() { let it = el.item(); _visitor.visit_lifetime_def(&it) };
     // Skipped field _i . gt_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_capture_by<V: Visitor + ?Sized>(_visitor: &mut V, _i: &CaptureBy) {
+pub fn visit_capture_by<V: Visitor + ?Sized>(_visitor: &mut V, _i: &CaptureBy) {
     use ::CaptureBy::*;
     match *_i {
         Value(ref _binding_0, ) => {
@@ -622,7 +622,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_constness<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Constness) {
+pub fn visit_constness<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Constness) {
     use ::Constness::*;
     match *_i {
         Const(ref _binding_0, ) => {
@@ -632,7 +632,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_defaultness<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Defaultness) {
+pub fn visit_defaultness<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Defaultness) {
     use ::Defaultness::*;
     match *_i {
         Default(ref _binding_0, ) => {
@@ -642,7 +642,7 @@
     }
 }
 
-pub fn walk_derive_input<V: Visitor + ?Sized>(_visitor: &mut V, _i: &DeriveInput) {
+pub fn visit_derive_input<V: Visitor + ?Sized>(_visitor: &mut V, _i: &DeriveInput) {
     // Skipped field _i . ident;
     _visitor.visit_visibility(&_i . vis);
     for it in (_i . attrs).iter() { _visitor.visit_attribute(&it) };
@@ -650,75 +650,75 @@
     _visitor.visit_body(&_i . body);
 }
 
-pub fn walk_expr<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Expr) {
+pub fn visit_expr<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Expr) {
     _visitor.visit_expr_kind(&_i . node);
     for it in (_i . attrs).iter() { _visitor.visit_attribute(&it) };
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_addr_of<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprAddrOf) {
+pub fn visit_expr_addr_of<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprAddrOf) {
     // Skipped field _i . and_token;
     _visitor.visit_mutability(&_i . mutbl);
     _visitor.visit_expr(&_i . expr);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_array<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprArray) {
+pub fn visit_expr_array<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprArray) {
     for el in (_i . exprs).iter() { let it = el.item(); _visitor.visit_expr(&it) };
     // Skipped field _i . bracket_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_assign<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprAssign) {
+pub fn visit_expr_assign<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprAssign) {
     _visitor.visit_expr(&_i . left);
     _visitor.visit_expr(&_i . right);
     // Skipped field _i . eq_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_assign_op<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprAssignOp) {
+pub fn visit_expr_assign_op<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprAssignOp) {
     _visitor.visit_bin_op(&_i . op);
     _visitor.visit_expr(&_i . left);
     _visitor.visit_expr(&_i . right);
 }
 
-pub fn walk_expr_binary<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprBinary) {
+pub fn visit_expr_binary<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprBinary) {
     _visitor.visit_bin_op(&_i . op);
     _visitor.visit_expr(&_i . left);
     _visitor.visit_expr(&_i . right);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_block<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprBlock) {
+pub fn visit_expr_block<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprBlock) {
     _visitor.visit_unsafety(&_i . unsafety);
     _visitor.visit_block(&_i . block);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_box<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprBox) {
+pub fn visit_expr_box<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprBox) {
     _visitor.visit_expr(&_i . expr);
     // Skipped field _i . box_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_break<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprBreak) {
+pub fn visit_expr_break<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprBreak) {
     // Skipped field _i . label;
     if let Some(ref it) = _i . expr { _visitor.visit_expr(&* it) };
     // Skipped field _i . break_token;
 }
 
-pub fn walk_expr_call<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprCall) {
+pub fn visit_expr_call<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprCall) {
     _visitor.visit_expr(&_i . func);
     for el in (_i . args).iter() { let it = el.item(); _visitor.visit_expr(&it) };
     // Skipped field _i . paren_token;
 }
 
-pub fn walk_expr_cast<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprCast) {
+pub fn visit_expr_cast<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprCast) {
     _visitor.visit_expr(&_i . expr);
     // Skipped field _i . as_token;
     _visitor.visit_ty(&_i . ty);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_catch<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprCatch) {
+pub fn visit_expr_catch<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprCatch) {
     // Skipped field _i . do_token;
     // Skipped field _i . catch_token;
     _visitor.visit_block(&_i . block);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_closure<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprClosure) {
+pub fn visit_expr_closure<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprClosure) {
     _visitor.visit_capture_by(&_i . capture);
     _visitor.visit_fn_decl(&_i . decl);
     _visitor.visit_expr(&_i . body);
@@ -726,18 +726,18 @@
     // Skipped field _i . or2_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_continue<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprContinue) {
+pub fn visit_expr_continue<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprContinue) {
     // Skipped field _i . label;
     // Skipped field _i . continue_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_field<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprField) {
+pub fn visit_expr_field<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprField) {
     _visitor.visit_expr(&_i . expr);
     // Skipped field _i . field;
     // Skipped field _i . dot_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_for_loop<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprForLoop) {
+pub fn visit_expr_for_loop<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprForLoop) {
     _visitor.visit_pat(&_i . pat);
     _visitor.visit_expr(&_i . expr);
     _visitor.visit_block(&_i . body);
@@ -747,12 +747,12 @@
     // Skipped field _i . in_token;
 }
 
-pub fn walk_expr_group<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprGroup) {
+pub fn visit_expr_group<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprGroup) {
     _visitor.visit_expr(&_i . expr);
     // Skipped field _i . group_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_if<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprIf) {
+pub fn visit_expr_if<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprIf) {
     _visitor.visit_expr(&_i . cond);
     _visitor.visit_block(&_i . if_true);
     if let Some(ref it) = _i . if_false { _visitor.visit_expr(&* it) };
@@ -760,7 +760,7 @@
     // Skipped field _i . else_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_if_let<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprIfLet) {
+pub fn visit_expr_if_let<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprIfLet) {
     _visitor.visit_pat(&_i . pat);
     _visitor.visit_expr(&_i . expr);
     _visitor.visit_block(&_i . if_true);
@@ -771,19 +771,19 @@
     // Skipped field _i . else_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_in_place<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprInPlace) {
+pub fn visit_expr_in_place<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprInPlace) {
     _visitor.visit_expr(&_i . place);
     _visitor.visit_in_place_kind(&_i . kind);
     _visitor.visit_expr(&_i . value);
 }
 
-pub fn walk_expr_index<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprIndex) {
+pub fn visit_expr_index<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprIndex) {
     _visitor.visit_expr(&_i . expr);
     _visitor.visit_expr(&_i . index);
     // Skipped field _i . bracket_token;
 }
 
-pub fn walk_expr_kind<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprKind) {
+pub fn visit_expr_kind<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprKind) {
     use ::ExprKind::*;
     match *_i {
         Box(ref _binding_0, ) => {
@@ -906,21 +906,21 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_loop<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprLoop) {
+pub fn visit_expr_loop<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprLoop) {
     _visitor.visit_block(&_i . body);
     // Skipped field _i . label;
     // Skipped field _i . loop_token;
     // Skipped field _i . colon_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_match<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprMatch) {
+pub fn visit_expr_match<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprMatch) {
     // Skipped field _i . match_token;
     // Skipped field _i . brace_token;
     _visitor.visit_expr(&_i . expr);
     for it in (_i . arms).iter() { _visitor.visit_arm(&it) };
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_method_call<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprMethodCall) {
+pub fn visit_expr_method_call<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprMethodCall) {
     _visitor.visit_expr(&_i . expr);
     // Skipped field _i . method;
     for el in (_i . typarams).iter() { let it = el.item(); _visitor.visit_ty(&it) };
@@ -932,35 +932,35 @@
     // Skipped field _i . gt_token;
 }
 
-pub fn walk_expr_paren<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprParen) {
+pub fn visit_expr_paren<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprParen) {
     _visitor.visit_expr(&_i . expr);
     // Skipped field _i . paren_token;
 }
 
-pub fn walk_expr_path<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprPath) {
+pub fn visit_expr_path<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprPath) {
     if let Some(ref it) = _i . qself { _visitor.visit_qself(&* it) };
     _visitor.visit_path(&_i . path);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_range<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprRange) {
+pub fn visit_expr_range<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprRange) {
     if let Some(ref it) = _i . from { _visitor.visit_expr(&* it) };
     if let Some(ref it) = _i . to { _visitor.visit_expr(&* it) };
     _visitor.visit_range_limits(&_i . limits);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_repeat<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprRepeat) {
+pub fn visit_expr_repeat<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprRepeat) {
     // Skipped field _i . bracket_token;
     // Skipped field _i . semi_token;
     _visitor.visit_expr(&_i . expr);
     _visitor.visit_expr(&_i . amt);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_ret<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprRet) {
+pub fn visit_expr_ret<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprRet) {
     if let Some(ref it) = _i . expr { _visitor.visit_expr(&* it) };
     // Skipped field _i . return_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_struct<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprStruct) {
+pub fn visit_expr_struct<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprStruct) {
     _visitor.visit_path(&_i . path);
     for el in (_i . fields).iter() { let it = el.item(); _visitor.visit_field_value(&it) };
     if let Some(ref it) = _i . rest { _visitor.visit_expr(&* it) };
@@ -968,35 +968,35 @@
     // Skipped field _i . brace_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_try<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprTry) {
+pub fn visit_expr_try<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprTry) {
     _visitor.visit_expr(&_i . expr);
     // Skipped field _i . question_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_tup<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprTup) {
+pub fn visit_expr_tup<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprTup) {
     for el in (_i . args).iter() { let it = el.item(); _visitor.visit_expr(&it) };
     // Skipped field _i . paren_token;
     // Skipped field _i . lone_comma;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_tup_field<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprTupField) {
+pub fn visit_expr_tup_field<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprTupField) {
     _visitor.visit_expr(&_i . expr);
     // Skipped field _i . field;
     // Skipped field _i . dot_token;
 }
 
-pub fn walk_expr_type<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprType) {
+pub fn visit_expr_type<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprType) {
     _visitor.visit_expr(&_i . expr);
     // Skipped field _i . colon_token;
     _visitor.visit_ty(&_i . ty);
 }
 
-pub fn walk_expr_unary<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprUnary) {
+pub fn visit_expr_unary<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprUnary) {
     _visitor.visit_un_op(&_i . op);
     _visitor.visit_expr(&_i . expr);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_while<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprWhile) {
+pub fn visit_expr_while<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprWhile) {
     _visitor.visit_expr(&_i . cond);
     _visitor.visit_block(&_i . body);
     // Skipped field _i . label;
@@ -1004,7 +1004,7 @@
     // Skipped field _i . while_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_while_let<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprWhileLet) {
+pub fn visit_expr_while_let<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprWhileLet) {
     _visitor.visit_pat(&_i . pat);
     _visitor.visit_expr(&_i . expr);
     _visitor.visit_block(&_i . body);
@@ -1015,12 +1015,12 @@
     // Skipped field _i . eq_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_yield<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprYield) {
+pub fn visit_expr_yield<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ExprYield) {
     // Skipped field _i . yield_token;
     if let Some(ref it) = _i . expr { _visitor.visit_expr(&* it) };
 }
 
-pub fn walk_field<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Field) {
+pub fn visit_field<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Field) {
     // Skipped field _i . ident;
     _visitor.visit_visibility(&_i . vis);
     for it in (_i . attrs).iter() { _visitor.visit_attribute(&it) };
@@ -1028,7 +1028,7 @@
     // Skipped field _i . colon_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_field_pat<V: Visitor + ?Sized>(_visitor: &mut V, _i: &FieldPat) {
+pub fn visit_field_pat<V: Visitor + ?Sized>(_visitor: &mut V, _i: &FieldPat) {
     // Skipped field _i . ident;
     _visitor.visit_pat(&_i . pat);
     // Skipped field _i . is_shorthand;
@@ -1036,7 +1036,7 @@
     for it in (_i . attrs).iter() { _visitor.visit_attribute(&it) };
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_field_value<V: Visitor + ?Sized>(_visitor: &mut V, _i: &FieldValue) {
+pub fn visit_field_value<V: Visitor + ?Sized>(_visitor: &mut V, _i: &FieldValue) {
     // Skipped field _i . ident;
     _visitor.visit_expr(&_i . expr);
     // Skipped field _i . is_shorthand;
@@ -1044,13 +1044,13 @@
     // Skipped field _i . colon_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_file<V: Visitor + ?Sized>(_visitor: &mut V, _i: &File) {
+pub fn visit_file<V: Visitor + ?Sized>(_visitor: &mut V, _i: &File) {
     // Skipped field _i . shebang;
     for it in (_i . attrs).iter() { _visitor.visit_attribute(&it) };
     for it in (_i . items).iter() { _visitor.visit_item(&it) };
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_fn_arg<V: Visitor + ?Sized>(_visitor: &mut V, _i: &FnArg) {
+pub fn visit_fn_arg<V: Visitor + ?Sized>(_visitor: &mut V, _i: &FnArg) {
     use ::FnArg::*;
     match *_i {
         SelfRef(ref _binding_0, ) => {
@@ -1068,7 +1068,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_fn_decl<V: Visitor + ?Sized>(_visitor: &mut V, _i: &FnDecl) {
+pub fn visit_fn_decl<V: Visitor + ?Sized>(_visitor: &mut V, _i: &FnDecl) {
     // Skipped field _i . fn_token;
     // Skipped field _i . paren_token;
     for el in (_i . inputs).iter() { let it = el.item(); _visitor.visit_fn_arg(&it) };
@@ -1078,7 +1078,7 @@
     // Skipped field _i . dot_tokens;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_foreign_item<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ForeignItem) {
+pub fn visit_foreign_item<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ForeignItem) {
     // Skipped field _i . ident;
     for it in (_i . attrs).iter() { _visitor.visit_attribute(&it) };
     _visitor.visit_foreign_item_kind(&_i . node);
@@ -1086,11 +1086,11 @@
     // Skipped field _i . semi_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_foreign_item_fn<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ForeignItemFn) {
+pub fn visit_foreign_item_fn<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ForeignItemFn) {
     _visitor.visit_fn_decl(&_i . decl);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_foreign_item_kind<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ForeignItemKind) {
+pub fn visit_foreign_item_kind<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ForeignItemKind) {
     use ::ForeignItemKind::*;
     match *_i {
         Fn(ref _binding_0, ) => {
@@ -1102,14 +1102,14 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_foreign_item_static<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ForeignItemStatic) {
+pub fn visit_foreign_item_static<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ForeignItemStatic) {
     // Skipped field _i . static_token;
     _visitor.visit_ty(&_i . ty);
     // Skipped field _i . colon_token;
     _visitor.visit_mutability(&_i . mutbl);
 }
 
-pub fn walk_function_ret_ty<V: Visitor + ?Sized>(_visitor: &mut V, _i: &FunctionRetTy) {
+pub fn visit_function_ret_ty<V: Visitor + ?Sized>(_visitor: &mut V, _i: &FunctionRetTy) {
     use ::FunctionRetTy::*;
     match *_i {
         Default => { }
@@ -1120,7 +1120,7 @@
     }
 }
 
-pub fn walk_generics<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Generics) {
+pub fn visit_generics<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Generics) {
     // Skipped field _i . lt_token;
     // Skipped field _i . gt_token;
     for el in (_i . lifetimes).iter() { let it = el.item(); _visitor.visit_lifetime_def(&it) };
@@ -1128,12 +1128,12 @@
     _visitor.visit_where_clause(&_i . where_clause);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_impl_item<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ImplItem) {
+pub fn visit_impl_item<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ImplItem) {
     for it in (_i . attrs).iter() { _visitor.visit_attribute(&it) };
     _visitor.visit_impl_item_kind(&_i . node);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_impl_item_const<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ImplItemConst) {
+pub fn visit_impl_item_const<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ImplItemConst) {
     _visitor.visit_visibility(&_i . vis);
     _visitor.visit_defaultness(&_i . defaultness);
     // Skipped field _i . const_token;
@@ -1145,7 +1145,7 @@
     // Skipped field _i . semi_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_impl_item_kind<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ImplItemKind) {
+pub fn visit_impl_item_kind<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ImplItemKind) {
     use ::ImplItemKind::*;
     match *_i {
         Const(ref _binding_0, ) => {
@@ -1163,14 +1163,14 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_impl_item_method<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ImplItemMethod) {
+pub fn visit_impl_item_method<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ImplItemMethod) {
     _visitor.visit_visibility(&_i . vis);
     _visitor.visit_defaultness(&_i . defaultness);
     _visitor.visit_method_sig(&_i . sig);
     _visitor.visit_block(&_i . block);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_impl_item_type<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ImplItemType) {
+pub fn visit_impl_item_type<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ImplItemType) {
     _visitor.visit_visibility(&_i . vis);
     _visitor.visit_defaultness(&_i . defaultness);
     // Skipped field _i . type_token;
@@ -1180,7 +1180,7 @@
     // Skipped field _i . semi_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_impl_polarity<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ImplPolarity) {
+pub fn visit_impl_polarity<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ImplPolarity) {
     use ::ImplPolarity::*;
     match *_i {
         Positive => { }
@@ -1190,7 +1190,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_in_place_kind<V: Visitor + ?Sized>(_visitor: &mut V, _i: &InPlaceKind) {
+pub fn visit_in_place_kind<V: Visitor + ?Sized>(_visitor: &mut V, _i: &InPlaceKind) {
     use ::InPlaceKind::*;
     match *_i {
         Arrow(ref _binding_0, ) => {
@@ -1202,12 +1202,12 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Item) {
+pub fn visit_item<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Item) {
     for it in (_i . attrs).iter() { _visitor.visit_attribute(&it) };
     _visitor.visit_item_kind(&_i . node);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_const<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ItemConst) {
+pub fn visit_item_const<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ItemConst) {
     _visitor.visit_visibility(&_i . vis);
     // Skipped field _i . const_token;
     // Skipped field _i . ident;
@@ -1218,7 +1218,7 @@
     // Skipped field _i . semi_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_default_impl<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ItemDefaultImpl) {
+pub fn visit_item_default_impl<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ItemDefaultImpl) {
     _visitor.visit_unsafety(&_i . unsafety);
     // Skipped field _i . impl_token;
     _visitor.visit_path(&_i . path);
@@ -1227,7 +1227,7 @@
     // Skipped field _i . brace_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_enum<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ItemEnum) {
+pub fn visit_item_enum<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ItemEnum) {
     _visitor.visit_visibility(&_i . vis);
     // Skipped field _i . enum_token;
     // Skipped field _i . ident;
@@ -1236,7 +1236,7 @@
     for el in (_i . variants).iter() { let it = el.item(); _visitor.visit_variant(&it) };
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_extern_crate<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ItemExternCrate) {
+pub fn visit_item_extern_crate<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ItemExternCrate) {
     _visitor.visit_visibility(&_i . vis);
     // Skipped field _i . extern_token;
     // Skipped field _i . crate_token;
@@ -1245,7 +1245,7 @@
     // Skipped field _i . semi_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_fn<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ItemFn) {
+pub fn visit_item_fn<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ItemFn) {
     _visitor.visit_visibility(&_i . vis);
     _visitor.visit_constness(&_i . constness);
     _visitor.visit_unsafety(&_i . unsafety);
@@ -1255,13 +1255,13 @@
     _visitor.visit_block(&_i . block);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_foreign_mod<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ItemForeignMod) {
+pub fn visit_item_foreign_mod<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ItemForeignMod) {
     _visitor.visit_abi(&_i . abi);
     // Skipped field _i . brace_token;
     for it in (_i . items).iter() { _visitor.visit_foreign_item(&it) };
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_impl<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ItemImpl) {
+pub fn visit_item_impl<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ItemImpl) {
     _visitor.visit_defaultness(&_i . defaultness);
     _visitor.visit_unsafety(&_i . unsafety);
     // Skipped field _i . impl_token;
@@ -1272,7 +1272,7 @@
     for it in (_i . items).iter() { _visitor.visit_impl_item(&it) };
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_kind<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ItemKind) {
+pub fn visit_item_kind<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ItemKind) {
     use ::ItemKind::*;
     match *_i {
         ExternCrate(ref _binding_0, ) => {
@@ -1323,7 +1323,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_mod<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ItemMod) {
+pub fn visit_item_mod<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ItemMod) {
     _visitor.visit_visibility(&_i . vis);
     // Skipped field _i . mod_token;
     // Skipped field _i . ident;
@@ -1331,7 +1331,7 @@
     // Skipped field _i . semi;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_static<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ItemStatic) {
+pub fn visit_item_static<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ItemStatic) {
     _visitor.visit_visibility(&_i . vis);
     // Skipped field _i . static_token;
     _visitor.visit_mutability(&_i . mutbl);
@@ -1343,7 +1343,7 @@
     // Skipped field _i . semi_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_struct<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ItemStruct) {
+pub fn visit_item_struct<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ItemStruct) {
     _visitor.visit_visibility(&_i . vis);
     // Skipped field _i . struct_token;
     // Skipped field _i . ident;
@@ -1352,7 +1352,7 @@
     // Skipped field _i . semi_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_trait<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ItemTrait) {
+pub fn visit_item_trait<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ItemTrait) {
     _visitor.visit_visibility(&_i . vis);
     _visitor.visit_unsafety(&_i . unsafety);
     // Skipped field _i . trait_token;
@@ -1364,7 +1364,7 @@
     for it in (_i . items).iter() { _visitor.visit_trait_item(&it) };
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_ty<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ItemTy) {
+pub fn visit_item_ty<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ItemTy) {
     _visitor.visit_visibility(&_i . vis);
     // Skipped field _i . type_token;
     // Skipped field _i . ident;
@@ -1374,7 +1374,7 @@
     // Skipped field _i . semi_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_union<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ItemUnion) {
+pub fn visit_item_union<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ItemUnion) {
     _visitor.visit_visibility(&_i . vis);
     // Skipped field _i . union_token;
     // Skipped field _i . ident;
@@ -1382,21 +1382,21 @@
     _visitor.visit_variant_data(&_i . data);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_use<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ItemUse) {
+pub fn visit_item_use<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ItemUse) {
     _visitor.visit_visibility(&_i . vis);
     // Skipped field _i . use_token;
     _visitor.visit_view_path(&_i . path);
     // Skipped field _i . semi_token;
 }
 
-pub fn walk_lifetime_def<V: Visitor + ?Sized>(_visitor: &mut V, _i: &LifetimeDef) {
+pub fn visit_lifetime_def<V: Visitor + ?Sized>(_visitor: &mut V, _i: &LifetimeDef) {
     for it in (_i . attrs).iter() { _visitor.visit_attribute(&it) };
     // Skipped field _i . lifetime;
     // Skipped field _i . colon_token;
     // Skipped field _i . bounds;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_local<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Local) {
+pub fn visit_local<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Local) {
     // Skipped field _i . let_token;
     // Skipped field _i . colon_token;
     // Skipped field _i . eq_token;
@@ -1407,14 +1407,14 @@
     for it in (_i . attrs).iter() { _visitor.visit_attribute(&it) };
 }
 
-pub fn walk_mac<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Mac) {
+pub fn visit_mac<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Mac) {
     _visitor.visit_path(&_i . path);
     // Skipped field _i . bang_token;
     // Skipped field _i . ident;
     // Skipped field _i . tokens;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_mac_stmt_style<V: Visitor + ?Sized>(_visitor: &mut V, _i: &MacStmtStyle) {
+pub fn visit_mac_stmt_style<V: Visitor + ?Sized>(_visitor: &mut V, _i: &MacStmtStyle) {
     use ::MacStmtStyle::*;
     match *_i {
         Semicolon(ref _binding_0, ) => {
@@ -1425,7 +1425,7 @@
     }
 }
 
-pub fn walk_meta_item<V: Visitor + ?Sized>(_visitor: &mut V, _i: &MetaItem) {
+pub fn visit_meta_item<V: Visitor + ?Sized>(_visitor: &mut V, _i: &MetaItem) {
     use ::MetaItem::*;
     match *_i {
         Term(ref _binding_0, ) => {
@@ -1440,19 +1440,19 @@
     }
 }
 
-pub fn walk_meta_item_list<V: Visitor + ?Sized>(_visitor: &mut V, _i: &MetaItemList) {
+pub fn visit_meta_item_list<V: Visitor + ?Sized>(_visitor: &mut V, _i: &MetaItemList) {
     // Skipped field _i . ident;
     // Skipped field _i . paren_token;
     for el in (_i . nested).iter() { let it = el.item(); _visitor.visit_nested_meta_item(&it) };
 }
 
-pub fn walk_meta_name_value<V: Visitor + ?Sized>(_visitor: &mut V, _i: &MetaNameValue) {
+pub fn visit_meta_name_value<V: Visitor + ?Sized>(_visitor: &mut V, _i: &MetaNameValue) {
     // Skipped field _i . ident;
     // Skipped field _i . eq_token;
     // Skipped field _i . lit;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_method_sig<V: Visitor + ?Sized>(_visitor: &mut V, _i: &MethodSig) {
+pub fn visit_method_sig<V: Visitor + ?Sized>(_visitor: &mut V, _i: &MethodSig) {
     _visitor.visit_constness(&_i . constness);
     _visitor.visit_unsafety(&_i . unsafety);
     if let Some(ref it) = _i . abi { _visitor.visit_abi(&* it) };
@@ -1460,12 +1460,12 @@
     _visitor.visit_fn_decl(&_i . decl);
 }
 
-pub fn walk_mut_ty<V: Visitor + ?Sized>(_visitor: &mut V, _i: &MutTy) {
+pub fn visit_mut_ty<V: Visitor + ?Sized>(_visitor: &mut V, _i: &MutTy) {
     _visitor.visit_ty(&_i . ty);
     _visitor.visit_mutability(&_i . mutability);
 }
 
-pub fn walk_mutability<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Mutability) {
+pub fn visit_mutability<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Mutability) {
     use ::Mutability::*;
     match *_i {
         Mutable(ref _binding_0, ) => {
@@ -1475,7 +1475,7 @@
     }
 }
 
-pub fn walk_nested_meta_item<V: Visitor + ?Sized>(_visitor: &mut V, _i: &NestedMetaItem) {
+pub fn visit_nested_meta_item<V: Visitor + ?Sized>(_visitor: &mut V, _i: &NestedMetaItem) {
     use ::NestedMetaItem::*;
     match *_i {
         MetaItem(ref _binding_0, ) => {
@@ -1487,13 +1487,13 @@
     }
 }
 
-pub fn walk_parenthesized_parameter_data<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ParenthesizedParameterData) {
+pub fn visit_parenthesized_parameter_data<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ParenthesizedParameterData) {
     // Skipped field _i . paren_token;
     for el in (_i . inputs).iter() { let it = el.item(); _visitor.visit_ty(&it) };
     _visitor.visit_function_ret_ty(&_i . output);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Pat) {
+pub fn visit_pat<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Pat) {
     use ::Pat::*;
     match *_i {
         Wild(ref _binding_0, ) => {
@@ -1535,40 +1535,40 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat_box<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PatBox) {
+pub fn visit_pat_box<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PatBox) {
     _visitor.visit_pat(&_i . pat);
     // Skipped field _i . box_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat_ident<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PatIdent) {
+pub fn visit_pat_ident<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PatIdent) {
     _visitor.visit_binding_mode(&_i . mode);
     // Skipped field _i . ident;
     if let Some(ref it) = _i . subpat { _visitor.visit_pat(&* it) };
     // Skipped field _i . at_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat_lit<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PatLit) {
+pub fn visit_pat_lit<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PatLit) {
     _visitor.visit_expr(&_i . expr);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat_path<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PatPath) {
+pub fn visit_pat_path<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PatPath) {
     if let Some(ref it) = _i . qself { _visitor.visit_qself(&* it) };
     _visitor.visit_path(&_i . path);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat_range<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PatRange) {
+pub fn visit_pat_range<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PatRange) {
     _visitor.visit_expr(&_i . lo);
     _visitor.visit_expr(&_i . hi);
     _visitor.visit_range_limits(&_i . limits);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat_ref<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PatRef) {
+pub fn visit_pat_ref<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PatRef) {
     _visitor.visit_pat(&_i . pat);
     _visitor.visit_mutability(&_i . mutbl);
     // Skipped field _i . and_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat_slice<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PatSlice) {
+pub fn visit_pat_slice<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PatSlice) {
     for el in (_i . front).iter() { let it = el.item(); _visitor.visit_pat(&it) };
     if let Some(ref it) = _i . middle { _visitor.visit_pat(&* it) };
     for el in (_i . back).iter() { let it = el.item(); _visitor.visit_pat(&it) };
@@ -1577,14 +1577,14 @@
     // Skipped field _i . bracket_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat_struct<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PatStruct) {
+pub fn visit_pat_struct<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PatStruct) {
     _visitor.visit_path(&_i . path);
     for el in (_i . fields).iter() { let it = el.item(); _visitor.visit_field_pat(&it) };
     // Skipped field _i . brace_token;
     // Skipped field _i . dot2_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat_tuple<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PatTuple) {
+pub fn visit_pat_tuple<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PatTuple) {
     for el in (_i . pats).iter() { let it = el.item(); _visitor.visit_pat(&it) };
     // Skipped field _i . dots_pos;
     // Skipped field _i . paren_token;
@@ -1592,40 +1592,40 @@
     // Skipped field _i . comma_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat_tuple_struct<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PatTupleStruct) {
+pub fn visit_pat_tuple_struct<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PatTupleStruct) {
     _visitor.visit_path(&_i . path);
     _visitor.visit_pat_tuple(&_i . pat);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat_wild<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PatWild) {
+pub fn visit_pat_wild<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PatWild) {
     // Skipped field _i . underscore_token;
 }
 
-pub fn walk_path<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Path) {
+pub fn visit_path<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Path) {
     // Skipped field _i . leading_colon;
     for el in (_i . segments).iter() { let it = el.item(); _visitor.visit_path_segment(&it) };
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_path_glob<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PathGlob) {
+pub fn visit_path_glob<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PathGlob) {
     _visitor.visit_path(&_i . path);
     // Skipped field _i . colon2_token;
     // Skipped field _i . star_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_path_list<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PathList) {
+pub fn visit_path_list<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PathList) {
     _visitor.visit_path(&_i . path);
     // Skipped field _i . colon2_token;
     // Skipped field _i . brace_token;
     for el in (_i . items).iter() { let it = el.item(); _visitor.visit_path_list_item(&it) };
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_path_list_item<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PathListItem) {
+pub fn visit_path_list_item<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PathListItem) {
     // Skipped field _i . name;
     // Skipped field _i . rename;
     // Skipped field _i . as_token;
 }
 
-pub fn walk_path_parameters<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PathParameters) {
+pub fn visit_path_parameters<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PathParameters) {
     use ::PathParameters::*;
     match *_i {
         None => { }
@@ -1638,23 +1638,23 @@
     }
 }
 
-pub fn walk_path_segment<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PathSegment) {
+pub fn visit_path_segment<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PathSegment) {
     // Skipped field _i . ident;
     _visitor.visit_path_parameters(&_i . parameters);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_path_simple<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PathSimple) {
+pub fn visit_path_simple<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PathSimple) {
     _visitor.visit_path(&_i . path);
     // Skipped field _i . as_token;
     // Skipped field _i . rename;
 }
 
-pub fn walk_poly_trait_ref<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PolyTraitRef) {
+pub fn visit_poly_trait_ref<V: Visitor + ?Sized>(_visitor: &mut V, _i: &PolyTraitRef) {
     if let Some(ref it) = _i . bound_lifetimes { _visitor.visit_bound_lifetimes(&* it) };
     _visitor.visit_path(&_i . trait_ref);
 }
 
-pub fn walk_qself<V: Visitor + ?Sized>(_visitor: &mut V, _i: &QSelf) {
+pub fn visit_qself<V: Visitor + ?Sized>(_visitor: &mut V, _i: &QSelf) {
     // Skipped field _i . lt_token;
     _visitor.visit_ty(&_i . ty);
     // Skipped field _i . position;
@@ -1662,7 +1662,7 @@
     // Skipped field _i . gt_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_range_limits<V: Visitor + ?Sized>(_visitor: &mut V, _i: &RangeLimits) {
+pub fn visit_range_limits<V: Visitor + ?Sized>(_visitor: &mut V, _i: &RangeLimits) {
     use ::RangeLimits::*;
     match *_i {
         HalfOpen(ref _binding_0, ) => {
@@ -1674,7 +1674,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_stmt<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Stmt) {
+pub fn visit_stmt<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Stmt) {
     use ::Stmt::*;
     match *_i {
         Local(ref _binding_0, ) => {
@@ -1696,7 +1696,7 @@
     }
 }
 
-pub fn walk_trait_bound_modifier<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TraitBoundModifier) {
+pub fn visit_trait_bound_modifier<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TraitBoundModifier) {
     use ::TraitBoundModifier::*;
     match *_i {
         None => { }
@@ -1706,12 +1706,12 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_trait_item<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TraitItem) {
+pub fn visit_trait_item<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TraitItem) {
     for it in (_i . attrs).iter() { _visitor.visit_attribute(&it) };
     _visitor.visit_trait_item_kind(&_i . node);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_trait_item_const<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TraitItemConst) {
+pub fn visit_trait_item_const<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TraitItemConst) {
     // Skipped field _i . const_token;
     // Skipped field _i . ident;
     // Skipped field _i . colon_token;
@@ -1720,7 +1720,7 @@
     // Skipped field _i . semi_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_trait_item_kind<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TraitItemKind) {
+pub fn visit_trait_item_kind<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TraitItemKind) {
     use ::TraitItemKind::*;
     match *_i {
         Const(ref _binding_0, ) => {
@@ -1738,13 +1738,13 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_trait_item_method<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TraitItemMethod) {
+pub fn visit_trait_item_method<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TraitItemMethod) {
     _visitor.visit_method_sig(&_i . sig);
     if let Some(ref it) = _i . default { _visitor.visit_block(&* it) };
     // Skipped field _i . semi_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_trait_item_type<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TraitItemType) {
+pub fn visit_trait_item_type<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TraitItemType) {
     // Skipped field _i . type_token;
     // Skipped field _i . ident;
     // Skipped field _i . colon_token;
@@ -1753,7 +1753,7 @@
     // Skipped field _i . semi_token;
 }
 
-pub fn walk_ty<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Ty) {
+pub fn visit_ty<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Ty) {
     use ::Ty::*;
     match *_i {
         Slice(ref _binding_0, ) => {
@@ -1801,36 +1801,36 @@
     }
 }
 
-pub fn walk_ty_array<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TyArray) {
+pub fn visit_ty_array<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TyArray) {
     // Skipped field _i . bracket_token;
     _visitor.visit_ty(&_i . ty);
     // Skipped field _i . semi_token;
     _visitor.visit_expr(&_i . amt);
 }
 
-pub fn walk_ty_bare_fn<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TyBareFn) {
+pub fn visit_ty_bare_fn<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TyBareFn) {
     _visitor.visit_bare_fn_ty(&_i . ty);
 }
 
-pub fn walk_ty_group<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TyGroup) {
+pub fn visit_ty_group<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TyGroup) {
     // Skipped field _i . group_token;
     _visitor.visit_ty(&_i . ty);
 }
 
-pub fn walk_ty_impl_trait<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TyImplTrait) {
+pub fn visit_ty_impl_trait<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TyImplTrait) {
     // Skipped field _i . impl_token;
     for el in (_i . bounds).iter() { let it = el.item(); _visitor.visit_ty_param_bound(&it) };
 }
 
-pub fn walk_ty_infer<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TyInfer) {
+pub fn visit_ty_infer<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TyInfer) {
     // Skipped field _i . underscore_token;
 }
 
-pub fn walk_ty_never<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TyNever) {
+pub fn visit_ty_never<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TyNever) {
     // Skipped field _i . bang_token;
 }
 
-pub fn walk_ty_param<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TyParam) {
+pub fn visit_ty_param<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TyParam) {
     for it in (_i . attrs).iter() { _visitor.visit_attribute(&it) };
     // Skipped field _i . ident;
     // Skipped field _i . colon_token;
@@ -1839,7 +1839,7 @@
     if let Some(ref it) = _i . default { _visitor.visit_ty(&* it) };
 }
 
-pub fn walk_ty_param_bound<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TyParamBound) {
+pub fn visit_ty_param_bound<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TyParamBound) {
     use ::TyParamBound::*;
     match *_i {
         Trait(ref _binding_0, ref _binding_1, ) => {
@@ -1852,50 +1852,50 @@
     }
 }
 
-pub fn walk_ty_paren<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TyParen) {
+pub fn visit_ty_paren<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TyParen) {
     // Skipped field _i . paren_token;
     _visitor.visit_ty(&_i . ty);
 }
 
-pub fn walk_ty_path<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TyPath) {
+pub fn visit_ty_path<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TyPath) {
     if let Some(ref it) = _i . qself { _visitor.visit_qself(&* it) };
     _visitor.visit_path(&_i . path);
 }
 
-pub fn walk_ty_ptr<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TyPtr) {
+pub fn visit_ty_ptr<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TyPtr) {
     // Skipped field _i . star_token;
     // Skipped field _i . const_token;
     _visitor.visit_mut_ty(&_i . ty);
 }
 
-pub fn walk_ty_rptr<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TyRptr) {
+pub fn visit_ty_rptr<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TyRptr) {
     // Skipped field _i . and_token;
     // Skipped field _i . lifetime;
     _visitor.visit_mut_ty(&_i . ty);
 }
 
-pub fn walk_ty_slice<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TySlice) {
+pub fn visit_ty_slice<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TySlice) {
     _visitor.visit_ty(&_i . ty);
     // Skipped field _i . bracket_token;
 }
 
-pub fn walk_ty_trait_object<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TyTraitObject) {
+pub fn visit_ty_trait_object<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TyTraitObject) {
     for el in (_i . bounds).iter() { let it = el.item(); _visitor.visit_ty_param_bound(&it) };
 }
 
-pub fn walk_ty_tup<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TyTup) {
+pub fn visit_ty_tup<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TyTup) {
     // Skipped field _i . paren_token;
     for el in (_i . tys).iter() { let it = el.item(); _visitor.visit_ty(&it) };
     // Skipped field _i . lone_comma;
 }
 
-pub fn walk_type_binding<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TypeBinding) {
+pub fn visit_type_binding<V: Visitor + ?Sized>(_visitor: &mut V, _i: &TypeBinding) {
     // Skipped field _i . ident;
     // Skipped field _i . eq_token;
     _visitor.visit_ty(&_i . ty);
 }
 
-pub fn walk_un_op<V: Visitor + ?Sized>(_visitor: &mut V, _i: &UnOp) {
+pub fn visit_un_op<V: Visitor + ?Sized>(_visitor: &mut V, _i: &UnOp) {
     use ::UnOp::*;
     match *_i {
         Deref(ref _binding_0, ) => {
@@ -1910,7 +1910,7 @@
     }
 }
 
-pub fn walk_unsafety<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Unsafety) {
+pub fn visit_unsafety<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Unsafety) {
     use ::Unsafety::*;
     match *_i {
         Unsafe(ref _binding_0, ) => {
@@ -1920,7 +1920,7 @@
     }
 }
 
-pub fn walk_variant<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Variant) {
+pub fn visit_variant<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Variant) {
     // Skipped field _i . ident;
     for it in (_i . attrs).iter() { _visitor.visit_attribute(&it) };
     _visitor.visit_variant_data(&_i . data);
@@ -1928,7 +1928,7 @@
     // Skipped field _i . eq_token;
 }
 
-pub fn walk_variant_data<V: Visitor + ?Sized>(_visitor: &mut V, _i: &VariantData) {
+pub fn visit_variant_data<V: Visitor + ?Sized>(_visitor: &mut V, _i: &VariantData) {
     use ::VariantData::*;
     match *_i {
         Struct(ref _binding_0, ref _binding_1, ) => {
@@ -1943,7 +1943,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_view_path<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ViewPath) {
+pub fn visit_view_path<V: Visitor + ?Sized>(_visitor: &mut V, _i: &ViewPath) {
     use ::ViewPath::*;
     match *_i {
         Simple(ref _binding_0, ) => {
@@ -1958,27 +1958,27 @@
     }
 }
 
-pub fn walk_vis_crate<V: Visitor + ?Sized>(_visitor: &mut V, _i: &VisCrate) {
+pub fn visit_vis_crate<V: Visitor + ?Sized>(_visitor: &mut V, _i: &VisCrate) {
     // Skipped field _i . pub_token;
     // Skipped field _i . paren_token;
     // Skipped field _i . crate_token;
 }
 
-pub fn walk_vis_inherited<V: Visitor + ?Sized>(_visitor: &mut V, _i: &VisInherited) {
+pub fn visit_vis_inherited<V: Visitor + ?Sized>(_visitor: &mut V, _i: &VisInherited) {
 }
 
-pub fn walk_vis_public<V: Visitor + ?Sized>(_visitor: &mut V, _i: &VisPublic) {
+pub fn visit_vis_public<V: Visitor + ?Sized>(_visitor: &mut V, _i: &VisPublic) {
     // Skipped field _i . pub_token;
 }
 
-pub fn walk_vis_restricted<V: Visitor + ?Sized>(_visitor: &mut V, _i: &VisRestricted) {
+pub fn visit_vis_restricted<V: Visitor + ?Sized>(_visitor: &mut V, _i: &VisRestricted) {
     // Skipped field _i . pub_token;
     // Skipped field _i . paren_token;
     // Skipped field _i . in_token;
     _visitor.visit_path(&_i . path);
 }
 
-pub fn walk_visibility<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Visibility) {
+pub fn visit_visibility<V: Visitor + ?Sized>(_visitor: &mut V, _i: &Visibility) {
     use ::Visibility::*;
     match *_i {
         Public(ref _binding_0, ) => {
@@ -1996,25 +1996,25 @@
     }
 }
 
-pub fn walk_where_bound_predicate<V: Visitor + ?Sized>(_visitor: &mut V, _i: &WhereBoundPredicate) {
+pub fn visit_where_bound_predicate<V: Visitor + ?Sized>(_visitor: &mut V, _i: &WhereBoundPredicate) {
     if let Some(ref it) = _i . bound_lifetimes { _visitor.visit_bound_lifetimes(&* it) };
     _visitor.visit_ty(&_i . bounded_ty);
     // Skipped field _i . colon_token;
     for el in (_i . bounds).iter() { let it = el.item(); _visitor.visit_ty_param_bound(&it) };
 }
 
-pub fn walk_where_clause<V: Visitor + ?Sized>(_visitor: &mut V, _i: &WhereClause) {
+pub fn visit_where_clause<V: Visitor + ?Sized>(_visitor: &mut V, _i: &WhereClause) {
     // Skipped field _i . where_token;
     for el in (_i . predicates).iter() { let it = el.item(); _visitor.visit_where_predicate(&it) };
 }
 
-pub fn walk_where_eq_predicate<V: Visitor + ?Sized>(_visitor: &mut V, _i: &WhereEqPredicate) {
+pub fn visit_where_eq_predicate<V: Visitor + ?Sized>(_visitor: &mut V, _i: &WhereEqPredicate) {
     _visitor.visit_ty(&_i . lhs_ty);
     // Skipped field _i . eq_token;
     _visitor.visit_ty(&_i . rhs_ty);
 }
 
-pub fn walk_where_predicate<V: Visitor + ?Sized>(_visitor: &mut V, _i: &WherePredicate) {
+pub fn visit_where_predicate<V: Visitor + ?Sized>(_visitor: &mut V, _i: &WherePredicate) {
     use ::WherePredicate::*;
     match *_i {
         BoundPredicate(ref _binding_0, ) => {
@@ -2029,7 +2029,7 @@
     }
 }
 
-pub fn walk_where_region_predicate<V: Visitor + ?Sized>(_visitor: &mut V, _i: &WhereRegionPredicate) {
+pub fn visit_where_region_predicate<V: Visitor + ?Sized>(_visitor: &mut V, _i: &WhereRegionPredicate) {
     // Skipped field _i . lifetime;
     // Skipped field _i . colon_token;
     // Skipped field _i . bounds;
diff --git a/src/gen/visit_mut.rs b/src/gen/visit_mut.rs
index a0d7e73..bc4d28e 100644
--- a/src/gen/visit_mut.rs
+++ b/src/gen/visit_mut.rs
@@ -6,7 +6,7 @@
 //! call `visit::walk_*` to apply the default traversal algorithm, or prevent
 //! deeper traversal by doing nothing.
 
-use super::*;
+use *;
 
 
 #[cfg(feature = "full")]
@@ -31,355 +31,355 @@
 /// new default implementation gets introduced.)
 pub trait VisitorMut {
 
-fn visit_abi(&mut self, i: &mut Abi) { walk_abi(self, i) }
+fn visit_abi_mut(&mut self, i: &mut Abi) { visit_abi_mut(self, i) }
 
-fn visit_abi_kind(&mut self, i: &mut AbiKind) { walk_abi_kind(self, i) }
+fn visit_abi_kind_mut(&mut self, i: &mut AbiKind) { visit_abi_kind_mut(self, i) }
 
-fn visit_angle_bracketed_parameter_data(&mut self, i: &mut AngleBracketedParameterData) { walk_angle_bracketed_parameter_data(self, i) }
+fn visit_angle_bracketed_parameter_data_mut(&mut self, i: &mut AngleBracketedParameterData) { visit_angle_bracketed_parameter_data_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_arg_captured(&mut self, i: &mut ArgCaptured) { walk_arg_captured(self, i) }
+fn visit_arg_captured_mut(&mut self, i: &mut ArgCaptured) { visit_arg_captured_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_arg_self(&mut self, i: &mut ArgSelf) { walk_arg_self(self, i) }
+fn visit_arg_self_mut(&mut self, i: &mut ArgSelf) { visit_arg_self_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_arg_self_ref(&mut self, i: &mut ArgSelfRef) { walk_arg_self_ref(self, i) }
+fn visit_arg_self_ref_mut(&mut self, i: &mut ArgSelfRef) { visit_arg_self_ref_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_arm(&mut self, i: &mut Arm) { walk_arm(self, i) }
+fn visit_arm_mut(&mut self, i: &mut Arm) { visit_arm_mut(self, i) }
 
-fn visit_attr_style(&mut self, i: &mut AttrStyle) { walk_attr_style(self, i) }
+fn visit_attr_style_mut(&mut self, i: &mut AttrStyle) { visit_attr_style_mut(self, i) }
 
-fn visit_attribute(&mut self, i: &mut Attribute) { walk_attribute(self, i) }
+fn visit_attribute_mut(&mut self, i: &mut Attribute) { visit_attribute_mut(self, i) }
 
-fn visit_bare_fn_arg(&mut self, i: &mut BareFnArg) { walk_bare_fn_arg(self, i) }
+fn visit_bare_fn_arg_mut(&mut self, i: &mut BareFnArg) { visit_bare_fn_arg_mut(self, i) }
 
-fn visit_bare_fn_arg_name(&mut self, i: &mut BareFnArgName) { walk_bare_fn_arg_name(self, i) }
+fn visit_bare_fn_arg_name_mut(&mut self, i: &mut BareFnArgName) { visit_bare_fn_arg_name_mut(self, i) }
 
-fn visit_bare_fn_ty(&mut self, i: &mut BareFnTy) { walk_bare_fn_ty(self, i) }
+fn visit_bare_fn_ty_mut(&mut self, i: &mut BareFnTy) { visit_bare_fn_ty_mut(self, i) }
 
-fn visit_bin_op(&mut self, i: &mut BinOp) { walk_bin_op(self, i) }
+fn visit_bin_op_mut(&mut self, i: &mut BinOp) { visit_bin_op_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_binding_mode(&mut self, i: &mut BindingMode) { walk_binding_mode(self, i) }
+fn visit_binding_mode_mut(&mut self, i: &mut BindingMode) { visit_binding_mode_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_block(&mut self, i: &mut Block) { walk_block(self, i) }
+fn visit_block_mut(&mut self, i: &mut Block) { visit_block_mut(self, i) }
 
-fn visit_body(&mut self, i: &mut Body) { walk_body(self, i) }
+fn visit_body_mut(&mut self, i: &mut Body) { visit_body_mut(self, i) }
 
-fn visit_body_enum(&mut self, i: &mut BodyEnum) { walk_body_enum(self, i) }
+fn visit_body_enum_mut(&mut self, i: &mut BodyEnum) { visit_body_enum_mut(self, i) }
 
-fn visit_body_struct(&mut self, i: &mut BodyStruct) { walk_body_struct(self, i) }
+fn visit_body_struct_mut(&mut self, i: &mut BodyStruct) { visit_body_struct_mut(self, i) }
 
-fn visit_bound_lifetimes(&mut self, i: &mut BoundLifetimes) { walk_bound_lifetimes(self, i) }
+fn visit_bound_lifetimes_mut(&mut self, i: &mut BoundLifetimes) { visit_bound_lifetimes_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_capture_by(&mut self, i: &mut CaptureBy) { walk_capture_by(self, i) }
+fn visit_capture_by_mut(&mut self, i: &mut CaptureBy) { visit_capture_by_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_constness(&mut self, i: &mut Constness) { walk_constness(self, i) }
+fn visit_constness_mut(&mut self, i: &mut Constness) { visit_constness_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_defaultness(&mut self, i: &mut Defaultness) { walk_defaultness(self, i) }
+fn visit_defaultness_mut(&mut self, i: &mut Defaultness) { visit_defaultness_mut(self, i) }
 
-fn visit_derive_input(&mut self, i: &mut DeriveInput) { walk_derive_input(self, i) }
+fn visit_derive_input_mut(&mut self, i: &mut DeriveInput) { visit_derive_input_mut(self, i) }
 
-fn visit_expr(&mut self, i: &mut Expr) { walk_expr(self, i) }
+fn visit_expr_mut(&mut self, i: &mut Expr) { visit_expr_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_addr_of(&mut self, i: &mut ExprAddrOf) { walk_expr_addr_of(self, i) }
+fn visit_expr_addr_of_mut(&mut self, i: &mut ExprAddrOf) { visit_expr_addr_of_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_array(&mut self, i: &mut ExprArray) { walk_expr_array(self, i) }
+fn visit_expr_array_mut(&mut self, i: &mut ExprArray) { visit_expr_array_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_assign(&mut self, i: &mut ExprAssign) { walk_expr_assign(self, i) }
+fn visit_expr_assign_mut(&mut self, i: &mut ExprAssign) { visit_expr_assign_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_assign_op(&mut self, i: &mut ExprAssignOp) { walk_expr_assign_op(self, i) }
+fn visit_expr_assign_op_mut(&mut self, i: &mut ExprAssignOp) { visit_expr_assign_op_mut(self, i) }
 
-fn visit_expr_binary(&mut self, i: &mut ExprBinary) { walk_expr_binary(self, i) }
+fn visit_expr_binary_mut(&mut self, i: &mut ExprBinary) { visit_expr_binary_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_block(&mut self, i: &mut ExprBlock) { walk_expr_block(self, i) }
+fn visit_expr_block_mut(&mut self, i: &mut ExprBlock) { visit_expr_block_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_box(&mut self, i: &mut ExprBox) { walk_expr_box(self, i) }
+fn visit_expr_box_mut(&mut self, i: &mut ExprBox) { visit_expr_box_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_break(&mut self, i: &mut ExprBreak) { walk_expr_break(self, i) }
+fn visit_expr_break_mut(&mut self, i: &mut ExprBreak) { visit_expr_break_mut(self, i) }
 
-fn visit_expr_call(&mut self, i: &mut ExprCall) { walk_expr_call(self, i) }
+fn visit_expr_call_mut(&mut self, i: &mut ExprCall) { visit_expr_call_mut(self, i) }
 
-fn visit_expr_cast(&mut self, i: &mut ExprCast) { walk_expr_cast(self, i) }
+fn visit_expr_cast_mut(&mut self, i: &mut ExprCast) { visit_expr_cast_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_catch(&mut self, i: &mut ExprCatch) { walk_expr_catch(self, i) }
+fn visit_expr_catch_mut(&mut self, i: &mut ExprCatch) { visit_expr_catch_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_closure(&mut self, i: &mut ExprClosure) { walk_expr_closure(self, i) }
+fn visit_expr_closure_mut(&mut self, i: &mut ExprClosure) { visit_expr_closure_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_continue(&mut self, i: &mut ExprContinue) { walk_expr_continue(self, i) }
+fn visit_expr_continue_mut(&mut self, i: &mut ExprContinue) { visit_expr_continue_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_field(&mut self, i: &mut ExprField) { walk_expr_field(self, i) }
+fn visit_expr_field_mut(&mut self, i: &mut ExprField) { visit_expr_field_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_for_loop(&mut self, i: &mut ExprForLoop) { walk_expr_for_loop(self, i) }
+fn visit_expr_for_loop_mut(&mut self, i: &mut ExprForLoop) { visit_expr_for_loop_mut(self, i) }
 
-fn visit_expr_group(&mut self, i: &mut ExprGroup) { walk_expr_group(self, i) }
+fn visit_expr_group_mut(&mut self, i: &mut ExprGroup) { visit_expr_group_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_if(&mut self, i: &mut ExprIf) { walk_expr_if(self, i) }
+fn visit_expr_if_mut(&mut self, i: &mut ExprIf) { visit_expr_if_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_if_let(&mut self, i: &mut ExprIfLet) { walk_expr_if_let(self, i) }
+fn visit_expr_if_let_mut(&mut self, i: &mut ExprIfLet) { visit_expr_if_let_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_in_place(&mut self, i: &mut ExprInPlace) { walk_expr_in_place(self, i) }
+fn visit_expr_in_place_mut(&mut self, i: &mut ExprInPlace) { visit_expr_in_place_mut(self, i) }
 
-fn visit_expr_index(&mut self, i: &mut ExprIndex) { walk_expr_index(self, i) }
+fn visit_expr_index_mut(&mut self, i: &mut ExprIndex) { visit_expr_index_mut(self, i) }
 
-fn visit_expr_kind(&mut self, i: &mut ExprKind) { walk_expr_kind(self, i) }
+fn visit_expr_kind_mut(&mut self, i: &mut ExprKind) { visit_expr_kind_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_loop(&mut self, i: &mut ExprLoop) { walk_expr_loop(self, i) }
+fn visit_expr_loop_mut(&mut self, i: &mut ExprLoop) { visit_expr_loop_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_match(&mut self, i: &mut ExprMatch) { walk_expr_match(self, i) }
+fn visit_expr_match_mut(&mut self, i: &mut ExprMatch) { visit_expr_match_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_method_call(&mut self, i: &mut ExprMethodCall) { walk_expr_method_call(self, i) }
+fn visit_expr_method_call_mut(&mut self, i: &mut ExprMethodCall) { visit_expr_method_call_mut(self, i) }
 
-fn visit_expr_paren(&mut self, i: &mut ExprParen) { walk_expr_paren(self, i) }
+fn visit_expr_paren_mut(&mut self, i: &mut ExprParen) { visit_expr_paren_mut(self, i) }
 
-fn visit_expr_path(&mut self, i: &mut ExprPath) { walk_expr_path(self, i) }
+fn visit_expr_path_mut(&mut self, i: &mut ExprPath) { visit_expr_path_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_range(&mut self, i: &mut ExprRange) { walk_expr_range(self, i) }
+fn visit_expr_range_mut(&mut self, i: &mut ExprRange) { visit_expr_range_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_repeat(&mut self, i: &mut ExprRepeat) { walk_expr_repeat(self, i) }
+fn visit_expr_repeat_mut(&mut self, i: &mut ExprRepeat) { visit_expr_repeat_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_ret(&mut self, i: &mut ExprRet) { walk_expr_ret(self, i) }
+fn visit_expr_ret_mut(&mut self, i: &mut ExprRet) { visit_expr_ret_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_struct(&mut self, i: &mut ExprStruct) { walk_expr_struct(self, i) }
+fn visit_expr_struct_mut(&mut self, i: &mut ExprStruct) { visit_expr_struct_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_try(&mut self, i: &mut ExprTry) { walk_expr_try(self, i) }
+fn visit_expr_try_mut(&mut self, i: &mut ExprTry) { visit_expr_try_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_tup(&mut self, i: &mut ExprTup) { walk_expr_tup(self, i) }
+fn visit_expr_tup_mut(&mut self, i: &mut ExprTup) { visit_expr_tup_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_tup_field(&mut self, i: &mut ExprTupField) { walk_expr_tup_field(self, i) }
+fn visit_expr_tup_field_mut(&mut self, i: &mut ExprTupField) { visit_expr_tup_field_mut(self, i) }
 
-fn visit_expr_type(&mut self, i: &mut ExprType) { walk_expr_type(self, i) }
+fn visit_expr_type_mut(&mut self, i: &mut ExprType) { visit_expr_type_mut(self, i) }
 
-fn visit_expr_unary(&mut self, i: &mut ExprUnary) { walk_expr_unary(self, i) }
+fn visit_expr_unary_mut(&mut self, i: &mut ExprUnary) { visit_expr_unary_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_while(&mut self, i: &mut ExprWhile) { walk_expr_while(self, i) }
+fn visit_expr_while_mut(&mut self, i: &mut ExprWhile) { visit_expr_while_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_while_let(&mut self, i: &mut ExprWhileLet) { walk_expr_while_let(self, i) }
+fn visit_expr_while_let_mut(&mut self, i: &mut ExprWhileLet) { visit_expr_while_let_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_expr_yield(&mut self, i: &mut ExprYield) { walk_expr_yield(self, i) }
+fn visit_expr_yield_mut(&mut self, i: &mut ExprYield) { visit_expr_yield_mut(self, i) }
 
-fn visit_field(&mut self, i: &mut Field) { walk_field(self, i) }
+fn visit_field_mut(&mut self, i: &mut Field) { visit_field_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_field_pat(&mut self, i: &mut FieldPat) { walk_field_pat(self, i) }
+fn visit_field_pat_mut(&mut self, i: &mut FieldPat) { visit_field_pat_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_field_value(&mut self, i: &mut FieldValue) { walk_field_value(self, i) }
+fn visit_field_value_mut(&mut self, i: &mut FieldValue) { visit_field_value_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_file(&mut self, i: &mut File) { walk_file(self, i) }
+fn visit_file_mut(&mut self, i: &mut File) { visit_file_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_fn_arg(&mut self, i: &mut FnArg) { walk_fn_arg(self, i) }
+fn visit_fn_arg_mut(&mut self, i: &mut FnArg) { visit_fn_arg_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_fn_decl(&mut self, i: &mut FnDecl) { walk_fn_decl(self, i) }
+fn visit_fn_decl_mut(&mut self, i: &mut FnDecl) { visit_fn_decl_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_foreign_item(&mut self, i: &mut ForeignItem) { walk_foreign_item(self, i) }
+fn visit_foreign_item_mut(&mut self, i: &mut ForeignItem) { visit_foreign_item_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_foreign_item_fn(&mut self, i: &mut ForeignItemFn) { walk_foreign_item_fn(self, i) }
+fn visit_foreign_item_fn_mut(&mut self, i: &mut ForeignItemFn) { visit_foreign_item_fn_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_foreign_item_kind(&mut self, i: &mut ForeignItemKind) { walk_foreign_item_kind(self, i) }
+fn visit_foreign_item_kind_mut(&mut self, i: &mut ForeignItemKind) { visit_foreign_item_kind_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_foreign_item_static(&mut self, i: &mut ForeignItemStatic) { walk_foreign_item_static(self, i) }
+fn visit_foreign_item_static_mut(&mut self, i: &mut ForeignItemStatic) { visit_foreign_item_static_mut(self, i) }
 
-fn visit_function_ret_ty(&mut self, i: &mut FunctionRetTy) { walk_function_ret_ty(self, i) }
+fn visit_function_ret_ty_mut(&mut self, i: &mut FunctionRetTy) { visit_function_ret_ty_mut(self, i) }
 
-fn visit_generics(&mut self, i: &mut Generics) { walk_generics(self, i) }
+fn visit_generics_mut(&mut self, i: &mut Generics) { visit_generics_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_impl_item(&mut self, i: &mut ImplItem) { walk_impl_item(self, i) }
+fn visit_impl_item_mut(&mut self, i: &mut ImplItem) { visit_impl_item_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_impl_item_const(&mut self, i: &mut ImplItemConst) { walk_impl_item_const(self, i) }
+fn visit_impl_item_const_mut(&mut self, i: &mut ImplItemConst) { visit_impl_item_const_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_impl_item_kind(&mut self, i: &mut ImplItemKind) { walk_impl_item_kind(self, i) }
+fn visit_impl_item_kind_mut(&mut self, i: &mut ImplItemKind) { visit_impl_item_kind_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_impl_item_method(&mut self, i: &mut ImplItemMethod) { walk_impl_item_method(self, i) }
+fn visit_impl_item_method_mut(&mut self, i: &mut ImplItemMethod) { visit_impl_item_method_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_impl_item_type(&mut self, i: &mut ImplItemType) { walk_impl_item_type(self, i) }
+fn visit_impl_item_type_mut(&mut self, i: &mut ImplItemType) { visit_impl_item_type_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_impl_polarity(&mut self, i: &mut ImplPolarity) { walk_impl_polarity(self, i) }
+fn visit_impl_polarity_mut(&mut self, i: &mut ImplPolarity) { visit_impl_polarity_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_in_place_kind(&mut self, i: &mut InPlaceKind) { walk_in_place_kind(self, i) }
+fn visit_in_place_kind_mut(&mut self, i: &mut InPlaceKind) { visit_in_place_kind_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_item(&mut self, i: &mut Item) { walk_item(self, i) }
+fn visit_item_mut(&mut self, i: &mut Item) { visit_item_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_item_const(&mut self, i: &mut ItemConst) { walk_item_const(self, i) }
+fn visit_item_const_mut(&mut self, i: &mut ItemConst) { visit_item_const_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_item_default_impl(&mut self, i: &mut ItemDefaultImpl) { walk_item_default_impl(self, i) }
+fn visit_item_default_impl_mut(&mut self, i: &mut ItemDefaultImpl) { visit_item_default_impl_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_item_enum(&mut self, i: &mut ItemEnum) { walk_item_enum(self, i) }
+fn visit_item_enum_mut(&mut self, i: &mut ItemEnum) { visit_item_enum_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_item_extern_crate(&mut self, i: &mut ItemExternCrate) { walk_item_extern_crate(self, i) }
+fn visit_item_extern_crate_mut(&mut self, i: &mut ItemExternCrate) { visit_item_extern_crate_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_item_fn(&mut self, i: &mut ItemFn) { walk_item_fn(self, i) }
+fn visit_item_fn_mut(&mut self, i: &mut ItemFn) { visit_item_fn_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_item_foreign_mod(&mut self, i: &mut ItemForeignMod) { walk_item_foreign_mod(self, i) }
+fn visit_item_foreign_mod_mut(&mut self, i: &mut ItemForeignMod) { visit_item_foreign_mod_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_item_impl(&mut self, i: &mut ItemImpl) { walk_item_impl(self, i) }
+fn visit_item_impl_mut(&mut self, i: &mut ItemImpl) { visit_item_impl_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_item_kind(&mut self, i: &mut ItemKind) { walk_item_kind(self, i) }
+fn visit_item_kind_mut(&mut self, i: &mut ItemKind) { visit_item_kind_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_item_mod(&mut self, i: &mut ItemMod) { walk_item_mod(self, i) }
+fn visit_item_mod_mut(&mut self, i: &mut ItemMod) { visit_item_mod_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_item_static(&mut self, i: &mut ItemStatic) { walk_item_static(self, i) }
+fn visit_item_static_mut(&mut self, i: &mut ItemStatic) { visit_item_static_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_item_struct(&mut self, i: &mut ItemStruct) { walk_item_struct(self, i) }
+fn visit_item_struct_mut(&mut self, i: &mut ItemStruct) { visit_item_struct_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_item_trait(&mut self, i: &mut ItemTrait) { walk_item_trait(self, i) }
+fn visit_item_trait_mut(&mut self, i: &mut ItemTrait) { visit_item_trait_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_item_ty(&mut self, i: &mut ItemTy) { walk_item_ty(self, i) }
+fn visit_item_ty_mut(&mut self, i: &mut ItemTy) { visit_item_ty_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_item_union(&mut self, i: &mut ItemUnion) { walk_item_union(self, i) }
+fn visit_item_union_mut(&mut self, i: &mut ItemUnion) { visit_item_union_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_item_use(&mut self, i: &mut ItemUse) { walk_item_use(self, i) }
+fn visit_item_use_mut(&mut self, i: &mut ItemUse) { visit_item_use_mut(self, i) }
 
-fn visit_lifetime_def(&mut self, i: &mut LifetimeDef) { walk_lifetime_def(self, i) }
+fn visit_lifetime_def_mut(&mut self, i: &mut LifetimeDef) { visit_lifetime_def_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_local(&mut self, i: &mut Local) { walk_local(self, i) }
+fn visit_local_mut(&mut self, i: &mut Local) { visit_local_mut(self, i) }
 
-fn visit_mac(&mut self, i: &mut Mac) { walk_mac(self, i) }
+fn visit_mac_mut(&mut self, i: &mut Mac) { visit_mac_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_mac_stmt_style(&mut self, i: &mut MacStmtStyle) { walk_mac_stmt_style(self, i) }
+fn visit_mac_stmt_style_mut(&mut self, i: &mut MacStmtStyle) { visit_mac_stmt_style_mut(self, i) }
 
-fn visit_meta_item(&mut self, i: &mut MetaItem) { walk_meta_item(self, i) }
+fn visit_meta_item_mut(&mut self, i: &mut MetaItem) { visit_meta_item_mut(self, i) }
 
-fn visit_meta_item_list(&mut self, i: &mut MetaItemList) { walk_meta_item_list(self, i) }
+fn visit_meta_item_list_mut(&mut self, i: &mut MetaItemList) { visit_meta_item_list_mut(self, i) }
 
-fn visit_meta_name_value(&mut self, i: &mut MetaNameValue) { walk_meta_name_value(self, i) }
+fn visit_meta_name_value_mut(&mut self, i: &mut MetaNameValue) { visit_meta_name_value_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_method_sig(&mut self, i: &mut MethodSig) { walk_method_sig(self, i) }
+fn visit_method_sig_mut(&mut self, i: &mut MethodSig) { visit_method_sig_mut(self, i) }
 
-fn visit_mut_ty(&mut self, i: &mut MutTy) { walk_mut_ty(self, i) }
+fn visit_mut_ty_mut(&mut self, i: &mut MutTy) { visit_mut_ty_mut(self, i) }
 
-fn visit_mutability(&mut self, i: &mut Mutability) { walk_mutability(self, i) }
+fn visit_mutability_mut(&mut self, i: &mut Mutability) { visit_mutability_mut(self, i) }
 
-fn visit_nested_meta_item(&mut self, i: &mut NestedMetaItem) { walk_nested_meta_item(self, i) }
+fn visit_nested_meta_item_mut(&mut self, i: &mut NestedMetaItem) { visit_nested_meta_item_mut(self, i) }
 
-fn visit_parenthesized_parameter_data(&mut self, i: &mut ParenthesizedParameterData) { walk_parenthesized_parameter_data(self, i) }
+fn visit_parenthesized_parameter_data_mut(&mut self, i: &mut ParenthesizedParameterData) { visit_parenthesized_parameter_data_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_pat(&mut self, i: &mut Pat) { walk_pat(self, i) }
+fn visit_pat_mut(&mut self, i: &mut Pat) { visit_pat_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_pat_box(&mut self, i: &mut PatBox) { walk_pat_box(self, i) }
+fn visit_pat_box_mut(&mut self, i: &mut PatBox) { visit_pat_box_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_pat_ident(&mut self, i: &mut PatIdent) { walk_pat_ident(self, i) }
+fn visit_pat_ident_mut(&mut self, i: &mut PatIdent) { visit_pat_ident_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_pat_lit(&mut self, i: &mut PatLit) { walk_pat_lit(self, i) }
+fn visit_pat_lit_mut(&mut self, i: &mut PatLit) { visit_pat_lit_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_pat_path(&mut self, i: &mut PatPath) { walk_pat_path(self, i) }
+fn visit_pat_path_mut(&mut self, i: &mut PatPath) { visit_pat_path_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_pat_range(&mut self, i: &mut PatRange) { walk_pat_range(self, i) }
+fn visit_pat_range_mut(&mut self, i: &mut PatRange) { visit_pat_range_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_pat_ref(&mut self, i: &mut PatRef) { walk_pat_ref(self, i) }
+fn visit_pat_ref_mut(&mut self, i: &mut PatRef) { visit_pat_ref_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_pat_slice(&mut self, i: &mut PatSlice) { walk_pat_slice(self, i) }
+fn visit_pat_slice_mut(&mut self, i: &mut PatSlice) { visit_pat_slice_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_pat_struct(&mut self, i: &mut PatStruct) { walk_pat_struct(self, i) }
+fn visit_pat_struct_mut(&mut self, i: &mut PatStruct) { visit_pat_struct_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_pat_tuple(&mut self, i: &mut PatTuple) { walk_pat_tuple(self, i) }
+fn visit_pat_tuple_mut(&mut self, i: &mut PatTuple) { visit_pat_tuple_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_pat_tuple_struct(&mut self, i: &mut PatTupleStruct) { walk_pat_tuple_struct(self, i) }
+fn visit_pat_tuple_struct_mut(&mut self, i: &mut PatTupleStruct) { visit_pat_tuple_struct_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_pat_wild(&mut self, i: &mut PatWild) { walk_pat_wild(self, i) }
+fn visit_pat_wild_mut(&mut self, i: &mut PatWild) { visit_pat_wild_mut(self, i) }
 
-fn visit_path(&mut self, i: &mut Path) { walk_path(self, i) }
+fn visit_path_mut(&mut self, i: &mut Path) { visit_path_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_path_glob(&mut self, i: &mut PathGlob) { walk_path_glob(self, i) }
+fn visit_path_glob_mut(&mut self, i: &mut PathGlob) { visit_path_glob_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_path_list(&mut self, i: &mut PathList) { walk_path_list(self, i) }
+fn visit_path_list_mut(&mut self, i: &mut PathList) { visit_path_list_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_path_list_item(&mut self, i: &mut PathListItem) { walk_path_list_item(self, i) }
+fn visit_path_list_item_mut(&mut self, i: &mut PathListItem) { visit_path_list_item_mut(self, i) }
 
-fn visit_path_parameters(&mut self, i: &mut PathParameters) { walk_path_parameters(self, i) }
+fn visit_path_parameters_mut(&mut self, i: &mut PathParameters) { visit_path_parameters_mut(self, i) }
 
-fn visit_path_segment(&mut self, i: &mut PathSegment) { walk_path_segment(self, i) }
+fn visit_path_segment_mut(&mut self, i: &mut PathSegment) { visit_path_segment_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_path_simple(&mut self, i: &mut PathSimple) { walk_path_simple(self, i) }
+fn visit_path_simple_mut(&mut self, i: &mut PathSimple) { visit_path_simple_mut(self, i) }
 
-fn visit_poly_trait_ref(&mut self, i: &mut PolyTraitRef) { walk_poly_trait_ref(self, i) }
+fn visit_poly_trait_ref_mut(&mut self, i: &mut PolyTraitRef) { visit_poly_trait_ref_mut(self, i) }
 
-fn visit_qself(&mut self, i: &mut QSelf) { walk_qself(self, i) }
+fn visit_qself_mut(&mut self, i: &mut QSelf) { visit_qself_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_range_limits(&mut self, i: &mut RangeLimits) { walk_range_limits(self, i) }
+fn visit_range_limits_mut(&mut self, i: &mut RangeLimits) { visit_range_limits_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_stmt(&mut self, i: &mut Stmt) { walk_stmt(self, i) }
+fn visit_stmt_mut(&mut self, i: &mut Stmt) { visit_stmt_mut(self, i) }
 
-fn visit_trait_bound_modifier(&mut self, i: &mut TraitBoundModifier) { walk_trait_bound_modifier(self, i) }
+fn visit_trait_bound_modifier_mut(&mut self, i: &mut TraitBoundModifier) { visit_trait_bound_modifier_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_trait_item(&mut self, i: &mut TraitItem) { walk_trait_item(self, i) }
+fn visit_trait_item_mut(&mut self, i: &mut TraitItem) { visit_trait_item_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_trait_item_const(&mut self, i: &mut TraitItemConst) { walk_trait_item_const(self, i) }
+fn visit_trait_item_const_mut(&mut self, i: &mut TraitItemConst) { visit_trait_item_const_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_trait_item_kind(&mut self, i: &mut TraitItemKind) { walk_trait_item_kind(self, i) }
+fn visit_trait_item_kind_mut(&mut self, i: &mut TraitItemKind) { visit_trait_item_kind_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_trait_item_method(&mut self, i: &mut TraitItemMethod) { walk_trait_item_method(self, i) }
+fn visit_trait_item_method_mut(&mut self, i: &mut TraitItemMethod) { visit_trait_item_method_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_trait_item_type(&mut self, i: &mut TraitItemType) { walk_trait_item_type(self, i) }
+fn visit_trait_item_type_mut(&mut self, i: &mut TraitItemType) { visit_trait_item_type_mut(self, i) }
 
-fn visit_ty(&mut self, i: &mut Ty) { walk_ty(self, i) }
+fn visit_ty_mut(&mut self, i: &mut Ty) { visit_ty_mut(self, i) }
 
-fn visit_ty_array(&mut self, i: &mut TyArray) { walk_ty_array(self, i) }
+fn visit_ty_array_mut(&mut self, i: &mut TyArray) { visit_ty_array_mut(self, i) }
 
-fn visit_ty_bare_fn(&mut self, i: &mut TyBareFn) { walk_ty_bare_fn(self, i) }
+fn visit_ty_bare_fn_mut(&mut self, i: &mut TyBareFn) { visit_ty_bare_fn_mut(self, i) }
 
-fn visit_ty_group(&mut self, i: &mut TyGroup) { walk_ty_group(self, i) }
+fn visit_ty_group_mut(&mut self, i: &mut TyGroup) { visit_ty_group_mut(self, i) }
 
-fn visit_ty_impl_trait(&mut self, i: &mut TyImplTrait) { walk_ty_impl_trait(self, i) }
+fn visit_ty_impl_trait_mut(&mut self, i: &mut TyImplTrait) { visit_ty_impl_trait_mut(self, i) }
 
-fn visit_ty_infer(&mut self, i: &mut TyInfer) { walk_ty_infer(self, i) }
+fn visit_ty_infer_mut(&mut self, i: &mut TyInfer) { visit_ty_infer_mut(self, i) }
 
-fn visit_ty_never(&mut self, i: &mut TyNever) { walk_ty_never(self, i) }
+fn visit_ty_never_mut(&mut self, i: &mut TyNever) { visit_ty_never_mut(self, i) }
 
-fn visit_ty_param(&mut self, i: &mut TyParam) { walk_ty_param(self, i) }
+fn visit_ty_param_mut(&mut self, i: &mut TyParam) { visit_ty_param_mut(self, i) }
 
-fn visit_ty_param_bound(&mut self, i: &mut TyParamBound) { walk_ty_param_bound(self, i) }
+fn visit_ty_param_bound_mut(&mut self, i: &mut TyParamBound) { visit_ty_param_bound_mut(self, i) }
 
-fn visit_ty_paren(&mut self, i: &mut TyParen) { walk_ty_paren(self, i) }
+fn visit_ty_paren_mut(&mut self, i: &mut TyParen) { visit_ty_paren_mut(self, i) }
 
-fn visit_ty_path(&mut self, i: &mut TyPath) { walk_ty_path(self, i) }
+fn visit_ty_path_mut(&mut self, i: &mut TyPath) { visit_ty_path_mut(self, i) }
 
-fn visit_ty_ptr(&mut self, i: &mut TyPtr) { walk_ty_ptr(self, i) }
+fn visit_ty_ptr_mut(&mut self, i: &mut TyPtr) { visit_ty_ptr_mut(self, i) }
 
-fn visit_ty_rptr(&mut self, i: &mut TyRptr) { walk_ty_rptr(self, i) }
+fn visit_ty_rptr_mut(&mut self, i: &mut TyRptr) { visit_ty_rptr_mut(self, i) }
 
-fn visit_ty_slice(&mut self, i: &mut TySlice) { walk_ty_slice(self, i) }
+fn visit_ty_slice_mut(&mut self, i: &mut TySlice) { visit_ty_slice_mut(self, i) }
 
-fn visit_ty_trait_object(&mut self, i: &mut TyTraitObject) { walk_ty_trait_object(self, i) }
+fn visit_ty_trait_object_mut(&mut self, i: &mut TyTraitObject) { visit_ty_trait_object_mut(self, i) }
 
-fn visit_ty_tup(&mut self, i: &mut TyTup) { walk_ty_tup(self, i) }
+fn visit_ty_tup_mut(&mut self, i: &mut TyTup) { visit_ty_tup_mut(self, i) }
 
-fn visit_type_binding(&mut self, i: &mut TypeBinding) { walk_type_binding(self, i) }
+fn visit_type_binding_mut(&mut self, i: &mut TypeBinding) { visit_type_binding_mut(self, i) }
 
-fn visit_un_op(&mut self, i: &mut UnOp) { walk_un_op(self, i) }
+fn visit_un_op_mut(&mut self, i: &mut UnOp) { visit_un_op_mut(self, i) }
 
-fn visit_unsafety(&mut self, i: &mut Unsafety) { walk_unsafety(self, i) }
+fn visit_unsafety_mut(&mut self, i: &mut Unsafety) { visit_unsafety_mut(self, i) }
 
-fn visit_variant(&mut self, i: &mut Variant) { walk_variant(self, i) }
+fn visit_variant_mut(&mut self, i: &mut Variant) { visit_variant_mut(self, i) }
 
-fn visit_variant_data(&mut self, i: &mut VariantData) { walk_variant_data(self, i) }
+fn visit_variant_data_mut(&mut self, i: &mut VariantData) { visit_variant_data_mut(self, i) }
 # [ cfg ( feature = "full" ) ]
-fn visit_view_path(&mut self, i: &mut ViewPath) { walk_view_path(self, i) }
+fn visit_view_path_mut(&mut self, i: &mut ViewPath) { visit_view_path_mut(self, i) }
 
-fn visit_vis_crate(&mut self, i: &mut VisCrate) { walk_vis_crate(self, i) }
+fn visit_vis_crate_mut(&mut self, i: &mut VisCrate) { visit_vis_crate_mut(self, i) }
 
-fn visit_vis_inherited(&mut self, i: &mut VisInherited) { walk_vis_inherited(self, i) }
+fn visit_vis_inherited_mut(&mut self, i: &mut VisInherited) { visit_vis_inherited_mut(self, i) }
 
-fn visit_vis_public(&mut self, i: &mut VisPublic) { walk_vis_public(self, i) }
+fn visit_vis_public_mut(&mut self, i: &mut VisPublic) { visit_vis_public_mut(self, i) }
 
-fn visit_vis_restricted(&mut self, i: &mut VisRestricted) { walk_vis_restricted(self, i) }
+fn visit_vis_restricted_mut(&mut self, i: &mut VisRestricted) { visit_vis_restricted_mut(self, i) }
 
-fn visit_visibility(&mut self, i: &mut Visibility) { walk_visibility(self, i) }
+fn visit_visibility_mut(&mut self, i: &mut Visibility) { visit_visibility_mut(self, i) }
 
-fn visit_where_bound_predicate(&mut self, i: &mut WhereBoundPredicate) { walk_where_bound_predicate(self, i) }
+fn visit_where_bound_predicate_mut(&mut self, i: &mut WhereBoundPredicate) { visit_where_bound_predicate_mut(self, i) }
 
-fn visit_where_clause(&mut self, i: &mut WhereClause) { walk_where_clause(self, i) }
+fn visit_where_clause_mut(&mut self, i: &mut WhereClause) { visit_where_clause_mut(self, i) }
 
-fn visit_where_eq_predicate(&mut self, i: &mut WhereEqPredicate) { walk_where_eq_predicate(self, i) }
+fn visit_where_eq_predicate_mut(&mut self, i: &mut WhereEqPredicate) { visit_where_eq_predicate_mut(self, i) }
 
-fn visit_where_predicate(&mut self, i: &mut WherePredicate) { walk_where_predicate(self, i) }
+fn visit_where_predicate_mut(&mut self, i: &mut WherePredicate) { visit_where_predicate_mut(self, i) }
 
-fn visit_where_region_predicate(&mut self, i: &mut WhereRegionPredicate) { walk_where_region_predicate(self, i) }
+fn visit_where_region_predicate_mut(&mut self, i: &mut WhereRegionPredicate) { visit_where_region_predicate_mut(self, i) }
 
 }
 
 
-pub fn walk_abi<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Abi) {
+pub fn visit_abi_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Abi) {
     // Skipped field _i . extern_token;
-    _visitor.visit_abi_kind(&mut _i . kind);
+    _visitor.visit_abi_kind_mut(&mut _i . kind);
 }
 
-pub fn walk_abi_kind<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut AbiKind) {
+pub fn visit_abi_kind_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut AbiKind) {
     use ::AbiKind::*;
     match *_i {
         Named(ref mut _binding_0, ) => {
@@ -389,44 +389,44 @@
     }
 }
 
-pub fn walk_angle_bracketed_parameter_data<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut AngleBracketedParameterData) {
+pub fn visit_angle_bracketed_parameter_data_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut AngleBracketedParameterData) {
     // Skipped field _i . turbofish;
     // Skipped field _i . lt_token;
     // Skipped field _i . lifetimes;
-    for mut el in (_i . types).iter_mut() { let mut it = el.item_mut(); _visitor.visit_ty(&mut it) };
-    for mut el in (_i . bindings).iter_mut() { let mut it = el.item_mut(); _visitor.visit_type_binding(&mut it) };
+    for mut el in (_i . types).iter_mut() { let mut it = el.item_mut(); _visitor.visit_ty_mut(&mut it) };
+    for mut el in (_i . bindings).iter_mut() { let mut it = el.item_mut(); _visitor.visit_type_binding_mut(&mut it) };
     // Skipped field _i . gt_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_arg_captured<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ArgCaptured) {
-    _visitor.visit_pat(&mut _i . pat);
+pub fn visit_arg_captured_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ArgCaptured) {
+    _visitor.visit_pat_mut(&mut _i . pat);
     // Skipped field _i . colon_token;
-    _visitor.visit_ty(&mut _i . ty);
+    _visitor.visit_ty_mut(&mut _i . ty);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_arg_self<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ArgSelf) {
-    _visitor.visit_mutability(&mut _i . mutbl);
+pub fn visit_arg_self_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ArgSelf) {
+    _visitor.visit_mutability_mut(&mut _i . mutbl);
     // Skipped field _i . self_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_arg_self_ref<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ArgSelfRef) {
+pub fn visit_arg_self_ref_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ArgSelfRef) {
     // Skipped field _i . and_token;
     // Skipped field _i . self_token;
     // Skipped field _i . lifetime;
-    _visitor.visit_mutability(&mut _i . mutbl);
+    _visitor.visit_mutability_mut(&mut _i . mutbl);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_arm<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Arm) {
-    for mut it in (_i . attrs).iter_mut() { _visitor.visit_attribute(&mut it) };
-    for mut el in (_i . pats).iter_mut() { let mut it = el.item_mut(); _visitor.visit_pat(&mut it) };
+pub fn visit_arm_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Arm) {
+    for mut it in (_i . attrs).iter_mut() { _visitor.visit_attribute_mut(&mut it) };
+    for mut el in (_i . pats).iter_mut() { let mut it = el.item_mut(); _visitor.visit_pat_mut(&mut it) };
     // Skipped field _i . if_token;
-    if let Some(ref mut it) = _i . guard { _visitor.visit_expr(&mut * it) };
+    if let Some(ref mut it) = _i . guard { _visitor.visit_expr_mut(&mut * it) };
     // Skipped field _i . rocket_token;
-    _visitor.visit_expr(&mut _i . body);
+    _visitor.visit_expr_mut(&mut _i . body);
     // Skipped field _i . comma;
 }
 
-pub fn walk_attr_style<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut AttrStyle) {
+pub fn visit_attr_style_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut AttrStyle) {
     use ::AttrStyle::*;
     match *_i {
         Outer => { }
@@ -436,21 +436,21 @@
     }
 }
 
-pub fn walk_attribute<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Attribute) {
-    _visitor.visit_attr_style(&mut _i . style);
+pub fn visit_attribute_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Attribute) {
+    _visitor.visit_attr_style_mut(&mut _i . style);
     // Skipped field _i . pound_token;
     // Skipped field _i . bracket_token;
-    _visitor.visit_path(&mut _i . path);
+    _visitor.visit_path_mut(&mut _i . path);
     // Skipped field _i . tts;
     // Skipped field _i . is_sugared_doc;
 }
 
-pub fn walk_bare_fn_arg<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut BareFnArg) {
+pub fn visit_bare_fn_arg_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut BareFnArg) {
     // Skipped field _i . name;
-    _visitor.visit_ty(&mut _i . ty);
+    _visitor.visit_ty_mut(&mut _i . ty);
 }
 
-pub fn walk_bare_fn_arg_name<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut BareFnArgName) {
+pub fn visit_bare_fn_arg_name_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut BareFnArgName) {
     use ::BareFnArgName::*;
     match *_i {
         Named(ref mut _binding_0, ) => {
@@ -462,18 +462,18 @@
     }
 }
 
-pub fn walk_bare_fn_ty<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut BareFnTy) {
-    if let Some(ref mut it) = _i . lifetimes { _visitor.visit_bound_lifetimes(&mut * it) };
-    _visitor.visit_unsafety(&mut _i . unsafety);
-    if let Some(ref mut it) = _i . abi { _visitor.visit_abi(&mut * it) };
+pub fn visit_bare_fn_ty_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut BareFnTy) {
+    if let Some(ref mut it) = _i . lifetimes { _visitor.visit_bound_lifetimes_mut(&mut * it) };
+    _visitor.visit_unsafety_mut(&mut _i . unsafety);
+    if let Some(ref mut it) = _i . abi { _visitor.visit_abi_mut(&mut * it) };
     // Skipped field _i . fn_token;
     // Skipped field _i . paren_token;
-    for mut el in (_i . inputs).iter_mut() { let mut it = el.item_mut(); _visitor.visit_bare_fn_arg(&mut it) };
+    for mut el in (_i . inputs).iter_mut() { let mut it = el.item_mut(); _visitor.visit_bare_fn_arg_mut(&mut it) };
     // Skipped field _i . variadic;
-    _visitor.visit_function_ret_ty(&mut _i . output);
+    _visitor.visit_function_ret_ty_mut(&mut _i . output);
 }
 
-pub fn walk_bin_op<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut BinOp) {
+pub fn visit_bin_op_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut BinOp) {
     use ::BinOp::*;
     match *_i {
         Add(ref mut _binding_0, ) => {
@@ -563,56 +563,56 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_binding_mode<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut BindingMode) {
+pub fn visit_binding_mode_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut BindingMode) {
     use ::BindingMode::*;
     match *_i {
         ByRef(ref mut _binding_0, ref mut _binding_1, ) => {
             // Skipped field * _binding_0;
-            _visitor.visit_mutability(&mut * _binding_1);
+            _visitor.visit_mutability_mut(&mut * _binding_1);
         }
         ByValue(ref mut _binding_0, ) => {
-            _visitor.visit_mutability(&mut * _binding_0);
+            _visitor.visit_mutability_mut(&mut * _binding_0);
         }
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_block<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Block) {
+pub fn visit_block_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Block) {
     // Skipped field _i . brace_token;
-    for mut it in (_i . stmts).iter_mut() { _visitor.visit_stmt(&mut it) };
+    for mut it in (_i . stmts).iter_mut() { _visitor.visit_stmt_mut(&mut it) };
 }
 
-pub fn walk_body<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Body) {
+pub fn visit_body_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Body) {
     use ::Body::*;
     match *_i {
         Enum(ref mut _binding_0, ) => {
-            _visitor.visit_body_enum(&mut * _binding_0);
+            _visitor.visit_body_enum_mut(&mut * _binding_0);
         }
         Struct(ref mut _binding_0, ) => {
-            _visitor.visit_body_struct(&mut * _binding_0);
+            _visitor.visit_body_struct_mut(&mut * _binding_0);
         }
     }
 }
 
-pub fn walk_body_enum<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut BodyEnum) {
+pub fn visit_body_enum_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut BodyEnum) {
     // Skipped field _i . enum_token;
     // Skipped field _i . brace_token;
-    for mut el in (_i . variants).iter_mut() { let mut it = el.item_mut(); _visitor.visit_variant(&mut it) };
+    for mut el in (_i . variants).iter_mut() { let mut it = el.item_mut(); _visitor.visit_variant_mut(&mut it) };
 }
 
-pub fn walk_body_struct<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut BodyStruct) {
-    _visitor.visit_variant_data(&mut _i . data);
+pub fn visit_body_struct_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut BodyStruct) {
+    _visitor.visit_variant_data_mut(&mut _i . data);
     // Skipped field _i . struct_token;
     // Skipped field _i . semi_token;
 }
 
-pub fn walk_bound_lifetimes<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut BoundLifetimes) {
+pub fn visit_bound_lifetimes_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut BoundLifetimes) {
     // Skipped field _i . for_token;
     // Skipped field _i . lt_token;
-    for mut el in (_i . lifetimes).iter_mut() { let mut it = el.item_mut(); _visitor.visit_lifetime_def(&mut it) };
+    for mut el in (_i . lifetimes).iter_mut() { let mut it = el.item_mut(); _visitor.visit_lifetime_def_mut(&mut it) };
     // Skipped field _i . gt_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_capture_by<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut CaptureBy) {
+pub fn visit_capture_by_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut CaptureBy) {
     use ::CaptureBy::*;
     match *_i {
         Value(ref mut _binding_0, ) => {
@@ -622,7 +622,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_constness<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Constness) {
+pub fn visit_constness_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Constness) {
     use ::Constness::*;
     match *_i {
         Const(ref mut _binding_0, ) => {
@@ -632,7 +632,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_defaultness<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Defaultness) {
+pub fn visit_defaultness_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Defaultness) {
     use ::Defaultness::*;
     match *_i {
         Default(ref mut _binding_0, ) => {
@@ -642,289 +642,289 @@
     }
 }
 
-pub fn walk_derive_input<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut DeriveInput) {
+pub fn visit_derive_input_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut DeriveInput) {
     // Skipped field _i . ident;
-    _visitor.visit_visibility(&mut _i . vis);
-    for mut it in (_i . attrs).iter_mut() { _visitor.visit_attribute(&mut it) };
-    _visitor.visit_generics(&mut _i . generics);
-    _visitor.visit_body(&mut _i . body);
+    _visitor.visit_visibility_mut(&mut _i . vis);
+    for mut it in (_i . attrs).iter_mut() { _visitor.visit_attribute_mut(&mut it) };
+    _visitor.visit_generics_mut(&mut _i . generics);
+    _visitor.visit_body_mut(&mut _i . body);
 }
 
-pub fn walk_expr<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Expr) {
-    _visitor.visit_expr_kind(&mut _i . node);
-    for mut it in (_i . attrs).iter_mut() { _visitor.visit_attribute(&mut it) };
+pub fn visit_expr_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Expr) {
+    _visitor.visit_expr_kind_mut(&mut _i . node);
+    for mut it in (_i . attrs).iter_mut() { _visitor.visit_attribute_mut(&mut it) };
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_addr_of<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprAddrOf) {
+pub fn visit_expr_addr_of_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprAddrOf) {
     // Skipped field _i . and_token;
-    _visitor.visit_mutability(&mut _i . mutbl);
-    _visitor.visit_expr(&mut _i . expr);
+    _visitor.visit_mutability_mut(&mut _i . mutbl);
+    _visitor.visit_expr_mut(&mut _i . expr);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_array<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprArray) {
-    for mut el in (_i . exprs).iter_mut() { let mut it = el.item_mut(); _visitor.visit_expr(&mut it) };
+pub fn visit_expr_array_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprArray) {
+    for mut el in (_i . exprs).iter_mut() { let mut it = el.item_mut(); _visitor.visit_expr_mut(&mut it) };
     // Skipped field _i . bracket_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_assign<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprAssign) {
-    _visitor.visit_expr(&mut _i . left);
-    _visitor.visit_expr(&mut _i . right);
+pub fn visit_expr_assign_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprAssign) {
+    _visitor.visit_expr_mut(&mut _i . left);
+    _visitor.visit_expr_mut(&mut _i . right);
     // Skipped field _i . eq_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_assign_op<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprAssignOp) {
-    _visitor.visit_bin_op(&mut _i . op);
-    _visitor.visit_expr(&mut _i . left);
-    _visitor.visit_expr(&mut _i . right);
+pub fn visit_expr_assign_op_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprAssignOp) {
+    _visitor.visit_bin_op_mut(&mut _i . op);
+    _visitor.visit_expr_mut(&mut _i . left);
+    _visitor.visit_expr_mut(&mut _i . right);
 }
 
-pub fn walk_expr_binary<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprBinary) {
-    _visitor.visit_bin_op(&mut _i . op);
-    _visitor.visit_expr(&mut _i . left);
-    _visitor.visit_expr(&mut _i . right);
+pub fn visit_expr_binary_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprBinary) {
+    _visitor.visit_bin_op_mut(&mut _i . op);
+    _visitor.visit_expr_mut(&mut _i . left);
+    _visitor.visit_expr_mut(&mut _i . right);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_block<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprBlock) {
-    _visitor.visit_unsafety(&mut _i . unsafety);
-    _visitor.visit_block(&mut _i . block);
+pub fn visit_expr_block_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprBlock) {
+    _visitor.visit_unsafety_mut(&mut _i . unsafety);
+    _visitor.visit_block_mut(&mut _i . block);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_box<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprBox) {
-    _visitor.visit_expr(&mut _i . expr);
+pub fn visit_expr_box_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprBox) {
+    _visitor.visit_expr_mut(&mut _i . expr);
     // Skipped field _i . box_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_break<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprBreak) {
+pub fn visit_expr_break_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprBreak) {
     // Skipped field _i . label;
-    if let Some(ref mut it) = _i . expr { _visitor.visit_expr(&mut * it) };
+    if let Some(ref mut it) = _i . expr { _visitor.visit_expr_mut(&mut * it) };
     // Skipped field _i . break_token;
 }
 
-pub fn walk_expr_call<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprCall) {
-    _visitor.visit_expr(&mut _i . func);
-    for mut el in (_i . args).iter_mut() { let mut it = el.item_mut(); _visitor.visit_expr(&mut it) };
+pub fn visit_expr_call_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprCall) {
+    _visitor.visit_expr_mut(&mut _i . func);
+    for mut el in (_i . args).iter_mut() { let mut it = el.item_mut(); _visitor.visit_expr_mut(&mut it) };
     // Skipped field _i . paren_token;
 }
 
-pub fn walk_expr_cast<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprCast) {
-    _visitor.visit_expr(&mut _i . expr);
+pub fn visit_expr_cast_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprCast) {
+    _visitor.visit_expr_mut(&mut _i . expr);
     // Skipped field _i . as_token;
-    _visitor.visit_ty(&mut _i . ty);
+    _visitor.visit_ty_mut(&mut _i . ty);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_catch<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprCatch) {
+pub fn visit_expr_catch_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprCatch) {
     // Skipped field _i . do_token;
     // Skipped field _i . catch_token;
-    _visitor.visit_block(&mut _i . block);
+    _visitor.visit_block_mut(&mut _i . block);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_closure<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprClosure) {
-    _visitor.visit_capture_by(&mut _i . capture);
-    _visitor.visit_fn_decl(&mut _i . decl);
-    _visitor.visit_expr(&mut _i . body);
+pub fn visit_expr_closure_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprClosure) {
+    _visitor.visit_capture_by_mut(&mut _i . capture);
+    _visitor.visit_fn_decl_mut(&mut _i . decl);
+    _visitor.visit_expr_mut(&mut _i . body);
     // Skipped field _i . or1_token;
     // Skipped field _i . or2_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_continue<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprContinue) {
+pub fn visit_expr_continue_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprContinue) {
     // Skipped field _i . label;
     // Skipped field _i . continue_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_field<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprField) {
-    _visitor.visit_expr(&mut _i . expr);
+pub fn visit_expr_field_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprField) {
+    _visitor.visit_expr_mut(&mut _i . expr);
     // Skipped field _i . field;
     // Skipped field _i . dot_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_for_loop<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprForLoop) {
-    _visitor.visit_pat(&mut _i . pat);
-    _visitor.visit_expr(&mut _i . expr);
-    _visitor.visit_block(&mut _i . body);
+pub fn visit_expr_for_loop_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprForLoop) {
+    _visitor.visit_pat_mut(&mut _i . pat);
+    _visitor.visit_expr_mut(&mut _i . expr);
+    _visitor.visit_block_mut(&mut _i . body);
     // Skipped field _i . label;
     // Skipped field _i . for_token;
     // Skipped field _i . colon_token;
     // Skipped field _i . in_token;
 }
 
-pub fn walk_expr_group<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprGroup) {
-    _visitor.visit_expr(&mut _i . expr);
+pub fn visit_expr_group_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprGroup) {
+    _visitor.visit_expr_mut(&mut _i . expr);
     // Skipped field _i . group_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_if<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprIf) {
-    _visitor.visit_expr(&mut _i . cond);
-    _visitor.visit_block(&mut _i . if_true);
-    if let Some(ref mut it) = _i . if_false { _visitor.visit_expr(&mut * it) };
+pub fn visit_expr_if_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprIf) {
+    _visitor.visit_expr_mut(&mut _i . cond);
+    _visitor.visit_block_mut(&mut _i . if_true);
+    if let Some(ref mut it) = _i . if_false { _visitor.visit_expr_mut(&mut * it) };
     // Skipped field _i . if_token;
     // Skipped field _i . else_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_if_let<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprIfLet) {
-    _visitor.visit_pat(&mut _i . pat);
-    _visitor.visit_expr(&mut _i . expr);
-    _visitor.visit_block(&mut _i . if_true);
-    if let Some(ref mut it) = _i . if_false { _visitor.visit_expr(&mut * it) };
+pub fn visit_expr_if_let_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprIfLet) {
+    _visitor.visit_pat_mut(&mut _i . pat);
+    _visitor.visit_expr_mut(&mut _i . expr);
+    _visitor.visit_block_mut(&mut _i . if_true);
+    if let Some(ref mut it) = _i . if_false { _visitor.visit_expr_mut(&mut * it) };
     // Skipped field _i . if_token;
     // Skipped field _i . let_token;
     // Skipped field _i . eq_token;
     // Skipped field _i . else_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_in_place<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprInPlace) {
-    _visitor.visit_expr(&mut _i . place);
-    _visitor.visit_in_place_kind(&mut _i . kind);
-    _visitor.visit_expr(&mut _i . value);
+pub fn visit_expr_in_place_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprInPlace) {
+    _visitor.visit_expr_mut(&mut _i . place);
+    _visitor.visit_in_place_kind_mut(&mut _i . kind);
+    _visitor.visit_expr_mut(&mut _i . value);
 }
 
-pub fn walk_expr_index<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprIndex) {
-    _visitor.visit_expr(&mut _i . expr);
-    _visitor.visit_expr(&mut _i . index);
+pub fn visit_expr_index_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprIndex) {
+    _visitor.visit_expr_mut(&mut _i . expr);
+    _visitor.visit_expr_mut(&mut _i . index);
     // Skipped field _i . bracket_token;
 }
 
-pub fn walk_expr_kind<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprKind) {
+pub fn visit_expr_kind_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprKind) {
     use ::ExprKind::*;
     match *_i {
         Box(ref mut _binding_0, ) => {
-            full!(_visitor.visit_expr_box(&mut * _binding_0));
+            full!(_visitor.visit_expr_box_mut(&mut * _binding_0));
         }
         InPlace(ref mut _binding_0, ) => {
-            full!(_visitor.visit_expr_in_place(&mut * _binding_0));
+            full!(_visitor.visit_expr_in_place_mut(&mut * _binding_0));
         }
         Array(ref mut _binding_0, ) => {
-            full!(_visitor.visit_expr_array(&mut * _binding_0));
+            full!(_visitor.visit_expr_array_mut(&mut * _binding_0));
         }
         Call(ref mut _binding_0, ) => {
-            _visitor.visit_expr_call(&mut * _binding_0);
+            _visitor.visit_expr_call_mut(&mut * _binding_0);
         }
         MethodCall(ref mut _binding_0, ) => {
-            full!(_visitor.visit_expr_method_call(&mut * _binding_0));
+            full!(_visitor.visit_expr_method_call_mut(&mut * _binding_0));
         }
         Tup(ref mut _binding_0, ) => {
-            full!(_visitor.visit_expr_tup(&mut * _binding_0));
+            full!(_visitor.visit_expr_tup_mut(&mut * _binding_0));
         }
         Binary(ref mut _binding_0, ) => {
-            _visitor.visit_expr_binary(&mut * _binding_0);
+            _visitor.visit_expr_binary_mut(&mut * _binding_0);
         }
         Unary(ref mut _binding_0, ) => {
-            _visitor.visit_expr_unary(&mut * _binding_0);
+            _visitor.visit_expr_unary_mut(&mut * _binding_0);
         }
         Lit(ref mut _binding_0, ) => {
             // Skipped field * _binding_0;
         }
         Cast(ref mut _binding_0, ) => {
-            _visitor.visit_expr_cast(&mut * _binding_0);
+            _visitor.visit_expr_cast_mut(&mut * _binding_0);
         }
         Type(ref mut _binding_0, ) => {
-            _visitor.visit_expr_type(&mut * _binding_0);
+            _visitor.visit_expr_type_mut(&mut * _binding_0);
         }
         If(ref mut _binding_0, ) => {
-            full!(_visitor.visit_expr_if(&mut * _binding_0));
+            full!(_visitor.visit_expr_if_mut(&mut * _binding_0));
         }
         IfLet(ref mut _binding_0, ) => {
-            full!(_visitor.visit_expr_if_let(&mut * _binding_0));
+            full!(_visitor.visit_expr_if_let_mut(&mut * _binding_0));
         }
         While(ref mut _binding_0, ) => {
-            full!(_visitor.visit_expr_while(&mut * _binding_0));
+            full!(_visitor.visit_expr_while_mut(&mut * _binding_0));
         }
         WhileLet(ref mut _binding_0, ) => {
-            full!(_visitor.visit_expr_while_let(&mut * _binding_0));
+            full!(_visitor.visit_expr_while_let_mut(&mut * _binding_0));
         }
         ForLoop(ref mut _binding_0, ) => {
-            full!(_visitor.visit_expr_for_loop(&mut * _binding_0));
+            full!(_visitor.visit_expr_for_loop_mut(&mut * _binding_0));
         }
         Loop(ref mut _binding_0, ) => {
-            full!(_visitor.visit_expr_loop(&mut * _binding_0));
+            full!(_visitor.visit_expr_loop_mut(&mut * _binding_0));
         }
         Match(ref mut _binding_0, ) => {
-            full!(_visitor.visit_expr_match(&mut * _binding_0));
+            full!(_visitor.visit_expr_match_mut(&mut * _binding_0));
         }
         Closure(ref mut _binding_0, ) => {
-            full!(_visitor.visit_expr_closure(&mut * _binding_0));
+            full!(_visitor.visit_expr_closure_mut(&mut * _binding_0));
         }
         Block(ref mut _binding_0, ) => {
-            full!(_visitor.visit_expr_block(&mut * _binding_0));
+            full!(_visitor.visit_expr_block_mut(&mut * _binding_0));
         }
         Assign(ref mut _binding_0, ) => {
-            full!(_visitor.visit_expr_assign(&mut * _binding_0));
+            full!(_visitor.visit_expr_assign_mut(&mut * _binding_0));
         }
         AssignOp(ref mut _binding_0, ) => {
-            full!(_visitor.visit_expr_assign_op(&mut * _binding_0));
+            full!(_visitor.visit_expr_assign_op_mut(&mut * _binding_0));
         }
         Field(ref mut _binding_0, ) => {
-            full!(_visitor.visit_expr_field(&mut * _binding_0));
+            full!(_visitor.visit_expr_field_mut(&mut * _binding_0));
         }
         TupField(ref mut _binding_0, ) => {
-            full!(_visitor.visit_expr_tup_field(&mut * _binding_0));
+            full!(_visitor.visit_expr_tup_field_mut(&mut * _binding_0));
         }
         Index(ref mut _binding_0, ) => {
-            _visitor.visit_expr_index(&mut * _binding_0);
+            _visitor.visit_expr_index_mut(&mut * _binding_0);
         }
         Range(ref mut _binding_0, ) => {
-            full!(_visitor.visit_expr_range(&mut * _binding_0));
+            full!(_visitor.visit_expr_range_mut(&mut * _binding_0));
         }
         Path(ref mut _binding_0, ) => {
-            _visitor.visit_expr_path(&mut * _binding_0);
+            _visitor.visit_expr_path_mut(&mut * _binding_0);
         }
         AddrOf(ref mut _binding_0, ) => {
-            full!(_visitor.visit_expr_addr_of(&mut * _binding_0));
+            full!(_visitor.visit_expr_addr_of_mut(&mut * _binding_0));
         }
         Break(ref mut _binding_0, ) => {
-            full!(_visitor.visit_expr_break(&mut * _binding_0));
+            full!(_visitor.visit_expr_break_mut(&mut * _binding_0));
         }
         Continue(ref mut _binding_0, ) => {
-            full!(_visitor.visit_expr_continue(&mut * _binding_0));
+            full!(_visitor.visit_expr_continue_mut(&mut * _binding_0));
         }
         Ret(ref mut _binding_0, ) => {
-            full!(_visitor.visit_expr_ret(&mut * _binding_0));
+            full!(_visitor.visit_expr_ret_mut(&mut * _binding_0));
         }
         Mac(ref mut _binding_0, ) => {
-            _visitor.visit_mac(&mut * _binding_0);
+            _visitor.visit_mac_mut(&mut * _binding_0);
         }
         Struct(ref mut _binding_0, ) => {
-            full!(_visitor.visit_expr_struct(&mut * _binding_0));
+            full!(_visitor.visit_expr_struct_mut(&mut * _binding_0));
         }
         Repeat(ref mut _binding_0, ) => {
-            full!(_visitor.visit_expr_repeat(&mut * _binding_0));
+            full!(_visitor.visit_expr_repeat_mut(&mut * _binding_0));
         }
         Paren(ref mut _binding_0, ) => {
-            _visitor.visit_expr_paren(&mut * _binding_0);
+            _visitor.visit_expr_paren_mut(&mut * _binding_0);
         }
         Group(ref mut _binding_0, ) => {
-            _visitor.visit_expr_group(&mut * _binding_0);
+            _visitor.visit_expr_group_mut(&mut * _binding_0);
         }
         Try(ref mut _binding_0, ) => {
-            full!(_visitor.visit_expr_try(&mut * _binding_0));
+            full!(_visitor.visit_expr_try_mut(&mut * _binding_0));
         }
         Catch(ref mut _binding_0, ) => {
-            full!(_visitor.visit_expr_catch(&mut * _binding_0));
+            full!(_visitor.visit_expr_catch_mut(&mut * _binding_0));
         }
         Yield(ref mut _binding_0, ) => {
-            full!(_visitor.visit_expr_yield(&mut * _binding_0));
+            full!(_visitor.visit_expr_yield_mut(&mut * _binding_0));
         }
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_loop<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprLoop) {
-    _visitor.visit_block(&mut _i . body);
+pub fn visit_expr_loop_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprLoop) {
+    _visitor.visit_block_mut(&mut _i . body);
     // Skipped field _i . label;
     // Skipped field _i . loop_token;
     // Skipped field _i . colon_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_match<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprMatch) {
+pub fn visit_expr_match_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprMatch) {
     // Skipped field _i . match_token;
     // Skipped field _i . brace_token;
-    _visitor.visit_expr(&mut _i . expr);
-    for mut it in (_i . arms).iter_mut() { _visitor.visit_arm(&mut it) };
+    _visitor.visit_expr_mut(&mut _i . expr);
+    for mut it in (_i . arms).iter_mut() { _visitor.visit_arm_mut(&mut it) };
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_method_call<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprMethodCall) {
-    _visitor.visit_expr(&mut _i . expr);
+pub fn visit_expr_method_call_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprMethodCall) {
+    _visitor.visit_expr_mut(&mut _i . expr);
     // Skipped field _i . method;
-    for mut el in (_i . typarams).iter_mut() { let mut it = el.item_mut(); _visitor.visit_ty(&mut it) };
-    for mut el in (_i . args).iter_mut() { let mut it = el.item_mut(); _visitor.visit_expr(&mut it) };
+    for mut el in (_i . typarams).iter_mut() { let mut it = el.item_mut(); _visitor.visit_ty_mut(&mut it) };
+    for mut el in (_i . args).iter_mut() { let mut it = el.item_mut(); _visitor.visit_expr_mut(&mut it) };
     // Skipped field _i . paren_token;
     // Skipped field _i . dot_token;
     // Skipped field _i . lt_token;
@@ -932,82 +932,82 @@
     // Skipped field _i . gt_token;
 }
 
-pub fn walk_expr_paren<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprParen) {
-    _visitor.visit_expr(&mut _i . expr);
+pub fn visit_expr_paren_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprParen) {
+    _visitor.visit_expr_mut(&mut _i . expr);
     // Skipped field _i . paren_token;
 }
 
-pub fn walk_expr_path<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprPath) {
-    if let Some(ref mut it) = _i . qself { _visitor.visit_qself(&mut * it) };
-    _visitor.visit_path(&mut _i . path);
+pub fn visit_expr_path_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprPath) {
+    if let Some(ref mut it) = _i . qself { _visitor.visit_qself_mut(&mut * it) };
+    _visitor.visit_path_mut(&mut _i . path);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_range<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprRange) {
-    if let Some(ref mut it) = _i . from { _visitor.visit_expr(&mut * it) };
-    if let Some(ref mut it) = _i . to { _visitor.visit_expr(&mut * it) };
-    _visitor.visit_range_limits(&mut _i . limits);
+pub fn visit_expr_range_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprRange) {
+    if let Some(ref mut it) = _i . from { _visitor.visit_expr_mut(&mut * it) };
+    if let Some(ref mut it) = _i . to { _visitor.visit_expr_mut(&mut * it) };
+    _visitor.visit_range_limits_mut(&mut _i . limits);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_repeat<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprRepeat) {
+pub fn visit_expr_repeat_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprRepeat) {
     // Skipped field _i . bracket_token;
     // Skipped field _i . semi_token;
-    _visitor.visit_expr(&mut _i . expr);
-    _visitor.visit_expr(&mut _i . amt);
+    _visitor.visit_expr_mut(&mut _i . expr);
+    _visitor.visit_expr_mut(&mut _i . amt);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_ret<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprRet) {
-    if let Some(ref mut it) = _i . expr { _visitor.visit_expr(&mut * it) };
+pub fn visit_expr_ret_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprRet) {
+    if let Some(ref mut it) = _i . expr { _visitor.visit_expr_mut(&mut * it) };
     // Skipped field _i . return_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_struct<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprStruct) {
-    _visitor.visit_path(&mut _i . path);
-    for mut el in (_i . fields).iter_mut() { let mut it = el.item_mut(); _visitor.visit_field_value(&mut it) };
-    if let Some(ref mut it) = _i . rest { _visitor.visit_expr(&mut * it) };
+pub fn visit_expr_struct_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprStruct) {
+    _visitor.visit_path_mut(&mut _i . path);
+    for mut el in (_i . fields).iter_mut() { let mut it = el.item_mut(); _visitor.visit_field_value_mut(&mut it) };
+    if let Some(ref mut it) = _i . rest { _visitor.visit_expr_mut(&mut * it) };
     // Skipped field _i . dot2_token;
     // Skipped field _i . brace_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_try<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprTry) {
-    _visitor.visit_expr(&mut _i . expr);
+pub fn visit_expr_try_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprTry) {
+    _visitor.visit_expr_mut(&mut _i . expr);
     // Skipped field _i . question_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_tup<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprTup) {
-    for mut el in (_i . args).iter_mut() { let mut it = el.item_mut(); _visitor.visit_expr(&mut it) };
+pub fn visit_expr_tup_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprTup) {
+    for mut el in (_i . args).iter_mut() { let mut it = el.item_mut(); _visitor.visit_expr_mut(&mut it) };
     // Skipped field _i . paren_token;
     // Skipped field _i . lone_comma;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_tup_field<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprTupField) {
-    _visitor.visit_expr(&mut _i . expr);
+pub fn visit_expr_tup_field_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprTupField) {
+    _visitor.visit_expr_mut(&mut _i . expr);
     // Skipped field _i . field;
     // Skipped field _i . dot_token;
 }
 
-pub fn walk_expr_type<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprType) {
-    _visitor.visit_expr(&mut _i . expr);
+pub fn visit_expr_type_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprType) {
+    _visitor.visit_expr_mut(&mut _i . expr);
     // Skipped field _i . colon_token;
-    _visitor.visit_ty(&mut _i . ty);
+    _visitor.visit_ty_mut(&mut _i . ty);
 }
 
-pub fn walk_expr_unary<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprUnary) {
-    _visitor.visit_un_op(&mut _i . op);
-    _visitor.visit_expr(&mut _i . expr);
+pub fn visit_expr_unary_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprUnary) {
+    _visitor.visit_un_op_mut(&mut _i . op);
+    _visitor.visit_expr_mut(&mut _i . expr);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_while<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprWhile) {
-    _visitor.visit_expr(&mut _i . cond);
-    _visitor.visit_block(&mut _i . body);
+pub fn visit_expr_while_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprWhile) {
+    _visitor.visit_expr_mut(&mut _i . cond);
+    _visitor.visit_block_mut(&mut _i . body);
     // Skipped field _i . label;
     // Skipped field _i . colon_token;
     // Skipped field _i . while_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_while_let<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprWhileLet) {
-    _visitor.visit_pat(&mut _i . pat);
-    _visitor.visit_expr(&mut _i . expr);
-    _visitor.visit_block(&mut _i . body);
+pub fn visit_expr_while_let_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprWhileLet) {
+    _visitor.visit_pat_mut(&mut _i . pat);
+    _visitor.visit_expr_mut(&mut _i . expr);
+    _visitor.visit_block_mut(&mut _i . body);
     // Skipped field _i . label;
     // Skipped field _i . colon_token;
     // Skipped field _i . while_token;
@@ -1015,172 +1015,172 @@
     // Skipped field _i . eq_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_expr_yield<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprYield) {
+pub fn visit_expr_yield_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ExprYield) {
     // Skipped field _i . yield_token;
-    if let Some(ref mut it) = _i . expr { _visitor.visit_expr(&mut * it) };
+    if let Some(ref mut it) = _i . expr { _visitor.visit_expr_mut(&mut * it) };
 }
 
-pub fn walk_field<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Field) {
+pub fn visit_field_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Field) {
     // Skipped field _i . ident;
-    _visitor.visit_visibility(&mut _i . vis);
-    for mut it in (_i . attrs).iter_mut() { _visitor.visit_attribute(&mut it) };
-    _visitor.visit_ty(&mut _i . ty);
+    _visitor.visit_visibility_mut(&mut _i . vis);
+    for mut it in (_i . attrs).iter_mut() { _visitor.visit_attribute_mut(&mut it) };
+    _visitor.visit_ty_mut(&mut _i . ty);
     // Skipped field _i . colon_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_field_pat<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut FieldPat) {
+pub fn visit_field_pat_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut FieldPat) {
     // Skipped field _i . ident;
-    _visitor.visit_pat(&mut _i . pat);
+    _visitor.visit_pat_mut(&mut _i . pat);
     // Skipped field _i . is_shorthand;
     // Skipped field _i . colon_token;
-    for mut it in (_i . attrs).iter_mut() { _visitor.visit_attribute(&mut it) };
+    for mut it in (_i . attrs).iter_mut() { _visitor.visit_attribute_mut(&mut it) };
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_field_value<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut FieldValue) {
+pub fn visit_field_value_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut FieldValue) {
     // Skipped field _i . ident;
-    _visitor.visit_expr(&mut _i . expr);
+    _visitor.visit_expr_mut(&mut _i . expr);
     // Skipped field _i . is_shorthand;
-    for mut it in (_i . attrs).iter_mut() { _visitor.visit_attribute(&mut it) };
+    for mut it in (_i . attrs).iter_mut() { _visitor.visit_attribute_mut(&mut it) };
     // Skipped field _i . colon_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_file<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut File) {
+pub fn visit_file_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut File) {
     // Skipped field _i . shebang;
-    for mut it in (_i . attrs).iter_mut() { _visitor.visit_attribute(&mut it) };
-    for mut it in (_i . items).iter_mut() { _visitor.visit_item(&mut it) };
+    for mut it in (_i . attrs).iter_mut() { _visitor.visit_attribute_mut(&mut it) };
+    for mut it in (_i . items).iter_mut() { _visitor.visit_item_mut(&mut it) };
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_fn_arg<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut FnArg) {
+pub fn visit_fn_arg_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut FnArg) {
     use ::FnArg::*;
     match *_i {
         SelfRef(ref mut _binding_0, ) => {
-            _visitor.visit_arg_self_ref(&mut * _binding_0);
+            _visitor.visit_arg_self_ref_mut(&mut * _binding_0);
         }
         SelfValue(ref mut _binding_0, ) => {
-            _visitor.visit_arg_self(&mut * _binding_0);
+            _visitor.visit_arg_self_mut(&mut * _binding_0);
         }
         Captured(ref mut _binding_0, ) => {
-            _visitor.visit_arg_captured(&mut * _binding_0);
+            _visitor.visit_arg_captured_mut(&mut * _binding_0);
         }
         Ignored(ref mut _binding_0, ) => {
-            _visitor.visit_ty(&mut * _binding_0);
+            _visitor.visit_ty_mut(&mut * _binding_0);
         }
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_fn_decl<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut FnDecl) {
+pub fn visit_fn_decl_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut FnDecl) {
     // Skipped field _i . fn_token;
     // Skipped field _i . paren_token;
-    for mut el in (_i . inputs).iter_mut() { let mut it = el.item_mut(); _visitor.visit_fn_arg(&mut it) };
-    _visitor.visit_function_ret_ty(&mut _i . output);
-    _visitor.visit_generics(&mut _i . generics);
+    for mut el in (_i . inputs).iter_mut() { let mut it = el.item_mut(); _visitor.visit_fn_arg_mut(&mut it) };
+    _visitor.visit_function_ret_ty_mut(&mut _i . output);
+    _visitor.visit_generics_mut(&mut _i . generics);
     // Skipped field _i . variadic;
     // Skipped field _i . dot_tokens;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_foreign_item<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ForeignItem) {
+pub fn visit_foreign_item_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ForeignItem) {
     // Skipped field _i . ident;
-    for mut it in (_i . attrs).iter_mut() { _visitor.visit_attribute(&mut it) };
-    _visitor.visit_foreign_item_kind(&mut _i . node);
-    _visitor.visit_visibility(&mut _i . vis);
+    for mut it in (_i . attrs).iter_mut() { _visitor.visit_attribute_mut(&mut it) };
+    _visitor.visit_foreign_item_kind_mut(&mut _i . node);
+    _visitor.visit_visibility_mut(&mut _i . vis);
     // Skipped field _i . semi_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_foreign_item_fn<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ForeignItemFn) {
-    _visitor.visit_fn_decl(&mut _i . decl);
+pub fn visit_foreign_item_fn_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ForeignItemFn) {
+    _visitor.visit_fn_decl_mut(&mut _i . decl);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_foreign_item_kind<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ForeignItemKind) {
+pub fn visit_foreign_item_kind_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ForeignItemKind) {
     use ::ForeignItemKind::*;
     match *_i {
         Fn(ref mut _binding_0, ) => {
-            _visitor.visit_foreign_item_fn(&mut * _binding_0);
+            _visitor.visit_foreign_item_fn_mut(&mut * _binding_0);
         }
         Static(ref mut _binding_0, ) => {
-            _visitor.visit_foreign_item_static(&mut * _binding_0);
+            _visitor.visit_foreign_item_static_mut(&mut * _binding_0);
         }
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_foreign_item_static<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ForeignItemStatic) {
+pub fn visit_foreign_item_static_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ForeignItemStatic) {
     // Skipped field _i . static_token;
-    _visitor.visit_ty(&mut _i . ty);
+    _visitor.visit_ty_mut(&mut _i . ty);
     // Skipped field _i . colon_token;
-    _visitor.visit_mutability(&mut _i . mutbl);
+    _visitor.visit_mutability_mut(&mut _i . mutbl);
 }
 
-pub fn walk_function_ret_ty<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut FunctionRetTy) {
+pub fn visit_function_ret_ty_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut FunctionRetTy) {
     use ::FunctionRetTy::*;
     match *_i {
         Default => { }
         Ty(ref mut _binding_0, ref mut _binding_1, ) => {
-            _visitor.visit_ty(&mut * _binding_0);
+            _visitor.visit_ty_mut(&mut * _binding_0);
             // Skipped field * _binding_1;
         }
     }
 }
 
-pub fn walk_generics<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Generics) {
+pub fn visit_generics_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Generics) {
     // Skipped field _i . lt_token;
     // Skipped field _i . gt_token;
-    for mut el in (_i . lifetimes).iter_mut() { let mut it = el.item_mut(); _visitor.visit_lifetime_def(&mut it) };
-    for mut el in (_i . ty_params).iter_mut() { let mut it = el.item_mut(); _visitor.visit_ty_param(&mut it) };
-    _visitor.visit_where_clause(&mut _i . where_clause);
+    for mut el in (_i . lifetimes).iter_mut() { let mut it = el.item_mut(); _visitor.visit_lifetime_def_mut(&mut it) };
+    for mut el in (_i . ty_params).iter_mut() { let mut it = el.item_mut(); _visitor.visit_ty_param_mut(&mut it) };
+    _visitor.visit_where_clause_mut(&mut _i . where_clause);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_impl_item<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ImplItem) {
-    for mut it in (_i . attrs).iter_mut() { _visitor.visit_attribute(&mut it) };
-    _visitor.visit_impl_item_kind(&mut _i . node);
+pub fn visit_impl_item_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ImplItem) {
+    for mut it in (_i . attrs).iter_mut() { _visitor.visit_attribute_mut(&mut it) };
+    _visitor.visit_impl_item_kind_mut(&mut _i . node);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_impl_item_const<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ImplItemConst) {
-    _visitor.visit_visibility(&mut _i . vis);
-    _visitor.visit_defaultness(&mut _i . defaultness);
+pub fn visit_impl_item_const_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ImplItemConst) {
+    _visitor.visit_visibility_mut(&mut _i . vis);
+    _visitor.visit_defaultness_mut(&mut _i . defaultness);
     // Skipped field _i . const_token;
     // Skipped field _i . ident;
     // Skipped field _i . colon_token;
-    _visitor.visit_ty(&mut _i . ty);
+    _visitor.visit_ty_mut(&mut _i . ty);
     // Skipped field _i . eq_token;
-    _visitor.visit_expr(&mut _i . expr);
+    _visitor.visit_expr_mut(&mut _i . expr);
     // Skipped field _i . semi_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_impl_item_kind<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ImplItemKind) {
+pub fn visit_impl_item_kind_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ImplItemKind) {
     use ::ImplItemKind::*;
     match *_i {
         Const(ref mut _binding_0, ) => {
-            _visitor.visit_impl_item_const(&mut * _binding_0);
+            _visitor.visit_impl_item_const_mut(&mut * _binding_0);
         }
         Method(ref mut _binding_0, ) => {
-            _visitor.visit_impl_item_method(&mut * _binding_0);
+            _visitor.visit_impl_item_method_mut(&mut * _binding_0);
         }
         Type(ref mut _binding_0, ) => {
-            _visitor.visit_impl_item_type(&mut * _binding_0);
+            _visitor.visit_impl_item_type_mut(&mut * _binding_0);
         }
         Macro(ref mut _binding_0, ) => {
-            _visitor.visit_mac(&mut * _binding_0);
+            _visitor.visit_mac_mut(&mut * _binding_0);
         }
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_impl_item_method<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ImplItemMethod) {
-    _visitor.visit_visibility(&mut _i . vis);
-    _visitor.visit_defaultness(&mut _i . defaultness);
-    _visitor.visit_method_sig(&mut _i . sig);
-    _visitor.visit_block(&mut _i . block);
+pub fn visit_impl_item_method_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ImplItemMethod) {
+    _visitor.visit_visibility_mut(&mut _i . vis);
+    _visitor.visit_defaultness_mut(&mut _i . defaultness);
+    _visitor.visit_method_sig_mut(&mut _i . sig);
+    _visitor.visit_block_mut(&mut _i . block);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_impl_item_type<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ImplItemType) {
-    _visitor.visit_visibility(&mut _i . vis);
-    _visitor.visit_defaultness(&mut _i . defaultness);
+pub fn visit_impl_item_type_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ImplItemType) {
+    _visitor.visit_visibility_mut(&mut _i . vis);
+    _visitor.visit_defaultness_mut(&mut _i . defaultness);
     // Skipped field _i . type_token;
     // Skipped field _i . ident;
     // Skipped field _i . eq_token;
-    _visitor.visit_ty(&mut _i . ty);
+    _visitor.visit_ty_mut(&mut _i . ty);
     // Skipped field _i . semi_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_impl_polarity<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ImplPolarity) {
+pub fn visit_impl_polarity_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ImplPolarity) {
     use ::ImplPolarity::*;
     match *_i {
         Positive => { }
@@ -1190,7 +1190,7 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_in_place_kind<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut InPlaceKind) {
+pub fn visit_in_place_kind_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut InPlaceKind) {
     use ::InPlaceKind::*;
     match *_i {
         Arrow(ref mut _binding_0, ) => {
@@ -1202,42 +1202,42 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Item) {
-    for mut it in (_i . attrs).iter_mut() { _visitor.visit_attribute(&mut it) };
-    _visitor.visit_item_kind(&mut _i . node);
+pub fn visit_item_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Item) {
+    for mut it in (_i . attrs).iter_mut() { _visitor.visit_attribute_mut(&mut it) };
+    _visitor.visit_item_kind_mut(&mut _i . node);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_const<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ItemConst) {
-    _visitor.visit_visibility(&mut _i . vis);
+pub fn visit_item_const_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ItemConst) {
+    _visitor.visit_visibility_mut(&mut _i . vis);
     // Skipped field _i . const_token;
     // Skipped field _i . ident;
     // Skipped field _i . colon_token;
-    _visitor.visit_ty(&mut _i . ty);
+    _visitor.visit_ty_mut(&mut _i . ty);
     // Skipped field _i . eq_token;
-    _visitor.visit_expr(&mut _i . expr);
+    _visitor.visit_expr_mut(&mut _i . expr);
     // Skipped field _i . semi_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_default_impl<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ItemDefaultImpl) {
-    _visitor.visit_unsafety(&mut _i . unsafety);
+pub fn visit_item_default_impl_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ItemDefaultImpl) {
+    _visitor.visit_unsafety_mut(&mut _i . unsafety);
     // Skipped field _i . impl_token;
-    _visitor.visit_path(&mut _i . path);
+    _visitor.visit_path_mut(&mut _i . path);
     // Skipped field _i . for_token;
     // Skipped field _i . dot2_token;
     // Skipped field _i . brace_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_enum<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ItemEnum) {
-    _visitor.visit_visibility(&mut _i . vis);
+pub fn visit_item_enum_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ItemEnum) {
+    _visitor.visit_visibility_mut(&mut _i . vis);
     // Skipped field _i . enum_token;
     // Skipped field _i . ident;
-    _visitor.visit_generics(&mut _i . generics);
+    _visitor.visit_generics_mut(&mut _i . generics);
     // Skipped field _i . brace_token;
-    for mut el in (_i . variants).iter_mut() { let mut it = el.item_mut(); _visitor.visit_variant(&mut it) };
+    for mut el in (_i . variants).iter_mut() { let mut it = el.item_mut(); _visitor.visit_variant_mut(&mut it) };
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_extern_crate<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ItemExternCrate) {
-    _visitor.visit_visibility(&mut _i . vis);
+pub fn visit_item_extern_crate_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ItemExternCrate) {
+    _visitor.visit_visibility_mut(&mut _i . vis);
     // Skipped field _i . extern_token;
     // Skipped field _i . crate_token;
     // Skipped field _i . ident;
@@ -1245,176 +1245,176 @@
     // Skipped field _i . semi_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_fn<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ItemFn) {
-    _visitor.visit_visibility(&mut _i . vis);
-    _visitor.visit_constness(&mut _i . constness);
-    _visitor.visit_unsafety(&mut _i . unsafety);
-    if let Some(ref mut it) = _i . abi { _visitor.visit_abi(&mut * it) };
-    _visitor.visit_fn_decl(&mut _i . decl);
+pub fn visit_item_fn_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ItemFn) {
+    _visitor.visit_visibility_mut(&mut _i . vis);
+    _visitor.visit_constness_mut(&mut _i . constness);
+    _visitor.visit_unsafety_mut(&mut _i . unsafety);
+    if let Some(ref mut it) = _i . abi { _visitor.visit_abi_mut(&mut * it) };
+    _visitor.visit_fn_decl_mut(&mut _i . decl);
     // Skipped field _i . ident;
-    _visitor.visit_block(&mut _i . block);
+    _visitor.visit_block_mut(&mut _i . block);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_foreign_mod<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ItemForeignMod) {
-    _visitor.visit_abi(&mut _i . abi);
+pub fn visit_item_foreign_mod_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ItemForeignMod) {
+    _visitor.visit_abi_mut(&mut _i . abi);
     // Skipped field _i . brace_token;
-    for mut it in (_i . items).iter_mut() { _visitor.visit_foreign_item(&mut it) };
+    for mut it in (_i . items).iter_mut() { _visitor.visit_foreign_item_mut(&mut it) };
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_impl<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ItemImpl) {
-    _visitor.visit_defaultness(&mut _i . defaultness);
-    _visitor.visit_unsafety(&mut _i . unsafety);
+pub fn visit_item_impl_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ItemImpl) {
+    _visitor.visit_defaultness_mut(&mut _i . defaultness);
+    _visitor.visit_unsafety_mut(&mut _i . unsafety);
     // Skipped field _i . impl_token;
-    _visitor.visit_generics(&mut _i . generics);
+    _visitor.visit_generics_mut(&mut _i . generics);
     // Skipped field _i . trait_;
-    _visitor.visit_ty(&mut _i . self_ty);
+    _visitor.visit_ty_mut(&mut _i . self_ty);
     // Skipped field _i . brace_token;
-    for mut it in (_i . items).iter_mut() { _visitor.visit_impl_item(&mut it) };
+    for mut it in (_i . items).iter_mut() { _visitor.visit_impl_item_mut(&mut it) };
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_kind<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ItemKind) {
+pub fn visit_item_kind_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ItemKind) {
     use ::ItemKind::*;
     match *_i {
         ExternCrate(ref mut _binding_0, ) => {
-            _visitor.visit_item_extern_crate(&mut * _binding_0);
+            _visitor.visit_item_extern_crate_mut(&mut * _binding_0);
         }
         Use(ref mut _binding_0, ) => {
-            _visitor.visit_item_use(&mut * _binding_0);
+            _visitor.visit_item_use_mut(&mut * _binding_0);
         }
         Static(ref mut _binding_0, ) => {
-            _visitor.visit_item_static(&mut * _binding_0);
+            _visitor.visit_item_static_mut(&mut * _binding_0);
         }
         Const(ref mut _binding_0, ) => {
-            _visitor.visit_item_const(&mut * _binding_0);
+            _visitor.visit_item_const_mut(&mut * _binding_0);
         }
         Fn(ref mut _binding_0, ) => {
-            _visitor.visit_item_fn(&mut * _binding_0);
+            _visitor.visit_item_fn_mut(&mut * _binding_0);
         }
         Mod(ref mut _binding_0, ) => {
-            _visitor.visit_item_mod(&mut * _binding_0);
+            _visitor.visit_item_mod_mut(&mut * _binding_0);
         }
         ForeignMod(ref mut _binding_0, ) => {
-            _visitor.visit_item_foreign_mod(&mut * _binding_0);
+            _visitor.visit_item_foreign_mod_mut(&mut * _binding_0);
         }
         Ty(ref mut _binding_0, ) => {
-            _visitor.visit_item_ty(&mut * _binding_0);
+            _visitor.visit_item_ty_mut(&mut * _binding_0);
         }
         Enum(ref mut _binding_0, ) => {
-            _visitor.visit_item_enum(&mut * _binding_0);
+            _visitor.visit_item_enum_mut(&mut * _binding_0);
         }
         Struct(ref mut _binding_0, ) => {
-            _visitor.visit_item_struct(&mut * _binding_0);
+            _visitor.visit_item_struct_mut(&mut * _binding_0);
         }
         Union(ref mut _binding_0, ) => {
-            _visitor.visit_item_union(&mut * _binding_0);
+            _visitor.visit_item_union_mut(&mut * _binding_0);
         }
         Trait(ref mut _binding_0, ) => {
-            _visitor.visit_item_trait(&mut * _binding_0);
+            _visitor.visit_item_trait_mut(&mut * _binding_0);
         }
         DefaultImpl(ref mut _binding_0, ) => {
-            _visitor.visit_item_default_impl(&mut * _binding_0);
+            _visitor.visit_item_default_impl_mut(&mut * _binding_0);
         }
         Impl(ref mut _binding_0, ) => {
-            _visitor.visit_item_impl(&mut * _binding_0);
+            _visitor.visit_item_impl_mut(&mut * _binding_0);
         }
         Mac(ref mut _binding_0, ) => {
-            _visitor.visit_mac(&mut * _binding_0);
+            _visitor.visit_mac_mut(&mut * _binding_0);
         }
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_mod<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ItemMod) {
-    _visitor.visit_visibility(&mut _i . vis);
+pub fn visit_item_mod_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ItemMod) {
+    _visitor.visit_visibility_mut(&mut _i . vis);
     // Skipped field _i . mod_token;
     // Skipped field _i . ident;
     // Skipped field _i . content;
     // Skipped field _i . semi;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_static<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ItemStatic) {
-    _visitor.visit_visibility(&mut _i . vis);
+pub fn visit_item_static_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ItemStatic) {
+    _visitor.visit_visibility_mut(&mut _i . vis);
     // Skipped field _i . static_token;
-    _visitor.visit_mutability(&mut _i . mutbl);
+    _visitor.visit_mutability_mut(&mut _i . mutbl);
     // Skipped field _i . ident;
     // Skipped field _i . colon_token;
-    _visitor.visit_ty(&mut _i . ty);
+    _visitor.visit_ty_mut(&mut _i . ty);
     // Skipped field _i . eq_token;
-    _visitor.visit_expr(&mut _i . expr);
+    _visitor.visit_expr_mut(&mut _i . expr);
     // Skipped field _i . semi_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_struct<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ItemStruct) {
-    _visitor.visit_visibility(&mut _i . vis);
+pub fn visit_item_struct_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ItemStruct) {
+    _visitor.visit_visibility_mut(&mut _i . vis);
     // Skipped field _i . struct_token;
     // Skipped field _i . ident;
-    _visitor.visit_generics(&mut _i . generics);
-    _visitor.visit_variant_data(&mut _i . data);
+    _visitor.visit_generics_mut(&mut _i . generics);
+    _visitor.visit_variant_data_mut(&mut _i . data);
     // Skipped field _i . semi_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_trait<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ItemTrait) {
-    _visitor.visit_visibility(&mut _i . vis);
-    _visitor.visit_unsafety(&mut _i . unsafety);
+pub fn visit_item_trait_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ItemTrait) {
+    _visitor.visit_visibility_mut(&mut _i . vis);
+    _visitor.visit_unsafety_mut(&mut _i . unsafety);
     // Skipped field _i . trait_token;
     // Skipped field _i . ident;
-    _visitor.visit_generics(&mut _i . generics);
+    _visitor.visit_generics_mut(&mut _i . generics);
     // Skipped field _i . colon_token;
-    for mut el in (_i . supertraits).iter_mut() { let mut it = el.item_mut(); _visitor.visit_ty_param_bound(&mut it) };
+    for mut el in (_i . supertraits).iter_mut() { let mut it = el.item_mut(); _visitor.visit_ty_param_bound_mut(&mut it) };
     // Skipped field _i . brace_token;
-    for mut it in (_i . items).iter_mut() { _visitor.visit_trait_item(&mut it) };
+    for mut it in (_i . items).iter_mut() { _visitor.visit_trait_item_mut(&mut it) };
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_ty<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ItemTy) {
-    _visitor.visit_visibility(&mut _i . vis);
+pub fn visit_item_ty_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ItemTy) {
+    _visitor.visit_visibility_mut(&mut _i . vis);
     // Skipped field _i . type_token;
     // Skipped field _i . ident;
-    _visitor.visit_generics(&mut _i . generics);
+    _visitor.visit_generics_mut(&mut _i . generics);
     // Skipped field _i . eq_token;
-    _visitor.visit_ty(&mut _i . ty);
+    _visitor.visit_ty_mut(&mut _i . ty);
     // Skipped field _i . semi_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_union<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ItemUnion) {
-    _visitor.visit_visibility(&mut _i . vis);
+pub fn visit_item_union_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ItemUnion) {
+    _visitor.visit_visibility_mut(&mut _i . vis);
     // Skipped field _i . union_token;
     // Skipped field _i . ident;
-    _visitor.visit_generics(&mut _i . generics);
-    _visitor.visit_variant_data(&mut _i . data);
+    _visitor.visit_generics_mut(&mut _i . generics);
+    _visitor.visit_variant_data_mut(&mut _i . data);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_item_use<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ItemUse) {
-    _visitor.visit_visibility(&mut _i . vis);
+pub fn visit_item_use_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ItemUse) {
+    _visitor.visit_visibility_mut(&mut _i . vis);
     // Skipped field _i . use_token;
-    _visitor.visit_view_path(&mut _i . path);
+    _visitor.visit_view_path_mut(&mut _i . path);
     // Skipped field _i . semi_token;
 }
 
-pub fn walk_lifetime_def<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut LifetimeDef) {
-    for mut it in (_i . attrs).iter_mut() { _visitor.visit_attribute(&mut it) };
+pub fn visit_lifetime_def_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut LifetimeDef) {
+    for mut it in (_i . attrs).iter_mut() { _visitor.visit_attribute_mut(&mut it) };
     // Skipped field _i . lifetime;
     // Skipped field _i . colon_token;
     // Skipped field _i . bounds;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_local<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Local) {
+pub fn visit_local_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Local) {
     // Skipped field _i . let_token;
     // Skipped field _i . colon_token;
     // Skipped field _i . eq_token;
     // Skipped field _i . semi_token;
-    _visitor.visit_pat(&mut _i . pat);
-    if let Some(ref mut it) = _i . ty { _visitor.visit_ty(&mut * it) };
-    if let Some(ref mut it) = _i . init { _visitor.visit_expr(&mut * it) };
-    for mut it in (_i . attrs).iter_mut() { _visitor.visit_attribute(&mut it) };
+    _visitor.visit_pat_mut(&mut _i . pat);
+    if let Some(ref mut it) = _i . ty { _visitor.visit_ty_mut(&mut * it) };
+    if let Some(ref mut it) = _i . init { _visitor.visit_expr_mut(&mut * it) };
+    for mut it in (_i . attrs).iter_mut() { _visitor.visit_attribute_mut(&mut it) };
 }
 
-pub fn walk_mac<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Mac) {
-    _visitor.visit_path(&mut _i . path);
+pub fn visit_mac_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Mac) {
+    _visitor.visit_path_mut(&mut _i . path);
     // Skipped field _i . bang_token;
     // Skipped field _i . ident;
     // Skipped field _i . tokens;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_mac_stmt_style<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut MacStmtStyle) {
+pub fn visit_mac_stmt_style_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut MacStmtStyle) {
     use ::MacStmtStyle::*;
     match *_i {
         Semicolon(ref mut _binding_0, ) => {
@@ -1425,47 +1425,47 @@
     }
 }
 
-pub fn walk_meta_item<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut MetaItem) {
+pub fn visit_meta_item_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut MetaItem) {
     use ::MetaItem::*;
     match *_i {
         Term(ref mut _binding_0, ) => {
             // Skipped field * _binding_0;
         }
         List(ref mut _binding_0, ) => {
-            _visitor.visit_meta_item_list(&mut * _binding_0);
+            _visitor.visit_meta_item_list_mut(&mut * _binding_0);
         }
         NameValue(ref mut _binding_0, ) => {
-            _visitor.visit_meta_name_value(&mut * _binding_0);
+            _visitor.visit_meta_name_value_mut(&mut * _binding_0);
         }
     }
 }
 
-pub fn walk_meta_item_list<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut MetaItemList) {
+pub fn visit_meta_item_list_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut MetaItemList) {
     // Skipped field _i . ident;
     // Skipped field _i . paren_token;
-    for mut el in (_i . nested).iter_mut() { let mut it = el.item_mut(); _visitor.visit_nested_meta_item(&mut it) };
+    for mut el in (_i . nested).iter_mut() { let mut it = el.item_mut(); _visitor.visit_nested_meta_item_mut(&mut it) };
 }
 
-pub fn walk_meta_name_value<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut MetaNameValue) {
+pub fn visit_meta_name_value_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut MetaNameValue) {
     // Skipped field _i . ident;
     // Skipped field _i . eq_token;
     // Skipped field _i . lit;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_method_sig<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut MethodSig) {
-    _visitor.visit_constness(&mut _i . constness);
-    _visitor.visit_unsafety(&mut _i . unsafety);
-    if let Some(ref mut it) = _i . abi { _visitor.visit_abi(&mut * it) };
+pub fn visit_method_sig_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut MethodSig) {
+    _visitor.visit_constness_mut(&mut _i . constness);
+    _visitor.visit_unsafety_mut(&mut _i . unsafety);
+    if let Some(ref mut it) = _i . abi { _visitor.visit_abi_mut(&mut * it) };
     // Skipped field _i . ident;
-    _visitor.visit_fn_decl(&mut _i . decl);
+    _visitor.visit_fn_decl_mut(&mut _i . decl);
 }
 
-pub fn walk_mut_ty<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut MutTy) {
-    _visitor.visit_ty(&mut _i . ty);
-    _visitor.visit_mutability(&mut _i . mutability);
+pub fn visit_mut_ty_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut MutTy) {
+    _visitor.visit_ty_mut(&mut _i . ty);
+    _visitor.visit_mutability_mut(&mut _i . mutability);
 }
 
-pub fn walk_mutability<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Mutability) {
+pub fn visit_mutability_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Mutability) {
     use ::Mutability::*;
     match *_i {
         Mutable(ref mut _binding_0, ) => {
@@ -1475,11 +1475,11 @@
     }
 }
 
-pub fn walk_nested_meta_item<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut NestedMetaItem) {
+pub fn visit_nested_meta_item_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut NestedMetaItem) {
     use ::NestedMetaItem::*;
     match *_i {
         MetaItem(ref mut _binding_0, ) => {
-            _visitor.visit_meta_item(&mut * _binding_0);
+            _visitor.visit_meta_item_mut(&mut * _binding_0);
         }
         Literal(ref mut _binding_0, ) => {
             // Skipped field * _binding_0;
@@ -1487,182 +1487,182 @@
     }
 }
 
-pub fn walk_parenthesized_parameter_data<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ParenthesizedParameterData) {
+pub fn visit_parenthesized_parameter_data_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ParenthesizedParameterData) {
     // Skipped field _i . paren_token;
-    for mut el in (_i . inputs).iter_mut() { let mut it = el.item_mut(); _visitor.visit_ty(&mut it) };
-    _visitor.visit_function_ret_ty(&mut _i . output);
+    for mut el in (_i . inputs).iter_mut() { let mut it = el.item_mut(); _visitor.visit_ty_mut(&mut it) };
+    _visitor.visit_function_ret_ty_mut(&mut _i . output);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Pat) {
+pub fn visit_pat_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Pat) {
     use ::Pat::*;
     match *_i {
         Wild(ref mut _binding_0, ) => {
-            _visitor.visit_pat_wild(&mut * _binding_0);
+            _visitor.visit_pat_wild_mut(&mut * _binding_0);
         }
         Ident(ref mut _binding_0, ) => {
-            _visitor.visit_pat_ident(&mut * _binding_0);
+            _visitor.visit_pat_ident_mut(&mut * _binding_0);
         }
         Struct(ref mut _binding_0, ) => {
-            _visitor.visit_pat_struct(&mut * _binding_0);
+            _visitor.visit_pat_struct_mut(&mut * _binding_0);
         }
         TupleStruct(ref mut _binding_0, ) => {
-            _visitor.visit_pat_tuple_struct(&mut * _binding_0);
+            _visitor.visit_pat_tuple_struct_mut(&mut * _binding_0);
         }
         Path(ref mut _binding_0, ) => {
-            _visitor.visit_pat_path(&mut * _binding_0);
+            _visitor.visit_pat_path_mut(&mut * _binding_0);
         }
         Tuple(ref mut _binding_0, ) => {
-            _visitor.visit_pat_tuple(&mut * _binding_0);
+            _visitor.visit_pat_tuple_mut(&mut * _binding_0);
         }
         Box(ref mut _binding_0, ) => {
-            _visitor.visit_pat_box(&mut * _binding_0);
+            _visitor.visit_pat_box_mut(&mut * _binding_0);
         }
         Ref(ref mut _binding_0, ) => {
-            _visitor.visit_pat_ref(&mut * _binding_0);
+            _visitor.visit_pat_ref_mut(&mut * _binding_0);
         }
         Lit(ref mut _binding_0, ) => {
-            _visitor.visit_pat_lit(&mut * _binding_0);
+            _visitor.visit_pat_lit_mut(&mut * _binding_0);
         }
         Range(ref mut _binding_0, ) => {
-            _visitor.visit_pat_range(&mut * _binding_0);
+            _visitor.visit_pat_range_mut(&mut * _binding_0);
         }
         Slice(ref mut _binding_0, ) => {
-            _visitor.visit_pat_slice(&mut * _binding_0);
+            _visitor.visit_pat_slice_mut(&mut * _binding_0);
         }
         Mac(ref mut _binding_0, ) => {
-            _visitor.visit_mac(&mut * _binding_0);
+            _visitor.visit_mac_mut(&mut * _binding_0);
         }
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat_box<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatBox) {
-    _visitor.visit_pat(&mut _i . pat);
+pub fn visit_pat_box_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatBox) {
+    _visitor.visit_pat_mut(&mut _i . pat);
     // Skipped field _i . box_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat_ident<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatIdent) {
-    _visitor.visit_binding_mode(&mut _i . mode);
+pub fn visit_pat_ident_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatIdent) {
+    _visitor.visit_binding_mode_mut(&mut _i . mode);
     // Skipped field _i . ident;
-    if let Some(ref mut it) = _i . subpat { _visitor.visit_pat(&mut * it) };
+    if let Some(ref mut it) = _i . subpat { _visitor.visit_pat_mut(&mut * it) };
     // Skipped field _i . at_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat_lit<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatLit) {
-    _visitor.visit_expr(&mut _i . expr);
+pub fn visit_pat_lit_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatLit) {
+    _visitor.visit_expr_mut(&mut _i . expr);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat_path<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatPath) {
-    if let Some(ref mut it) = _i . qself { _visitor.visit_qself(&mut * it) };
-    _visitor.visit_path(&mut _i . path);
+pub fn visit_pat_path_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatPath) {
+    if let Some(ref mut it) = _i . qself { _visitor.visit_qself_mut(&mut * it) };
+    _visitor.visit_path_mut(&mut _i . path);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat_range<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatRange) {
-    _visitor.visit_expr(&mut _i . lo);
-    _visitor.visit_expr(&mut _i . hi);
-    _visitor.visit_range_limits(&mut _i . limits);
+pub fn visit_pat_range_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatRange) {
+    _visitor.visit_expr_mut(&mut _i . lo);
+    _visitor.visit_expr_mut(&mut _i . hi);
+    _visitor.visit_range_limits_mut(&mut _i . limits);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat_ref<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatRef) {
-    _visitor.visit_pat(&mut _i . pat);
-    _visitor.visit_mutability(&mut _i . mutbl);
+pub fn visit_pat_ref_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatRef) {
+    _visitor.visit_pat_mut(&mut _i . pat);
+    _visitor.visit_mutability_mut(&mut _i . mutbl);
     // Skipped field _i . and_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat_slice<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatSlice) {
-    for mut el in (_i . front).iter_mut() { let mut it = el.item_mut(); _visitor.visit_pat(&mut it) };
-    if let Some(ref mut it) = _i . middle { _visitor.visit_pat(&mut * it) };
-    for mut el in (_i . back).iter_mut() { let mut it = el.item_mut(); _visitor.visit_pat(&mut it) };
+pub fn visit_pat_slice_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatSlice) {
+    for mut el in (_i . front).iter_mut() { let mut it = el.item_mut(); _visitor.visit_pat_mut(&mut it) };
+    if let Some(ref mut it) = _i . middle { _visitor.visit_pat_mut(&mut * it) };
+    for mut el in (_i . back).iter_mut() { let mut it = el.item_mut(); _visitor.visit_pat_mut(&mut it) };
     // Skipped field _i . dot2_token;
     // Skipped field _i . comma_token;
     // Skipped field _i . bracket_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat_struct<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatStruct) {
-    _visitor.visit_path(&mut _i . path);
-    for mut el in (_i . fields).iter_mut() { let mut it = el.item_mut(); _visitor.visit_field_pat(&mut it) };
+pub fn visit_pat_struct_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatStruct) {
+    _visitor.visit_path_mut(&mut _i . path);
+    for mut el in (_i . fields).iter_mut() { let mut it = el.item_mut(); _visitor.visit_field_pat_mut(&mut it) };
     // Skipped field _i . brace_token;
     // Skipped field _i . dot2_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat_tuple<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatTuple) {
-    for mut el in (_i . pats).iter_mut() { let mut it = el.item_mut(); _visitor.visit_pat(&mut it) };
+pub fn visit_pat_tuple_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatTuple) {
+    for mut el in (_i . pats).iter_mut() { let mut it = el.item_mut(); _visitor.visit_pat_mut(&mut it) };
     // Skipped field _i . dots_pos;
     // Skipped field _i . paren_token;
     // Skipped field _i . dot2_token;
     // Skipped field _i . comma_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat_tuple_struct<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatTupleStruct) {
-    _visitor.visit_path(&mut _i . path);
-    _visitor.visit_pat_tuple(&mut _i . pat);
+pub fn visit_pat_tuple_struct_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatTupleStruct) {
+    _visitor.visit_path_mut(&mut _i . path);
+    _visitor.visit_pat_tuple_mut(&mut _i . pat);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_pat_wild<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatWild) {
+pub fn visit_pat_wild_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PatWild) {
     // Skipped field _i . underscore_token;
 }
 
-pub fn walk_path<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Path) {
+pub fn visit_path_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Path) {
     // Skipped field _i . leading_colon;
-    for mut el in (_i . segments).iter_mut() { let mut it = el.item_mut(); _visitor.visit_path_segment(&mut it) };
+    for mut el in (_i . segments).iter_mut() { let mut it = el.item_mut(); _visitor.visit_path_segment_mut(&mut it) };
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_path_glob<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PathGlob) {
-    _visitor.visit_path(&mut _i . path);
+pub fn visit_path_glob_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PathGlob) {
+    _visitor.visit_path_mut(&mut _i . path);
     // Skipped field _i . colon2_token;
     // Skipped field _i . star_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_path_list<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PathList) {
-    _visitor.visit_path(&mut _i . path);
+pub fn visit_path_list_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PathList) {
+    _visitor.visit_path_mut(&mut _i . path);
     // Skipped field _i . colon2_token;
     // Skipped field _i . brace_token;
-    for mut el in (_i . items).iter_mut() { let mut it = el.item_mut(); _visitor.visit_path_list_item(&mut it) };
+    for mut el in (_i . items).iter_mut() { let mut it = el.item_mut(); _visitor.visit_path_list_item_mut(&mut it) };
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_path_list_item<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PathListItem) {
+pub fn visit_path_list_item_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PathListItem) {
     // Skipped field _i . name;
     // Skipped field _i . rename;
     // Skipped field _i . as_token;
 }
 
-pub fn walk_path_parameters<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PathParameters) {
+pub fn visit_path_parameters_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PathParameters) {
     use ::PathParameters::*;
     match *_i {
         None => { }
         AngleBracketed(ref mut _binding_0, ) => {
-            _visitor.visit_angle_bracketed_parameter_data(&mut * _binding_0);
+            _visitor.visit_angle_bracketed_parameter_data_mut(&mut * _binding_0);
         }
         Parenthesized(ref mut _binding_0, ) => {
-            _visitor.visit_parenthesized_parameter_data(&mut * _binding_0);
+            _visitor.visit_parenthesized_parameter_data_mut(&mut * _binding_0);
         }
     }
 }
 
-pub fn walk_path_segment<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PathSegment) {
+pub fn visit_path_segment_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PathSegment) {
     // Skipped field _i . ident;
-    _visitor.visit_path_parameters(&mut _i . parameters);
+    _visitor.visit_path_parameters_mut(&mut _i . parameters);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_path_simple<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PathSimple) {
-    _visitor.visit_path(&mut _i . path);
+pub fn visit_path_simple_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PathSimple) {
+    _visitor.visit_path_mut(&mut _i . path);
     // Skipped field _i . as_token;
     // Skipped field _i . rename;
 }
 
-pub fn walk_poly_trait_ref<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PolyTraitRef) {
-    if let Some(ref mut it) = _i . bound_lifetimes { _visitor.visit_bound_lifetimes(&mut * it) };
-    _visitor.visit_path(&mut _i . trait_ref);
+pub fn visit_poly_trait_ref_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut PolyTraitRef) {
+    if let Some(ref mut it) = _i . bound_lifetimes { _visitor.visit_bound_lifetimes_mut(&mut * it) };
+    _visitor.visit_path_mut(&mut _i . trait_ref);
 }
 
-pub fn walk_qself<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut QSelf) {
+pub fn visit_qself_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut QSelf) {
     // Skipped field _i . lt_token;
-    _visitor.visit_ty(&mut _i . ty);
+    _visitor.visit_ty_mut(&mut _i . ty);
     // Skipped field _i . position;
     // Skipped field _i . as_token;
     // Skipped field _i . gt_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_range_limits<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut RangeLimits) {
+pub fn visit_range_limits_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut RangeLimits) {
     use ::RangeLimits::*;
     match *_i {
         HalfOpen(ref mut _binding_0, ) => {
@@ -1674,20 +1674,20 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_stmt<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Stmt) {
+pub fn visit_stmt_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Stmt) {
     use ::Stmt::*;
     match *_i {
         Local(ref mut _binding_0, ) => {
-            _visitor.visit_local(&mut * _binding_0);
+            _visitor.visit_local_mut(&mut * _binding_0);
         }
         Item(ref mut _binding_0, ) => {
-            _visitor.visit_item(&mut * _binding_0);
+            _visitor.visit_item_mut(&mut * _binding_0);
         }
         Expr(ref mut _binding_0, ) => {
-            _visitor.visit_expr(&mut * _binding_0);
+            _visitor.visit_expr_mut(&mut * _binding_0);
         }
         Semi(ref mut _binding_0, ref mut _binding_1, ) => {
-            _visitor.visit_expr(&mut * _binding_0);
+            _visitor.visit_expr_mut(&mut * _binding_0);
             // Skipped field * _binding_1;
         }
         Mac(ref mut _binding_0, ) => {
@@ -1696,7 +1696,7 @@
     }
 }
 
-pub fn walk_trait_bound_modifier<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TraitBoundModifier) {
+pub fn visit_trait_bound_modifier_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TraitBoundModifier) {
     use ::TraitBoundModifier::*;
     match *_i {
         None => { }
@@ -1706,145 +1706,145 @@
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_trait_item<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TraitItem) {
-    for mut it in (_i . attrs).iter_mut() { _visitor.visit_attribute(&mut it) };
-    _visitor.visit_trait_item_kind(&mut _i . node);
+pub fn visit_trait_item_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TraitItem) {
+    for mut it in (_i . attrs).iter_mut() { _visitor.visit_attribute_mut(&mut it) };
+    _visitor.visit_trait_item_kind_mut(&mut _i . node);
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_trait_item_const<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TraitItemConst) {
+pub fn visit_trait_item_const_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TraitItemConst) {
     // Skipped field _i . const_token;
     // Skipped field _i . ident;
     // Skipped field _i . colon_token;
-    _visitor.visit_ty(&mut _i . ty);
+    _visitor.visit_ty_mut(&mut _i . ty);
     // Skipped field _i . default;
     // Skipped field _i . semi_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_trait_item_kind<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TraitItemKind) {
+pub fn visit_trait_item_kind_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TraitItemKind) {
     use ::TraitItemKind::*;
     match *_i {
         Const(ref mut _binding_0, ) => {
-            _visitor.visit_trait_item_const(&mut * _binding_0);
+            _visitor.visit_trait_item_const_mut(&mut * _binding_0);
         }
         Method(ref mut _binding_0, ) => {
-            _visitor.visit_trait_item_method(&mut * _binding_0);
+            _visitor.visit_trait_item_method_mut(&mut * _binding_0);
         }
         Type(ref mut _binding_0, ) => {
-            _visitor.visit_trait_item_type(&mut * _binding_0);
+            _visitor.visit_trait_item_type_mut(&mut * _binding_0);
         }
         Macro(ref mut _binding_0, ) => {
-            _visitor.visit_mac(&mut * _binding_0);
+            _visitor.visit_mac_mut(&mut * _binding_0);
         }
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_trait_item_method<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TraitItemMethod) {
-    _visitor.visit_method_sig(&mut _i . sig);
-    if let Some(ref mut it) = _i . default { _visitor.visit_block(&mut * it) };
+pub fn visit_trait_item_method_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TraitItemMethod) {
+    _visitor.visit_method_sig_mut(&mut _i . sig);
+    if let Some(ref mut it) = _i . default { _visitor.visit_block_mut(&mut * it) };
     // Skipped field _i . semi_token;
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_trait_item_type<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TraitItemType) {
+pub fn visit_trait_item_type_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TraitItemType) {
     // Skipped field _i . type_token;
     // Skipped field _i . ident;
     // Skipped field _i . colon_token;
-    for mut el in (_i . bounds).iter_mut() { let mut it = el.item_mut(); _visitor.visit_ty_param_bound(&mut it) };
+    for mut el in (_i . bounds).iter_mut() { let mut it = el.item_mut(); _visitor.visit_ty_param_bound_mut(&mut it) };
     // Skipped field _i . default;
     // Skipped field _i . semi_token;
 }
 
-pub fn walk_ty<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Ty) {
+pub fn visit_ty_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Ty) {
     use ::Ty::*;
     match *_i {
         Slice(ref mut _binding_0, ) => {
-            _visitor.visit_ty_slice(&mut * _binding_0);
+            _visitor.visit_ty_slice_mut(&mut * _binding_0);
         }
         Array(ref mut _binding_0, ) => {
-            _visitor.visit_ty_array(&mut * _binding_0);
+            _visitor.visit_ty_array_mut(&mut * _binding_0);
         }
         Ptr(ref mut _binding_0, ) => {
-            _visitor.visit_ty_ptr(&mut * _binding_0);
+            _visitor.visit_ty_ptr_mut(&mut * _binding_0);
         }
         Rptr(ref mut _binding_0, ) => {
-            _visitor.visit_ty_rptr(&mut * _binding_0);
+            _visitor.visit_ty_rptr_mut(&mut * _binding_0);
         }
         BareFn(ref mut _binding_0, ) => {
-            _visitor.visit_ty_bare_fn(&mut * _binding_0);
+            _visitor.visit_ty_bare_fn_mut(&mut * _binding_0);
         }
         Never(ref mut _binding_0, ) => {
-            _visitor.visit_ty_never(&mut * _binding_0);
+            _visitor.visit_ty_never_mut(&mut * _binding_0);
         }
         Tup(ref mut _binding_0, ) => {
-            _visitor.visit_ty_tup(&mut * _binding_0);
+            _visitor.visit_ty_tup_mut(&mut * _binding_0);
         }
         Path(ref mut _binding_0, ) => {
-            _visitor.visit_ty_path(&mut * _binding_0);
+            _visitor.visit_ty_path_mut(&mut * _binding_0);
         }
         TraitObject(ref mut _binding_0, ) => {
-            _visitor.visit_ty_trait_object(&mut * _binding_0);
+            _visitor.visit_ty_trait_object_mut(&mut * _binding_0);
         }
         ImplTrait(ref mut _binding_0, ) => {
-            _visitor.visit_ty_impl_trait(&mut * _binding_0);
+            _visitor.visit_ty_impl_trait_mut(&mut * _binding_0);
         }
         Paren(ref mut _binding_0, ) => {
-            _visitor.visit_ty_paren(&mut * _binding_0);
+            _visitor.visit_ty_paren_mut(&mut * _binding_0);
         }
         Group(ref mut _binding_0, ) => {
-            _visitor.visit_ty_group(&mut * _binding_0);
+            _visitor.visit_ty_group_mut(&mut * _binding_0);
         }
         Infer(ref mut _binding_0, ) => {
-            _visitor.visit_ty_infer(&mut * _binding_0);
+            _visitor.visit_ty_infer_mut(&mut * _binding_0);
         }
         Mac(ref mut _binding_0, ) => {
-            _visitor.visit_mac(&mut * _binding_0);
+            _visitor.visit_mac_mut(&mut * _binding_0);
         }
     }
 }
 
-pub fn walk_ty_array<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TyArray) {
+pub fn visit_ty_array_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TyArray) {
     // Skipped field _i . bracket_token;
-    _visitor.visit_ty(&mut _i . ty);
+    _visitor.visit_ty_mut(&mut _i . ty);
     // Skipped field _i . semi_token;
-    _visitor.visit_expr(&mut _i . amt);
+    _visitor.visit_expr_mut(&mut _i . amt);
 }
 
-pub fn walk_ty_bare_fn<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TyBareFn) {
-    _visitor.visit_bare_fn_ty(&mut _i . ty);
+pub fn visit_ty_bare_fn_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TyBareFn) {
+    _visitor.visit_bare_fn_ty_mut(&mut _i . ty);
 }
 
-pub fn walk_ty_group<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TyGroup) {
+pub fn visit_ty_group_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TyGroup) {
     // Skipped field _i . group_token;
-    _visitor.visit_ty(&mut _i . ty);
+    _visitor.visit_ty_mut(&mut _i . ty);
 }
 
-pub fn walk_ty_impl_trait<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TyImplTrait) {
+pub fn visit_ty_impl_trait_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TyImplTrait) {
     // Skipped field _i . impl_token;
-    for mut el in (_i . bounds).iter_mut() { let mut it = el.item_mut(); _visitor.visit_ty_param_bound(&mut it) };
+    for mut el in (_i . bounds).iter_mut() { let mut it = el.item_mut(); _visitor.visit_ty_param_bound_mut(&mut it) };
 }
 
-pub fn walk_ty_infer<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TyInfer) {
+pub fn visit_ty_infer_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TyInfer) {
     // Skipped field _i . underscore_token;
 }
 
-pub fn walk_ty_never<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TyNever) {
+pub fn visit_ty_never_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TyNever) {
     // Skipped field _i . bang_token;
 }
 
-pub fn walk_ty_param<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TyParam) {
-    for mut it in (_i . attrs).iter_mut() { _visitor.visit_attribute(&mut it) };
+pub fn visit_ty_param_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TyParam) {
+    for mut it in (_i . attrs).iter_mut() { _visitor.visit_attribute_mut(&mut it) };
     // Skipped field _i . ident;
     // Skipped field _i . colon_token;
-    for mut el in (_i . bounds).iter_mut() { let mut it = el.item_mut(); _visitor.visit_ty_param_bound(&mut it) };
+    for mut el in (_i . bounds).iter_mut() { let mut it = el.item_mut(); _visitor.visit_ty_param_bound_mut(&mut it) };
     // Skipped field _i . eq_token;
-    if let Some(ref mut it) = _i . default { _visitor.visit_ty(&mut * it) };
+    if let Some(ref mut it) = _i . default { _visitor.visit_ty_mut(&mut * it) };
 }
 
-pub fn walk_ty_param_bound<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TyParamBound) {
+pub fn visit_ty_param_bound_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TyParamBound) {
     use ::TyParamBound::*;
     match *_i {
         Trait(ref mut _binding_0, ref mut _binding_1, ) => {
-            _visitor.visit_poly_trait_ref(&mut * _binding_0);
-            _visitor.visit_trait_bound_modifier(&mut * _binding_1);
+            _visitor.visit_poly_trait_ref_mut(&mut * _binding_0);
+            _visitor.visit_trait_bound_modifier_mut(&mut * _binding_1);
         }
         Region(ref mut _binding_0, ) => {
             // Skipped field * _binding_0;
@@ -1852,50 +1852,50 @@
     }
 }
 
-pub fn walk_ty_paren<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TyParen) {
+pub fn visit_ty_paren_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TyParen) {
     // Skipped field _i . paren_token;
-    _visitor.visit_ty(&mut _i . ty);
+    _visitor.visit_ty_mut(&mut _i . ty);
 }
 
-pub fn walk_ty_path<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TyPath) {
-    if let Some(ref mut it) = _i . qself { _visitor.visit_qself(&mut * it) };
-    _visitor.visit_path(&mut _i . path);
+pub fn visit_ty_path_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TyPath) {
+    if let Some(ref mut it) = _i . qself { _visitor.visit_qself_mut(&mut * it) };
+    _visitor.visit_path_mut(&mut _i . path);
 }
 
-pub fn walk_ty_ptr<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TyPtr) {
+pub fn visit_ty_ptr_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TyPtr) {
     // Skipped field _i . star_token;
     // Skipped field _i . const_token;
-    _visitor.visit_mut_ty(&mut _i . ty);
+    _visitor.visit_mut_ty_mut(&mut _i . ty);
 }
 
-pub fn walk_ty_rptr<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TyRptr) {
+pub fn visit_ty_rptr_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TyRptr) {
     // Skipped field _i . and_token;
     // Skipped field _i . lifetime;
-    _visitor.visit_mut_ty(&mut _i . ty);
+    _visitor.visit_mut_ty_mut(&mut _i . ty);
 }
 
-pub fn walk_ty_slice<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TySlice) {
-    _visitor.visit_ty(&mut _i . ty);
+pub fn visit_ty_slice_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TySlice) {
+    _visitor.visit_ty_mut(&mut _i . ty);
     // Skipped field _i . bracket_token;
 }
 
-pub fn walk_ty_trait_object<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TyTraitObject) {
-    for mut el in (_i . bounds).iter_mut() { let mut it = el.item_mut(); _visitor.visit_ty_param_bound(&mut it) };
+pub fn visit_ty_trait_object_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TyTraitObject) {
+    for mut el in (_i . bounds).iter_mut() { let mut it = el.item_mut(); _visitor.visit_ty_param_bound_mut(&mut it) };
 }
 
-pub fn walk_ty_tup<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TyTup) {
+pub fn visit_ty_tup_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TyTup) {
     // Skipped field _i . paren_token;
-    for mut el in (_i . tys).iter_mut() { let mut it = el.item_mut(); _visitor.visit_ty(&mut it) };
+    for mut el in (_i . tys).iter_mut() { let mut it = el.item_mut(); _visitor.visit_ty_mut(&mut it) };
     // Skipped field _i . lone_comma;
 }
 
-pub fn walk_type_binding<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TypeBinding) {
+pub fn visit_type_binding_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut TypeBinding) {
     // Skipped field _i . ident;
     // Skipped field _i . eq_token;
-    _visitor.visit_ty(&mut _i . ty);
+    _visitor.visit_ty_mut(&mut _i . ty);
 }
 
-pub fn walk_un_op<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut UnOp) {
+pub fn visit_un_op_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut UnOp) {
     use ::UnOp::*;
     match *_i {
         Deref(ref mut _binding_0, ) => {
@@ -1910,7 +1910,7 @@
     }
 }
 
-pub fn walk_unsafety<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Unsafety) {
+pub fn visit_unsafety_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Unsafety) {
     use ::Unsafety::*;
     match *_i {
         Unsafe(ref mut _binding_0, ) => {
@@ -1920,116 +1920,116 @@
     }
 }
 
-pub fn walk_variant<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Variant) {
+pub fn visit_variant_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Variant) {
     // Skipped field _i . ident;
-    for mut it in (_i . attrs).iter_mut() { _visitor.visit_attribute(&mut it) };
-    _visitor.visit_variant_data(&mut _i . data);
-    if let Some(ref mut it) = _i . discriminant { _visitor.visit_expr(&mut * it) };
+    for mut it in (_i . attrs).iter_mut() { _visitor.visit_attribute_mut(&mut it) };
+    _visitor.visit_variant_data_mut(&mut _i . data);
+    if let Some(ref mut it) = _i . discriminant { _visitor.visit_expr_mut(&mut * it) };
     // Skipped field _i . eq_token;
 }
 
-pub fn walk_variant_data<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut VariantData) {
+pub fn visit_variant_data_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut VariantData) {
     use ::VariantData::*;
     match *_i {
         Struct(ref mut _binding_0, ref mut _binding_1, ) => {
-            for mut el in (* _binding_0).iter_mut() { let mut it = el.item_mut(); _visitor.visit_field(&mut it) };
+            for mut el in (* _binding_0).iter_mut() { let mut it = el.item_mut(); _visitor.visit_field_mut(&mut it) };
             // Skipped field * _binding_1;
         }
         Tuple(ref mut _binding_0, ref mut _binding_1, ) => {
-            for mut el in (* _binding_0).iter_mut() { let mut it = el.item_mut(); _visitor.visit_field(&mut it) };
+            for mut el in (* _binding_0).iter_mut() { let mut it = el.item_mut(); _visitor.visit_field_mut(&mut it) };
             // Skipped field * _binding_1;
         }
         Unit => { }
     }
 }
 # [ cfg ( feature = "full" ) ]
-pub fn walk_view_path<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ViewPath) {
+pub fn visit_view_path_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut ViewPath) {
     use ::ViewPath::*;
     match *_i {
         Simple(ref mut _binding_0, ) => {
-            _visitor.visit_path_simple(&mut * _binding_0);
+            _visitor.visit_path_simple_mut(&mut * _binding_0);
         }
         Glob(ref mut _binding_0, ) => {
-            _visitor.visit_path_glob(&mut * _binding_0);
+            _visitor.visit_path_glob_mut(&mut * _binding_0);
         }
         List(ref mut _binding_0, ) => {
-            _visitor.visit_path_list(&mut * _binding_0);
+            _visitor.visit_path_list_mut(&mut * _binding_0);
         }
     }
 }
 
-pub fn walk_vis_crate<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut VisCrate) {
+pub fn visit_vis_crate_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut VisCrate) {
     // Skipped field _i . pub_token;
     // Skipped field _i . paren_token;
     // Skipped field _i . crate_token;
 }
 
-pub fn walk_vis_inherited<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut VisInherited) {
+pub fn visit_vis_inherited_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut VisInherited) {
 }
 
-pub fn walk_vis_public<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut VisPublic) {
+pub fn visit_vis_public_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut VisPublic) {
     // Skipped field _i . pub_token;
 }
 
-pub fn walk_vis_restricted<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut VisRestricted) {
+pub fn visit_vis_restricted_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut VisRestricted) {
     // Skipped field _i . pub_token;
     // Skipped field _i . paren_token;
     // Skipped field _i . in_token;
-    _visitor.visit_path(&mut _i . path);
+    _visitor.visit_path_mut(&mut _i . path);
 }
 
-pub fn walk_visibility<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Visibility) {
+pub fn visit_visibility_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut Visibility) {
     use ::Visibility::*;
     match *_i {
         Public(ref mut _binding_0, ) => {
-            _visitor.visit_vis_public(&mut * _binding_0);
+            _visitor.visit_vis_public_mut(&mut * _binding_0);
         }
         Crate(ref mut _binding_0, ) => {
-            _visitor.visit_vis_crate(&mut * _binding_0);
+            _visitor.visit_vis_crate_mut(&mut * _binding_0);
         }
         Restricted(ref mut _binding_0, ) => {
-            _visitor.visit_vis_restricted(&mut * _binding_0);
+            _visitor.visit_vis_restricted_mut(&mut * _binding_0);
         }
         Inherited(ref mut _binding_0, ) => {
-            _visitor.visit_vis_inherited(&mut * _binding_0);
+            _visitor.visit_vis_inherited_mut(&mut * _binding_0);
         }
     }
 }
 
-pub fn walk_where_bound_predicate<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut WhereBoundPredicate) {
-    if let Some(ref mut it) = _i . bound_lifetimes { _visitor.visit_bound_lifetimes(&mut * it) };
-    _visitor.visit_ty(&mut _i . bounded_ty);
+pub fn visit_where_bound_predicate_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut WhereBoundPredicate) {
+    if let Some(ref mut it) = _i . bound_lifetimes { _visitor.visit_bound_lifetimes_mut(&mut * it) };
+    _visitor.visit_ty_mut(&mut _i . bounded_ty);
     // Skipped field _i . colon_token;
-    for mut el in (_i . bounds).iter_mut() { let mut it = el.item_mut(); _visitor.visit_ty_param_bound(&mut it) };
+    for mut el in (_i . bounds).iter_mut() { let mut it = el.item_mut(); _visitor.visit_ty_param_bound_mut(&mut it) };
 }
 
-pub fn walk_where_clause<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut WhereClause) {
+pub fn visit_where_clause_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut WhereClause) {
     // Skipped field _i . where_token;
-    for mut el in (_i . predicates).iter_mut() { let mut it = el.item_mut(); _visitor.visit_where_predicate(&mut it) };
+    for mut el in (_i . predicates).iter_mut() { let mut it = el.item_mut(); _visitor.visit_where_predicate_mut(&mut it) };
 }
 
-pub fn walk_where_eq_predicate<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut WhereEqPredicate) {
-    _visitor.visit_ty(&mut _i . lhs_ty);
+pub fn visit_where_eq_predicate_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut WhereEqPredicate) {
+    _visitor.visit_ty_mut(&mut _i . lhs_ty);
     // Skipped field _i . eq_token;
-    _visitor.visit_ty(&mut _i . rhs_ty);
+    _visitor.visit_ty_mut(&mut _i . rhs_ty);
 }
 
-pub fn walk_where_predicate<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut WherePredicate) {
+pub fn visit_where_predicate_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut WherePredicate) {
     use ::WherePredicate::*;
     match *_i {
         BoundPredicate(ref mut _binding_0, ) => {
-            _visitor.visit_where_bound_predicate(&mut * _binding_0);
+            _visitor.visit_where_bound_predicate_mut(&mut * _binding_0);
         }
         RegionPredicate(ref mut _binding_0, ) => {
-            _visitor.visit_where_region_predicate(&mut * _binding_0);
+            _visitor.visit_where_region_predicate_mut(&mut * _binding_0);
         }
         EqPredicate(ref mut _binding_0, ) => {
-            _visitor.visit_where_eq_predicate(&mut * _binding_0);
+            _visitor.visit_where_eq_predicate_mut(&mut * _binding_0);
         }
     }
 }
 
-pub fn walk_where_region_predicate<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut WhereRegionPredicate) {
+pub fn visit_where_region_predicate_mut<V: VisitorMut + ?Sized>(_visitor: &mut V, _i: &mut WhereRegionPredicate) {
     // Skipped field _i . lifetime;
     // Skipped field _i . colon_token;
     // Skipped field _i . bounds;
diff --git a/src/lib.rs b/src/lib.rs
index 2fedda9..c30515d 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -95,17 +95,17 @@
 pub use synom::tokens;
 pub use synom::delimited;
 
-#[cfg(feature = "visit")]
-#[path = "gen/visit.rs"]
-pub mod visit;
+mod gen {
+    #[cfg(feature = "visit")]
+    pub mod visit;
 
-#[cfg(feature = "visit")]
-#[path = "gen/visit_mut.rs"]
-pub mod visit_mut;
+    #[cfg(feature = "visit_mut")]
+    pub mod visit_mut;
 
-#[cfg(feature = "fold")]
-#[path = "gen/fold.rs"]
-pub mod fold;
+    #[cfg(feature = "fold")]
+    pub mod fold;
+}
+pub use gen::*;
 
 ////////////////////////////////////////////////////////////////////////////////
 
diff --git a/syn_codegen/src/main.rs b/syn_codegen/src/main.rs
index 95fc2bc..4567545 100644
--- a/syn_codegen/src/main.rs
+++ b/syn_codegen/src/main.rs
@@ -334,7 +334,7 @@
                     name = name,
                 ),
                 Kind::VisitMut => format!(
-                    "_visitor.visit_{under_name}(&mut {name})",
+                    "_visitor.visit_{under_name}_mut(&mut {name})",
                     under_name = under_name(type_name),
                     name = name,
                 ),
@@ -519,7 +519,7 @@
         state.visit_trait.push_str(&format!(
             "{features}\n\
              fn visit_{under_name}(&mut self, i: &{ty}) {{ \
-               walk_{under_name}(self, i) \
+               visit_{under_name}(self, i) \
              }}\n",
             features = s.features,
             under_name = under_name,
@@ -527,8 +527,8 @@
         ));
         state.visit_mut_trait.push_str(&format!(
             "{features}\n\
-             fn visit_{under_name}(&mut self, i: &mut {ty}) {{ \
-               walk_{under_name}(self, i) \
+             fn visit_{under_name}_mut(&mut self, i: &mut {ty}) {{ \
+               visit_{under_name}_mut(self, i) \
              }}\n",
             features = s.features,
             under_name = under_name,
@@ -537,7 +537,7 @@
         state.fold_trait.push_str(&format!(
             "{features}\n\
              fn fold_{under_name}(&mut self, i: {ty}) -> {ty} {{ \
-               walk_{under_name}(self, i) \
+               fold_{under_name}(self, i) \
              }}\n",
             features = s.features,
             under_name = under_name,
@@ -546,7 +546,7 @@
 
         state.visit_impl.push_str(&format!(
             "{features}\n\
-             pub fn walk_{under_name}<V: Visitor + ?Sized>(\
+             pub fn visit_{under_name}<V: Visitor + ?Sized>(\
                _visitor: &mut V, _i: &{ty}) {{\n",
             features = s.features,
             under_name = under_name,
@@ -554,7 +554,7 @@
         ));
         state.visit_mut_impl.push_str(&format!(
             "{features}\n\
-             pub fn walk_{under_name}<V: VisitorMut + ?Sized>(\
+             pub fn visit_{under_name}_mut<V: VisitorMut + ?Sized>(\
                _visitor: &mut V, _i: &mut {ty}) {{\n",
             features = s.features,
             under_name = under_name,
@@ -562,7 +562,7 @@
         ));
         state.fold_impl.push_str(&format!(
             "{features}\n\
-             pub fn walk_{under_name}<V: Folder + ?Sized>(\
+             pub fn fold_{under_name}<V: Folder + ?Sized>(\
                _visitor: &mut V, _i: {ty}) -> {ty} {{\n",
             features = s.features,
             under_name = under_name,
@@ -747,7 +747,7 @@
 // Unreachable code is generated sometimes without the full feature.
 #![allow(unreachable_code)]
 
-use super::*;
+use *;
 use synom::delimited::Delimited;
 
 trait FoldHelper {{
@@ -805,7 +805,7 @@
 //! call `visit::walk_*` to apply the default traversal algorithm, or prevent
 //! deeper traversal by doing nothing.
 
-use super::*;
+use *;
 
 {full_macro}
 
@@ -837,7 +837,7 @@
 //! call `visit::walk_*` to apply the default traversal algorithm, or prevent
 //! deeper traversal by doing nothing.
 
-use super::*;
+use *;
 
 {full_macro}
 
diff --git a/tests/test_precedence.rs b/tests/test_precedence.rs
index 4442ecb..87dada8 100644
--- a/tests/test_precedence.rs
+++ b/tests/test_precedence.rs
@@ -297,7 +297,7 @@
 
     fn paren(folder: &mut BracketsFolder, node: ExprKind) -> ExprKind {
         ExprKind::Paren(ExprParen {
-            expr: Box::new(walk_expr(folder, Expr {
+            expr: Box::new(fold_expr(folder, Expr {
                 node: node,
                 attrs: vec![],
             })),
@@ -314,7 +314,7 @@
                 ExprKind::If(..) |
                 ExprKind::Block(..) |
                 ExprKind::IfLet(..) => {
-                    return walk_expr(self, expr);
+                    return fold_expr(self, expr);
                 }
                 node => paren(self, node),
             };
@@ -329,10 +329,10 @@
             match stmt {
                 // Don't wrap toplevel expressions in statements.
                 Stmt::Expr(e) => {
-                    Stmt::Expr(Box::new(walk_expr(self, *e)))
+                    Stmt::Expr(Box::new(fold_expr(self, *e)))
                 }
                 Stmt::Semi(e, semi) => {
-                    Stmt::Semi(Box::new(walk_expr(self, *e)), semi)
+                    Stmt::Semi(Box::new(fold_expr(self, *e)), semi)
                 }
                 s => s,
             }