Rename methods and functions to be more uniform
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,
}