| // This file is @generated by syn-internal-codegen. |
| // It is not intended for manual editing. |
| |
| #![allow(unused_variables)] |
| #[cfg(any(feature = "full", feature = "derive"))] |
| use crate::gen::helper::visit_mut::*; |
| #[cfg(any(feature = "full", feature = "derive"))] |
| use crate::punctuated::Punctuated; |
| use crate::*; |
| use proc_macro2::Span; |
| #[cfg(feature = "full")] |
| macro_rules! full { |
| ($e:expr) => { |
| $e |
| }; |
| } |
| #[cfg(all(feature = "derive", not(feature = "full")))] |
| macro_rules! full { |
| ($e:expr) => { |
| unreachable!() |
| }; |
| } |
| macro_rules! skip { |
| ($($tt:tt)*) => {}; |
| } |
| /// Syntax tree traversal to mutate an exclusive borrow of a syntax tree in |
| /// place. |
| /// |
| /// See the [module documentation] for details. |
| /// |
| /// [module documentation]: self |
| /// |
| /// *This trait is available only if Syn is built with the `"visit-mut"` feature.* |
| pub trait VisitMut { |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_abi_mut(&mut self, i: &mut Abi) { |
| visit_abi_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_angle_bracketed_generic_arguments_mut( |
| &mut self, |
| i: &mut AngleBracketedGenericArguments, |
| ) { |
| visit_angle_bracketed_generic_arguments_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_arm_mut(&mut self, i: &mut Arm) { |
| visit_arm_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_attr_style_mut(&mut self, i: &mut AttrStyle) { |
| visit_attr_style_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_attribute_mut(&mut self, i: &mut Attribute) { |
| visit_attribute_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_bare_fn_arg_mut(&mut self, i: &mut BareFnArg) { |
| visit_bare_fn_arg_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_bin_op_mut(&mut self, i: &mut BinOp) { |
| visit_bin_op_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_binding_mut(&mut self, i: &mut Binding) { |
| visit_binding_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_block_mut(&mut self, i: &mut Block) { |
| visit_block_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_bound_lifetimes_mut(&mut self, i: &mut BoundLifetimes) { |
| visit_bound_lifetimes_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_const_param_mut(&mut self, i: &mut ConstParam) { |
| visit_const_param_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_constraint_mut(&mut self, i: &mut Constraint) { |
| visit_constraint_mut(self, i) |
| } |
| #[cfg(feature = "derive")] |
| fn visit_data_mut(&mut self, i: &mut Data) { |
| visit_data_mut(self, i) |
| } |
| #[cfg(feature = "derive")] |
| fn visit_data_enum_mut(&mut self, i: &mut DataEnum) { |
| visit_data_enum_mut(self, i) |
| } |
| #[cfg(feature = "derive")] |
| fn visit_data_struct_mut(&mut self, i: &mut DataStruct) { |
| visit_data_struct_mut(self, i) |
| } |
| #[cfg(feature = "derive")] |
| fn visit_data_union_mut(&mut self, i: &mut DataUnion) { |
| visit_data_union_mut(self, i) |
| } |
| #[cfg(feature = "derive")] |
| fn visit_derive_input_mut(&mut self, i: &mut DeriveInput) { |
| visit_derive_input_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_expr_mut(&mut self, i: &mut Expr) { |
| visit_expr_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_expr_array_mut(&mut self, i: &mut ExprArray) { |
| visit_expr_array_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| 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(&mut self, i: &mut ExprAssignOp) { |
| visit_expr_assign_op_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_expr_async_mut(&mut self, i: &mut ExprAsync) { |
| visit_expr_async_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_expr_await_mut(&mut self, i: &mut ExprAwait) { |
| visit_expr_await_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_expr_binary_mut(&mut self, i: &mut ExprBinary) { |
| visit_expr_binary_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_expr_block_mut(&mut self, i: &mut ExprBlock) { |
| visit_expr_block_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_expr_box_mut(&mut self, i: &mut ExprBox) { |
| visit_expr_box_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_expr_break_mut(&mut self, i: &mut ExprBreak) { |
| visit_expr_break_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_expr_call_mut(&mut self, i: &mut ExprCall) { |
| visit_expr_call_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_expr_cast_mut(&mut self, i: &mut ExprCast) { |
| visit_expr_cast_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_expr_closure_mut(&mut self, i: &mut ExprClosure) { |
| visit_expr_closure_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_expr_continue_mut(&mut self, i: &mut ExprContinue) { |
| visit_expr_continue_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| 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(&mut self, i: &mut ExprForLoop) { |
| visit_expr_for_loop_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_expr_group_mut(&mut self, i: &mut ExprGroup) { |
| visit_expr_group_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_expr_if_mut(&mut self, i: &mut ExprIf) { |
| visit_expr_if_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_expr_index_mut(&mut self, i: &mut ExprIndex) { |
| visit_expr_index_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_expr_let_mut(&mut self, i: &mut ExprLet) { |
| visit_expr_let_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_expr_lit_mut(&mut self, i: &mut ExprLit) { |
| visit_expr_lit_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_expr_loop_mut(&mut self, i: &mut ExprLoop) { |
| visit_expr_loop_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_expr_macro_mut(&mut self, i: &mut ExprMacro) { |
| visit_expr_macro_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| 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(&mut self, i: &mut ExprMethodCall) { |
| visit_expr_method_call_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_expr_paren_mut(&mut self, i: &mut ExprParen) { |
| visit_expr_paren_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_expr_path_mut(&mut self, i: &mut ExprPath) { |
| visit_expr_path_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_expr_range_mut(&mut self, i: &mut ExprRange) { |
| visit_expr_range_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_expr_reference_mut(&mut self, i: &mut ExprReference) { |
| visit_expr_reference_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_expr_repeat_mut(&mut self, i: &mut ExprRepeat) { |
| visit_expr_repeat_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_expr_return_mut(&mut self, i: &mut ExprReturn) { |
| visit_expr_return_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_expr_struct_mut(&mut self, i: &mut ExprStruct) { |
| visit_expr_struct_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_expr_try_mut(&mut self, i: &mut ExprTry) { |
| visit_expr_try_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_expr_try_block_mut(&mut self, i: &mut ExprTryBlock) { |
| visit_expr_try_block_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_expr_tuple_mut(&mut self, i: &mut ExprTuple) { |
| visit_expr_tuple_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_expr_type_mut(&mut self, i: &mut ExprType) { |
| visit_expr_type_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_expr_unary_mut(&mut self, i: &mut ExprUnary) { |
| visit_expr_unary_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_expr_unsafe_mut(&mut self, i: &mut ExprUnsafe) { |
| visit_expr_unsafe_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_expr_while_mut(&mut self, i: &mut ExprWhile) { |
| visit_expr_while_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_expr_yield_mut(&mut self, i: &mut ExprYield) { |
| visit_expr_yield_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_field_mut(&mut self, i: &mut Field) { |
| visit_field_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_field_pat_mut(&mut self, i: &mut FieldPat) { |
| visit_field_pat_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_field_value_mut(&mut self, i: &mut FieldValue) { |
| visit_field_value_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_fields_mut(&mut self, i: &mut Fields) { |
| visit_fields_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_fields_named_mut(&mut self, i: &mut FieldsNamed) { |
| visit_fields_named_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_fields_unnamed_mut(&mut self, i: &mut FieldsUnnamed) { |
| visit_fields_unnamed_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_file_mut(&mut self, i: &mut File) { |
| visit_file_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_fn_arg_mut(&mut self, i: &mut FnArg) { |
| visit_fn_arg_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| 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(&mut self, i: &mut ForeignItemFn) { |
| visit_foreign_item_fn_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_foreign_item_macro_mut(&mut self, i: &mut ForeignItemMacro) { |
| visit_foreign_item_macro_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_foreign_item_static_mut(&mut self, i: &mut ForeignItemStatic) { |
| visit_foreign_item_static_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_foreign_item_type_mut(&mut self, i: &mut ForeignItemType) { |
| visit_foreign_item_type_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_generic_argument_mut(&mut self, i: &mut GenericArgument) { |
| visit_generic_argument_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_generic_method_argument_mut(&mut self, i: &mut GenericMethodArgument) { |
| visit_generic_method_argument_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_generic_param_mut(&mut self, i: &mut GenericParam) { |
| visit_generic_param_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_generics_mut(&mut self, i: &mut Generics) { |
| visit_generics_mut(self, i) |
| } |
| fn visit_ident_mut(&mut self, i: &mut Ident) { |
| visit_ident_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| 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(&mut self, i: &mut ImplItemConst) { |
| visit_impl_item_const_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_impl_item_macro_mut(&mut self, i: &mut ImplItemMacro) { |
| visit_impl_item_macro_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| 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(&mut self, i: &mut ImplItemType) { |
| visit_impl_item_type_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_index_mut(&mut self, i: &mut Index) { |
| visit_index_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_item_mut(&mut self, i: &mut Item) { |
| visit_item_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_item_const_mut(&mut self, i: &mut ItemConst) { |
| visit_item_const_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| 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(&mut self, i: &mut ItemExternCrate) { |
| visit_item_extern_crate_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| 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(&mut self, i: &mut ItemForeignMod) { |
| visit_item_foreign_mod_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_item_impl_mut(&mut self, i: &mut ItemImpl) { |
| visit_item_impl_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_item_macro_mut(&mut self, i: &mut ItemMacro) { |
| visit_item_macro_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_item_macro2_mut(&mut self, i: &mut ItemMacro2) { |
| visit_item_macro2_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_item_mod_mut(&mut self, i: &mut ItemMod) { |
| visit_item_mod_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_item_static_mut(&mut self, i: &mut ItemStatic) { |
| visit_item_static_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_item_struct_mut(&mut self, i: &mut ItemStruct) { |
| visit_item_struct_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_item_trait_mut(&mut self, i: &mut ItemTrait) { |
| visit_item_trait_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_item_trait_alias_mut(&mut self, i: &mut ItemTraitAlias) { |
| visit_item_trait_alias_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_item_type_mut(&mut self, i: &mut ItemType) { |
| visit_item_type_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_item_union_mut(&mut self, i: &mut ItemUnion) { |
| visit_item_union_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_item_use_mut(&mut self, i: &mut ItemUse) { |
| visit_item_use_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_label_mut(&mut self, i: &mut Label) { |
| visit_label_mut(self, i) |
| } |
| fn visit_lifetime_mut(&mut self, i: &mut Lifetime) { |
| visit_lifetime_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_lifetime_def_mut(&mut self, i: &mut LifetimeDef) { |
| visit_lifetime_def_mut(self, i) |
| } |
| fn visit_lit_mut(&mut self, i: &mut Lit) { |
| visit_lit_mut(self, i) |
| } |
| fn visit_lit_bool_mut(&mut self, i: &mut LitBool) { |
| visit_lit_bool_mut(self, i) |
| } |
| fn visit_lit_byte_mut(&mut self, i: &mut LitByte) { |
| visit_lit_byte_mut(self, i) |
| } |
| fn visit_lit_byte_str_mut(&mut self, i: &mut LitByteStr) { |
| visit_lit_byte_str_mut(self, i) |
| } |
| fn visit_lit_char_mut(&mut self, i: &mut LitChar) { |
| visit_lit_char_mut(self, i) |
| } |
| fn visit_lit_float_mut(&mut self, i: &mut LitFloat) { |
| visit_lit_float_mut(self, i) |
| } |
| fn visit_lit_int_mut(&mut self, i: &mut LitInt) { |
| visit_lit_int_mut(self, i) |
| } |
| fn visit_lit_str_mut(&mut self, i: &mut LitStr) { |
| visit_lit_str_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_local_mut(&mut self, i: &mut Local) { |
| visit_local_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_macro_mut(&mut self, i: &mut Macro) { |
| visit_macro_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_macro_delimiter_mut(&mut self, i: &mut MacroDelimiter) { |
| visit_macro_delimiter_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_member_mut(&mut self, i: &mut Member) { |
| visit_member_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_meta_mut(&mut self, i: &mut Meta) { |
| visit_meta_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_meta_list_mut(&mut self, i: &mut MetaList) { |
| visit_meta_list_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_meta_name_value_mut(&mut self, i: &mut MetaNameValue) { |
| visit_meta_name_value_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_method_turbofish_mut(&mut self, i: &mut MethodTurbofish) { |
| visit_method_turbofish_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_nested_meta_mut(&mut self, i: &mut NestedMeta) { |
| visit_nested_meta_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_parenthesized_generic_arguments_mut(&mut self, i: &mut ParenthesizedGenericArguments) { |
| visit_parenthesized_generic_arguments_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_pat_mut(&mut self, i: &mut Pat) { |
| visit_pat_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_pat_box_mut(&mut self, i: &mut PatBox) { |
| visit_pat_box_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_pat_ident_mut(&mut self, i: &mut PatIdent) { |
| visit_pat_ident_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_pat_lit_mut(&mut self, i: &mut PatLit) { |
| visit_pat_lit_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_pat_macro_mut(&mut self, i: &mut PatMacro) { |
| visit_pat_macro_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_pat_or_mut(&mut self, i: &mut PatOr) { |
| visit_pat_or_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_pat_path_mut(&mut self, i: &mut PatPath) { |
| visit_pat_path_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_pat_range_mut(&mut self, i: &mut PatRange) { |
| visit_pat_range_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_pat_reference_mut(&mut self, i: &mut PatReference) { |
| visit_pat_reference_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_pat_rest_mut(&mut self, i: &mut PatRest) { |
| visit_pat_rest_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_pat_slice_mut(&mut self, i: &mut PatSlice) { |
| visit_pat_slice_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_pat_struct_mut(&mut self, i: &mut PatStruct) { |
| visit_pat_struct_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| 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(&mut self, i: &mut PatTupleStruct) { |
| visit_pat_tuple_struct_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_pat_type_mut(&mut self, i: &mut PatType) { |
| visit_pat_type_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_pat_wild_mut(&mut self, i: &mut PatWild) { |
| visit_pat_wild_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_path_mut(&mut self, i: &mut Path) { |
| visit_path_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_path_arguments_mut(&mut self, i: &mut PathArguments) { |
| visit_path_arguments_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_path_segment_mut(&mut self, i: &mut PathSegment) { |
| visit_path_segment_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_predicate_eq_mut(&mut self, i: &mut PredicateEq) { |
| visit_predicate_eq_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_predicate_lifetime_mut(&mut self, i: &mut PredicateLifetime) { |
| visit_predicate_lifetime_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_predicate_type_mut(&mut self, i: &mut PredicateType) { |
| visit_predicate_type_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_qself_mut(&mut self, i: &mut QSelf) { |
| visit_qself_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_range_limits_mut(&mut self, i: &mut RangeLimits) { |
| visit_range_limits_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_receiver_mut(&mut self, i: &mut Receiver) { |
| visit_receiver_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_return_type_mut(&mut self, i: &mut ReturnType) { |
| visit_return_type_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_signature_mut(&mut self, i: &mut Signature) { |
| visit_signature_mut(self, i) |
| } |
| fn visit_span_mut(&mut self, i: &mut Span) { |
| visit_span_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_stmt_mut(&mut self, i: &mut Stmt) { |
| visit_stmt_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_trait_bound_mut(&mut self, i: &mut TraitBound) { |
| visit_trait_bound_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| 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(&mut self, i: &mut TraitItem) { |
| visit_trait_item_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| 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_macro_mut(&mut self, i: &mut TraitItemMacro) { |
| visit_trait_item_macro_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| 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(&mut self, i: &mut TraitItemType) { |
| visit_trait_item_type_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_type_mut(&mut self, i: &mut Type) { |
| visit_type_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_type_array_mut(&mut self, i: &mut TypeArray) { |
| visit_type_array_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_type_bare_fn_mut(&mut self, i: &mut TypeBareFn) { |
| visit_type_bare_fn_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_type_group_mut(&mut self, i: &mut TypeGroup) { |
| visit_type_group_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_type_impl_trait_mut(&mut self, i: &mut TypeImplTrait) { |
| visit_type_impl_trait_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_type_infer_mut(&mut self, i: &mut TypeInfer) { |
| visit_type_infer_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_type_macro_mut(&mut self, i: &mut TypeMacro) { |
| visit_type_macro_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_type_never_mut(&mut self, i: &mut TypeNever) { |
| visit_type_never_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_type_param_mut(&mut self, i: &mut TypeParam) { |
| visit_type_param_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_type_param_bound_mut(&mut self, i: &mut TypeParamBound) { |
| visit_type_param_bound_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_type_paren_mut(&mut self, i: &mut TypeParen) { |
| visit_type_paren_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_type_path_mut(&mut self, i: &mut TypePath) { |
| visit_type_path_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_type_ptr_mut(&mut self, i: &mut TypePtr) { |
| visit_type_ptr_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_type_reference_mut(&mut self, i: &mut TypeReference) { |
| visit_type_reference_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_type_slice_mut(&mut self, i: &mut TypeSlice) { |
| visit_type_slice_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_type_trait_object_mut(&mut self, i: &mut TypeTraitObject) { |
| visit_type_trait_object_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_type_tuple_mut(&mut self, i: &mut TypeTuple) { |
| visit_type_tuple_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_un_op_mut(&mut self, i: &mut UnOp) { |
| visit_un_op_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_use_glob_mut(&mut self, i: &mut UseGlob) { |
| visit_use_glob_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_use_group_mut(&mut self, i: &mut UseGroup) { |
| visit_use_group_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_use_name_mut(&mut self, i: &mut UseName) { |
| visit_use_name_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_use_path_mut(&mut self, i: &mut UsePath) { |
| visit_use_path_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_use_rename_mut(&mut self, i: &mut UseRename) { |
| visit_use_rename_mut(self, i) |
| } |
| #[cfg(feature = "full")] |
| fn visit_use_tree_mut(&mut self, i: &mut UseTree) { |
| visit_use_tree_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_variadic_mut(&mut self, i: &mut Variadic) { |
| visit_variadic_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_variant_mut(&mut self, i: &mut Variant) { |
| visit_variant_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_vis_crate_mut(&mut self, i: &mut VisCrate) { |
| visit_vis_crate_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_vis_public_mut(&mut self, i: &mut VisPublic) { |
| visit_vis_public_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_vis_restricted_mut(&mut self, i: &mut VisRestricted) { |
| visit_vis_restricted_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_visibility_mut(&mut self, i: &mut Visibility) { |
| visit_visibility_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_where_clause_mut(&mut self, i: &mut WhereClause) { |
| visit_where_clause_mut(self, i) |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| fn visit_where_predicate_mut(&mut self, i: &mut WherePredicate) { |
| visit_where_predicate_mut(self, i) |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_abi_mut<V>(v: &mut V, node: &mut Abi) |
| where |
| V: VisitMut + ?Sized, |
| { |
| tokens_helper(v, &mut node.extern_token.span); |
| if let Some(it) = &mut node.name { |
| v.visit_lit_str_mut(it) |
| }; |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_angle_bracketed_generic_arguments_mut<V>( |
| v: &mut V, |
| node: &mut AngleBracketedGenericArguments, |
| ) where |
| V: VisitMut + ?Sized, |
| { |
| if let Some(it) = &mut node.colon2_token { |
| tokens_helper(v, &mut it.spans) |
| }; |
| tokens_helper(v, &mut node.lt_token.spans); |
| for el in Punctuated::pairs_mut(&mut node.args) { |
| let (it, p) = el.into_tuple(); |
| v.visit_generic_argument_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| tokens_helper(v, &mut node.gt_token.spans); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_arm_mut<V>(v: &mut V, node: &mut Arm) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_pat_mut(&mut node.pat); |
| if let Some(it) = &mut node.guard { |
| tokens_helper(v, &mut (it).0.span); |
| v.visit_expr_mut(&mut *(it).1); |
| }; |
| tokens_helper(v, &mut node.fat_arrow_token.spans); |
| v.visit_expr_mut(&mut *node.body); |
| if let Some(it) = &mut node.comma { |
| tokens_helper(v, &mut it.spans) |
| }; |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_attr_style_mut<V>(v: &mut V, node: &mut AttrStyle) |
| where |
| V: VisitMut + ?Sized, |
| { |
| match node { |
| AttrStyle::Outer => {} |
| AttrStyle::Inner(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| } |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_attribute_mut<V>(v: &mut V, node: &mut Attribute) |
| where |
| V: VisitMut + ?Sized, |
| { |
| tokens_helper(v, &mut node.pound_token.spans); |
| v.visit_attr_style_mut(&mut node.style); |
| tokens_helper(v, &mut node.bracket_token.span); |
| v.visit_path_mut(&mut node.path); |
| skip!(node.tokens); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_bare_fn_arg_mut<V>(v: &mut V, node: &mut BareFnArg) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| if let Some(it) = &mut node.name { |
| v.visit_ident_mut(&mut (it).0); |
| tokens_helper(v, &mut (it).1.spans); |
| }; |
| v.visit_type_mut(&mut node.ty); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_bin_op_mut<V>(v: &mut V, node: &mut BinOp) |
| where |
| V: VisitMut + ?Sized, |
| { |
| match node { |
| BinOp::Add(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| } |
| BinOp::Sub(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| } |
| BinOp::Mul(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| } |
| BinOp::Div(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| } |
| BinOp::Rem(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| } |
| BinOp::And(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| } |
| BinOp::Or(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| } |
| BinOp::BitXor(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| } |
| BinOp::BitAnd(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| } |
| BinOp::BitOr(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| } |
| BinOp::Shl(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| } |
| BinOp::Shr(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| } |
| BinOp::Eq(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| } |
| BinOp::Lt(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| } |
| BinOp::Le(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| } |
| BinOp::Ne(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| } |
| BinOp::Ge(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| } |
| BinOp::Gt(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| } |
| BinOp::AddEq(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| } |
| BinOp::SubEq(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| } |
| BinOp::MulEq(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| } |
| BinOp::DivEq(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| } |
| BinOp::RemEq(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| } |
| BinOp::BitXorEq(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| } |
| BinOp::BitAndEq(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| } |
| BinOp::BitOrEq(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| } |
| BinOp::ShlEq(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| } |
| BinOp::ShrEq(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| } |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_binding_mut<V>(v: &mut V, node: &mut Binding) |
| where |
| V: VisitMut + ?Sized, |
| { |
| v.visit_ident_mut(&mut node.ident); |
| tokens_helper(v, &mut node.eq_token.spans); |
| v.visit_type_mut(&mut node.ty); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_block_mut<V>(v: &mut V, node: &mut Block) |
| where |
| V: VisitMut + ?Sized, |
| { |
| tokens_helper(v, &mut node.brace_token.span); |
| for it in &mut node.stmts { |
| v.visit_stmt_mut(it) |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_bound_lifetimes_mut<V>(v: &mut V, node: &mut BoundLifetimes) |
| where |
| V: VisitMut + ?Sized, |
| { |
| tokens_helper(v, &mut node.for_token.span); |
| tokens_helper(v, &mut node.lt_token.spans); |
| for el in Punctuated::pairs_mut(&mut node.lifetimes) { |
| let (it, p) = el.into_tuple(); |
| v.visit_lifetime_def_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| tokens_helper(v, &mut node.gt_token.spans); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_const_param_mut<V>(v: &mut V, node: &mut ConstParam) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| tokens_helper(v, &mut node.const_token.span); |
| v.visit_ident_mut(&mut node.ident); |
| tokens_helper(v, &mut node.colon_token.spans); |
| v.visit_type_mut(&mut node.ty); |
| if let Some(it) = &mut node.eq_token { |
| tokens_helper(v, &mut it.spans) |
| }; |
| if let Some(it) = &mut node.default { |
| v.visit_expr_mut(it) |
| }; |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_constraint_mut<V>(v: &mut V, node: &mut Constraint) |
| where |
| V: VisitMut + ?Sized, |
| { |
| v.visit_ident_mut(&mut node.ident); |
| tokens_helper(v, &mut node.colon_token.spans); |
| for el in Punctuated::pairs_mut(&mut node.bounds) { |
| let (it, p) = el.into_tuple(); |
| v.visit_type_param_bound_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| } |
| #[cfg(feature = "derive")] |
| pub fn visit_data_mut<V>(v: &mut V, node: &mut Data) |
| where |
| V: VisitMut + ?Sized, |
| { |
| match node { |
| Data::Struct(_binding_0) => { |
| v.visit_data_struct_mut(_binding_0); |
| } |
| Data::Enum(_binding_0) => { |
| v.visit_data_enum_mut(_binding_0); |
| } |
| Data::Union(_binding_0) => { |
| v.visit_data_union_mut(_binding_0); |
| } |
| } |
| } |
| #[cfg(feature = "derive")] |
| pub fn visit_data_enum_mut<V>(v: &mut V, node: &mut DataEnum) |
| where |
| V: VisitMut + ?Sized, |
| { |
| tokens_helper(v, &mut node.enum_token.span); |
| tokens_helper(v, &mut node.brace_token.span); |
| for el in Punctuated::pairs_mut(&mut node.variants) { |
| let (it, p) = el.into_tuple(); |
| v.visit_variant_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| } |
| #[cfg(feature = "derive")] |
| pub fn visit_data_struct_mut<V>(v: &mut V, node: &mut DataStruct) |
| where |
| V: VisitMut + ?Sized, |
| { |
| tokens_helper(v, &mut node.struct_token.span); |
| v.visit_fields_mut(&mut node.fields); |
| if let Some(it) = &mut node.semi_token { |
| tokens_helper(v, &mut it.spans) |
| }; |
| } |
| #[cfg(feature = "derive")] |
| pub fn visit_data_union_mut<V>(v: &mut V, node: &mut DataUnion) |
| where |
| V: VisitMut + ?Sized, |
| { |
| tokens_helper(v, &mut node.union_token.span); |
| v.visit_fields_named_mut(&mut node.fields); |
| } |
| #[cfg(feature = "derive")] |
| pub fn visit_derive_input_mut<V>(v: &mut V, node: &mut DeriveInput) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_visibility_mut(&mut node.vis); |
| v.visit_ident_mut(&mut node.ident); |
| v.visit_generics_mut(&mut node.generics); |
| v.visit_data_mut(&mut node.data); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_expr_mut<V>(v: &mut V, node: &mut Expr) |
| where |
| V: VisitMut + ?Sized, |
| { |
| match node { |
| Expr::Array(_binding_0) => { |
| full!(v.visit_expr_array_mut(_binding_0)); |
| } |
| Expr::Assign(_binding_0) => { |
| full!(v.visit_expr_assign_mut(_binding_0)); |
| } |
| Expr::AssignOp(_binding_0) => { |
| full!(v.visit_expr_assign_op_mut(_binding_0)); |
| } |
| Expr::Async(_binding_0) => { |
| full!(v.visit_expr_async_mut(_binding_0)); |
| } |
| Expr::Await(_binding_0) => { |
| full!(v.visit_expr_await_mut(_binding_0)); |
| } |
| Expr::Binary(_binding_0) => { |
| v.visit_expr_binary_mut(_binding_0); |
| } |
| Expr::Block(_binding_0) => { |
| full!(v.visit_expr_block_mut(_binding_0)); |
| } |
| Expr::Box(_binding_0) => { |
| full!(v.visit_expr_box_mut(_binding_0)); |
| } |
| Expr::Break(_binding_0) => { |
| full!(v.visit_expr_break_mut(_binding_0)); |
| } |
| Expr::Call(_binding_0) => { |
| v.visit_expr_call_mut(_binding_0); |
| } |
| Expr::Cast(_binding_0) => { |
| v.visit_expr_cast_mut(_binding_0); |
| } |
| Expr::Closure(_binding_0) => { |
| full!(v.visit_expr_closure_mut(_binding_0)); |
| } |
| Expr::Continue(_binding_0) => { |
| full!(v.visit_expr_continue_mut(_binding_0)); |
| } |
| Expr::Field(_binding_0) => { |
| v.visit_expr_field_mut(_binding_0); |
| } |
| Expr::ForLoop(_binding_0) => { |
| full!(v.visit_expr_for_loop_mut(_binding_0)); |
| } |
| Expr::Group(_binding_0) => { |
| full!(v.visit_expr_group_mut(_binding_0)); |
| } |
| Expr::If(_binding_0) => { |
| full!(v.visit_expr_if_mut(_binding_0)); |
| } |
| Expr::Index(_binding_0) => { |
| v.visit_expr_index_mut(_binding_0); |
| } |
| Expr::Let(_binding_0) => { |
| full!(v.visit_expr_let_mut(_binding_0)); |
| } |
| Expr::Lit(_binding_0) => { |
| v.visit_expr_lit_mut(_binding_0); |
| } |
| Expr::Loop(_binding_0) => { |
| full!(v.visit_expr_loop_mut(_binding_0)); |
| } |
| Expr::Macro(_binding_0) => { |
| full!(v.visit_expr_macro_mut(_binding_0)); |
| } |
| Expr::Match(_binding_0) => { |
| full!(v.visit_expr_match_mut(_binding_0)); |
| } |
| Expr::MethodCall(_binding_0) => { |
| full!(v.visit_expr_method_call_mut(_binding_0)); |
| } |
| Expr::Paren(_binding_0) => { |
| v.visit_expr_paren_mut(_binding_0); |
| } |
| Expr::Path(_binding_0) => { |
| v.visit_expr_path_mut(_binding_0); |
| } |
| Expr::Range(_binding_0) => { |
| full!(v.visit_expr_range_mut(_binding_0)); |
| } |
| Expr::Reference(_binding_0) => { |
| full!(v.visit_expr_reference_mut(_binding_0)); |
| } |
| Expr::Repeat(_binding_0) => { |
| full!(v.visit_expr_repeat_mut(_binding_0)); |
| } |
| Expr::Return(_binding_0) => { |
| full!(v.visit_expr_return_mut(_binding_0)); |
| } |
| Expr::Struct(_binding_0) => { |
| full!(v.visit_expr_struct_mut(_binding_0)); |
| } |
| Expr::Try(_binding_0) => { |
| full!(v.visit_expr_try_mut(_binding_0)); |
| } |
| Expr::TryBlock(_binding_0) => { |
| full!(v.visit_expr_try_block_mut(_binding_0)); |
| } |
| Expr::Tuple(_binding_0) => { |
| full!(v.visit_expr_tuple_mut(_binding_0)); |
| } |
| Expr::Type(_binding_0) => { |
| full!(v.visit_expr_type_mut(_binding_0)); |
| } |
| Expr::Unary(_binding_0) => { |
| v.visit_expr_unary_mut(_binding_0); |
| } |
| Expr::Unsafe(_binding_0) => { |
| full!(v.visit_expr_unsafe_mut(_binding_0)); |
| } |
| Expr::Verbatim(_binding_0) => { |
| skip!(_binding_0); |
| } |
| Expr::While(_binding_0) => { |
| full!(v.visit_expr_while_mut(_binding_0)); |
| } |
| Expr::Yield(_binding_0) => { |
| full!(v.visit_expr_yield_mut(_binding_0)); |
| } |
| _ => unreachable!(), |
| } |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_expr_array_mut<V>(v: &mut V, node: &mut ExprArray) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| tokens_helper(v, &mut node.bracket_token.span); |
| for el in Punctuated::pairs_mut(&mut node.elems) { |
| let (it, p) = el.into_tuple(); |
| v.visit_expr_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_expr_assign_mut<V>(v: &mut V, node: &mut ExprAssign) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_expr_mut(&mut *node.left); |
| tokens_helper(v, &mut node.eq_token.spans); |
| v.visit_expr_mut(&mut *node.right); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_expr_assign_op_mut<V>(v: &mut V, node: &mut ExprAssignOp) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_expr_mut(&mut *node.left); |
| v.visit_bin_op_mut(&mut node.op); |
| v.visit_expr_mut(&mut *node.right); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_expr_async_mut<V>(v: &mut V, node: &mut ExprAsync) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| tokens_helper(v, &mut node.async_token.span); |
| if let Some(it) = &mut node.capture { |
| tokens_helper(v, &mut it.span) |
| }; |
| v.visit_block_mut(&mut node.block); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_expr_await_mut<V>(v: &mut V, node: &mut ExprAwait) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_expr_mut(&mut *node.base); |
| tokens_helper(v, &mut node.dot_token.spans); |
| tokens_helper(v, &mut node.await_token.span); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_expr_binary_mut<V>(v: &mut V, node: &mut ExprBinary) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_expr_mut(&mut *node.left); |
| v.visit_bin_op_mut(&mut node.op); |
| v.visit_expr_mut(&mut *node.right); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_expr_block_mut<V>(v: &mut V, node: &mut ExprBlock) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| if let Some(it) = &mut node.label { |
| v.visit_label_mut(it) |
| }; |
| v.visit_block_mut(&mut node.block); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_expr_box_mut<V>(v: &mut V, node: &mut ExprBox) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| tokens_helper(v, &mut node.box_token.span); |
| v.visit_expr_mut(&mut *node.expr); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_expr_break_mut<V>(v: &mut V, node: &mut ExprBreak) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| tokens_helper(v, &mut node.break_token.span); |
| if let Some(it) = &mut node.label { |
| v.visit_lifetime_mut(it) |
| }; |
| if let Some(it) = &mut node.expr { |
| v.visit_expr_mut(&mut **it) |
| }; |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_expr_call_mut<V>(v: &mut V, node: &mut ExprCall) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_expr_mut(&mut *node.func); |
| tokens_helper(v, &mut node.paren_token.span); |
| for el in Punctuated::pairs_mut(&mut node.args) { |
| let (it, p) = el.into_tuple(); |
| v.visit_expr_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_expr_cast_mut<V>(v: &mut V, node: &mut ExprCast) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_expr_mut(&mut *node.expr); |
| tokens_helper(v, &mut node.as_token.span); |
| v.visit_type_mut(&mut *node.ty); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_expr_closure_mut<V>(v: &mut V, node: &mut ExprClosure) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| if let Some(it) = &mut node.asyncness { |
| tokens_helper(v, &mut it.span) |
| }; |
| if let Some(it) = &mut node.movability { |
| tokens_helper(v, &mut it.span) |
| }; |
| if let Some(it) = &mut node.capture { |
| tokens_helper(v, &mut it.span) |
| }; |
| tokens_helper(v, &mut node.or1_token.spans); |
| for el in Punctuated::pairs_mut(&mut node.inputs) { |
| let (it, p) = el.into_tuple(); |
| v.visit_pat_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| tokens_helper(v, &mut node.or2_token.spans); |
| v.visit_return_type_mut(&mut node.output); |
| v.visit_expr_mut(&mut *node.body); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_expr_continue_mut<V>(v: &mut V, node: &mut ExprContinue) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| tokens_helper(v, &mut node.continue_token.span); |
| if let Some(it) = &mut node.label { |
| v.visit_lifetime_mut(it) |
| }; |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_expr_field_mut<V>(v: &mut V, node: &mut ExprField) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_expr_mut(&mut *node.base); |
| tokens_helper(v, &mut node.dot_token.spans); |
| v.visit_member_mut(&mut node.member); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_expr_for_loop_mut<V>(v: &mut V, node: &mut ExprForLoop) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| if let Some(it) = &mut node.label { |
| v.visit_label_mut(it) |
| }; |
| tokens_helper(v, &mut node.for_token.span); |
| v.visit_pat_mut(&mut node.pat); |
| tokens_helper(v, &mut node.in_token.span); |
| v.visit_expr_mut(&mut *node.expr); |
| v.visit_block_mut(&mut node.body); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_expr_group_mut<V>(v: &mut V, node: &mut ExprGroup) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| tokens_helper(v, &mut node.group_token.span); |
| v.visit_expr_mut(&mut *node.expr); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_expr_if_mut<V>(v: &mut V, node: &mut ExprIf) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| tokens_helper(v, &mut node.if_token.span); |
| v.visit_expr_mut(&mut *node.cond); |
| v.visit_block_mut(&mut node.then_branch); |
| if let Some(it) = &mut node.else_branch { |
| tokens_helper(v, &mut (it).0.span); |
| v.visit_expr_mut(&mut *(it).1); |
| }; |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_expr_index_mut<V>(v: &mut V, node: &mut ExprIndex) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_expr_mut(&mut *node.expr); |
| tokens_helper(v, &mut node.bracket_token.span); |
| v.visit_expr_mut(&mut *node.index); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_expr_let_mut<V>(v: &mut V, node: &mut ExprLet) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| tokens_helper(v, &mut node.let_token.span); |
| v.visit_pat_mut(&mut node.pat); |
| tokens_helper(v, &mut node.eq_token.spans); |
| v.visit_expr_mut(&mut *node.expr); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_expr_lit_mut<V>(v: &mut V, node: &mut ExprLit) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_lit_mut(&mut node.lit); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_expr_loop_mut<V>(v: &mut V, node: &mut ExprLoop) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| if let Some(it) = &mut node.label { |
| v.visit_label_mut(it) |
| }; |
| tokens_helper(v, &mut node.loop_token.span); |
| v.visit_block_mut(&mut node.body); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_expr_macro_mut<V>(v: &mut V, node: &mut ExprMacro) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_macro_mut(&mut node.mac); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_expr_match_mut<V>(v: &mut V, node: &mut ExprMatch) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| tokens_helper(v, &mut node.match_token.span); |
| v.visit_expr_mut(&mut *node.expr); |
| tokens_helper(v, &mut node.brace_token.span); |
| for it in &mut node.arms { |
| v.visit_arm_mut(it) |
| } |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_expr_method_call_mut<V>(v: &mut V, node: &mut ExprMethodCall) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_expr_mut(&mut *node.receiver); |
| tokens_helper(v, &mut node.dot_token.spans); |
| v.visit_ident_mut(&mut node.method); |
| if let Some(it) = &mut node.turbofish { |
| v.visit_method_turbofish_mut(it) |
| }; |
| tokens_helper(v, &mut node.paren_token.span); |
| for el in Punctuated::pairs_mut(&mut node.args) { |
| let (it, p) = el.into_tuple(); |
| v.visit_expr_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_expr_paren_mut<V>(v: &mut V, node: &mut ExprParen) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| tokens_helper(v, &mut node.paren_token.span); |
| v.visit_expr_mut(&mut *node.expr); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_expr_path_mut<V>(v: &mut V, node: &mut ExprPath) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| if let Some(it) = &mut node.qself { |
| v.visit_qself_mut(it) |
| }; |
| v.visit_path_mut(&mut node.path); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_expr_range_mut<V>(v: &mut V, node: &mut ExprRange) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| if let Some(it) = &mut node.from { |
| v.visit_expr_mut(&mut **it) |
| }; |
| v.visit_range_limits_mut(&mut node.limits); |
| if let Some(it) = &mut node.to { |
| v.visit_expr_mut(&mut **it) |
| }; |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_expr_reference_mut<V>(v: &mut V, node: &mut ExprReference) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| tokens_helper(v, &mut node.and_token.spans); |
| if let Some(it) = &mut node.mutability { |
| tokens_helper(v, &mut it.span) |
| }; |
| v.visit_expr_mut(&mut *node.expr); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_expr_repeat_mut<V>(v: &mut V, node: &mut ExprRepeat) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| tokens_helper(v, &mut node.bracket_token.span); |
| v.visit_expr_mut(&mut *node.expr); |
| tokens_helper(v, &mut node.semi_token.spans); |
| v.visit_expr_mut(&mut *node.len); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_expr_return_mut<V>(v: &mut V, node: &mut ExprReturn) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| tokens_helper(v, &mut node.return_token.span); |
| if let Some(it) = &mut node.expr { |
| v.visit_expr_mut(&mut **it) |
| }; |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_expr_struct_mut<V>(v: &mut V, node: &mut ExprStruct) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_path_mut(&mut node.path); |
| tokens_helper(v, &mut node.brace_token.span); |
| for el in Punctuated::pairs_mut(&mut node.fields) { |
| let (it, p) = el.into_tuple(); |
| v.visit_field_value_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| if let Some(it) = &mut node.dot2_token { |
| tokens_helper(v, &mut it.spans) |
| }; |
| if let Some(it) = &mut node.rest { |
| v.visit_expr_mut(&mut **it) |
| }; |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_expr_try_mut<V>(v: &mut V, node: &mut ExprTry) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_expr_mut(&mut *node.expr); |
| tokens_helper(v, &mut node.question_token.spans); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_expr_try_block_mut<V>(v: &mut V, node: &mut ExprTryBlock) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| tokens_helper(v, &mut node.try_token.span); |
| v.visit_block_mut(&mut node.block); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_expr_tuple_mut<V>(v: &mut V, node: &mut ExprTuple) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| tokens_helper(v, &mut node.paren_token.span); |
| for el in Punctuated::pairs_mut(&mut node.elems) { |
| let (it, p) = el.into_tuple(); |
| v.visit_expr_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_expr_type_mut<V>(v: &mut V, node: &mut ExprType) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_expr_mut(&mut *node.expr); |
| tokens_helper(v, &mut node.colon_token.spans); |
| v.visit_type_mut(&mut *node.ty); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_expr_unary_mut<V>(v: &mut V, node: &mut ExprUnary) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_un_op_mut(&mut node.op); |
| v.visit_expr_mut(&mut *node.expr); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_expr_unsafe_mut<V>(v: &mut V, node: &mut ExprUnsafe) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| tokens_helper(v, &mut node.unsafe_token.span); |
| v.visit_block_mut(&mut node.block); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_expr_while_mut<V>(v: &mut V, node: &mut ExprWhile) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| if let Some(it) = &mut node.label { |
| v.visit_label_mut(it) |
| }; |
| tokens_helper(v, &mut node.while_token.span); |
| v.visit_expr_mut(&mut *node.cond); |
| v.visit_block_mut(&mut node.body); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_expr_yield_mut<V>(v: &mut V, node: &mut ExprYield) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| tokens_helper(v, &mut node.yield_token.span); |
| if let Some(it) = &mut node.expr { |
| v.visit_expr_mut(&mut **it) |
| }; |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_field_mut<V>(v: &mut V, node: &mut Field) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_visibility_mut(&mut node.vis); |
| if let Some(it) = &mut node.ident { |
| v.visit_ident_mut(it) |
| }; |
| if let Some(it) = &mut node.colon_token { |
| tokens_helper(v, &mut it.spans) |
| }; |
| v.visit_type_mut(&mut node.ty); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_field_pat_mut<V>(v: &mut V, node: &mut FieldPat) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_member_mut(&mut node.member); |
| if let Some(it) = &mut node.colon_token { |
| tokens_helper(v, &mut it.spans) |
| }; |
| v.visit_pat_mut(&mut *node.pat); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_field_value_mut<V>(v: &mut V, node: &mut FieldValue) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_member_mut(&mut node.member); |
| if let Some(it) = &mut node.colon_token { |
| tokens_helper(v, &mut it.spans) |
| }; |
| v.visit_expr_mut(&mut node.expr); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_fields_mut<V>(v: &mut V, node: &mut Fields) |
| where |
| V: VisitMut + ?Sized, |
| { |
| match node { |
| Fields::Named(_binding_0) => { |
| v.visit_fields_named_mut(_binding_0); |
| } |
| Fields::Unnamed(_binding_0) => { |
| v.visit_fields_unnamed_mut(_binding_0); |
| } |
| Fields::Unit => {} |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_fields_named_mut<V>(v: &mut V, node: &mut FieldsNamed) |
| where |
| V: VisitMut + ?Sized, |
| { |
| tokens_helper(v, &mut node.brace_token.span); |
| for el in Punctuated::pairs_mut(&mut node.named) { |
| let (it, p) = el.into_tuple(); |
| v.visit_field_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_fields_unnamed_mut<V>(v: &mut V, node: &mut FieldsUnnamed) |
| where |
| V: VisitMut + ?Sized, |
| { |
| tokens_helper(v, &mut node.paren_token.span); |
| for el in Punctuated::pairs_mut(&mut node.unnamed) { |
| let (it, p) = el.into_tuple(); |
| v.visit_field_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_file_mut<V>(v: &mut V, node: &mut File) |
| where |
| V: VisitMut + ?Sized, |
| { |
| skip!(node.shebang); |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| for it in &mut node.items { |
| v.visit_item_mut(it) |
| } |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_fn_arg_mut<V>(v: &mut V, node: &mut FnArg) |
| where |
| V: VisitMut + ?Sized, |
| { |
| match node { |
| FnArg::Receiver(_binding_0) => { |
| v.visit_receiver_mut(_binding_0); |
| } |
| FnArg::Typed(_binding_0) => { |
| v.visit_pat_type_mut(_binding_0); |
| } |
| } |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_foreign_item_mut<V>(v: &mut V, node: &mut ForeignItem) |
| where |
| V: VisitMut + ?Sized, |
| { |
| match node { |
| ForeignItem::Fn(_binding_0) => { |
| v.visit_foreign_item_fn_mut(_binding_0); |
| } |
| ForeignItem::Static(_binding_0) => { |
| v.visit_foreign_item_static_mut(_binding_0); |
| } |
| ForeignItem::Type(_binding_0) => { |
| v.visit_foreign_item_type_mut(_binding_0); |
| } |
| ForeignItem::Macro(_binding_0) => { |
| v.visit_foreign_item_macro_mut(_binding_0); |
| } |
| ForeignItem::Verbatim(_binding_0) => { |
| skip!(_binding_0); |
| } |
| _ => unreachable!(), |
| } |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_foreign_item_fn_mut<V>(v: &mut V, node: &mut ForeignItemFn) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_visibility_mut(&mut node.vis); |
| v.visit_signature_mut(&mut node.sig); |
| tokens_helper(v, &mut node.semi_token.spans); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_foreign_item_macro_mut<V>(v: &mut V, node: &mut ForeignItemMacro) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_macro_mut(&mut node.mac); |
| if let Some(it) = &mut node.semi_token { |
| tokens_helper(v, &mut it.spans) |
| }; |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_foreign_item_static_mut<V>(v: &mut V, node: &mut ForeignItemStatic) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_visibility_mut(&mut node.vis); |
| tokens_helper(v, &mut node.static_token.span); |
| if let Some(it) = &mut node.mutability { |
| tokens_helper(v, &mut it.span) |
| }; |
| v.visit_ident_mut(&mut node.ident); |
| tokens_helper(v, &mut node.colon_token.spans); |
| v.visit_type_mut(&mut *node.ty); |
| tokens_helper(v, &mut node.semi_token.spans); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_foreign_item_type_mut<V>(v: &mut V, node: &mut ForeignItemType) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_visibility_mut(&mut node.vis); |
| tokens_helper(v, &mut node.type_token.span); |
| v.visit_ident_mut(&mut node.ident); |
| tokens_helper(v, &mut node.semi_token.spans); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_generic_argument_mut<V>(v: &mut V, node: &mut GenericArgument) |
| where |
| V: VisitMut + ?Sized, |
| { |
| match node { |
| GenericArgument::Lifetime(_binding_0) => { |
| v.visit_lifetime_mut(_binding_0); |
| } |
| GenericArgument::Type(_binding_0) => { |
| v.visit_type_mut(_binding_0); |
| } |
| GenericArgument::Binding(_binding_0) => { |
| v.visit_binding_mut(_binding_0); |
| } |
| GenericArgument::Constraint(_binding_0) => { |
| v.visit_constraint_mut(_binding_0); |
| } |
| GenericArgument::Const(_binding_0) => { |
| v.visit_expr_mut(_binding_0); |
| } |
| } |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_generic_method_argument_mut<V>(v: &mut V, node: &mut GenericMethodArgument) |
| where |
| V: VisitMut + ?Sized, |
| { |
| match node { |
| GenericMethodArgument::Type(_binding_0) => { |
| v.visit_type_mut(_binding_0); |
| } |
| GenericMethodArgument::Const(_binding_0) => { |
| v.visit_expr_mut(_binding_0); |
| } |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_generic_param_mut<V>(v: &mut V, node: &mut GenericParam) |
| where |
| V: VisitMut + ?Sized, |
| { |
| match node { |
| GenericParam::Type(_binding_0) => { |
| v.visit_type_param_mut(_binding_0); |
| } |
| GenericParam::Lifetime(_binding_0) => { |
| v.visit_lifetime_def_mut(_binding_0); |
| } |
| GenericParam::Const(_binding_0) => { |
| v.visit_const_param_mut(_binding_0); |
| } |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_generics_mut<V>(v: &mut V, node: &mut Generics) |
| where |
| V: VisitMut + ?Sized, |
| { |
| if let Some(it) = &mut node.lt_token { |
| tokens_helper(v, &mut it.spans) |
| }; |
| for el in Punctuated::pairs_mut(&mut node.params) { |
| let (it, p) = el.into_tuple(); |
| v.visit_generic_param_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| if let Some(it) = &mut node.gt_token { |
| tokens_helper(v, &mut it.spans) |
| }; |
| if let Some(it) = &mut node.where_clause { |
| v.visit_where_clause_mut(it) |
| }; |
| } |
| pub fn visit_ident_mut<V>(v: &mut V, node: &mut Ident) |
| where |
| V: VisitMut + ?Sized, |
| { |
| let mut span = node.span(); |
| v.visit_span_mut(&mut span); |
| node.set_span(span); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_impl_item_mut<V>(v: &mut V, node: &mut ImplItem) |
| where |
| V: VisitMut + ?Sized, |
| { |
| match node { |
| ImplItem::Const(_binding_0) => { |
| v.visit_impl_item_const_mut(_binding_0); |
| } |
| ImplItem::Method(_binding_0) => { |
| v.visit_impl_item_method_mut(_binding_0); |
| } |
| ImplItem::Type(_binding_0) => { |
| v.visit_impl_item_type_mut(_binding_0); |
| } |
| ImplItem::Macro(_binding_0) => { |
| v.visit_impl_item_macro_mut(_binding_0); |
| } |
| ImplItem::Verbatim(_binding_0) => { |
| skip!(_binding_0); |
| } |
| _ => unreachable!(), |
| } |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_impl_item_const_mut<V>(v: &mut V, node: &mut ImplItemConst) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_visibility_mut(&mut node.vis); |
| if let Some(it) = &mut node.defaultness { |
| tokens_helper(v, &mut it.span) |
| }; |
| tokens_helper(v, &mut node.const_token.span); |
| v.visit_ident_mut(&mut node.ident); |
| tokens_helper(v, &mut node.colon_token.spans); |
| v.visit_type_mut(&mut node.ty); |
| tokens_helper(v, &mut node.eq_token.spans); |
| v.visit_expr_mut(&mut node.expr); |
| tokens_helper(v, &mut node.semi_token.spans); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_impl_item_macro_mut<V>(v: &mut V, node: &mut ImplItemMacro) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_macro_mut(&mut node.mac); |
| if let Some(it) = &mut node.semi_token { |
| tokens_helper(v, &mut it.spans) |
| }; |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_impl_item_method_mut<V>(v: &mut V, node: &mut ImplItemMethod) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_visibility_mut(&mut node.vis); |
| if let Some(it) = &mut node.defaultness { |
| tokens_helper(v, &mut it.span) |
| }; |
| v.visit_signature_mut(&mut node.sig); |
| v.visit_block_mut(&mut node.block); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_impl_item_type_mut<V>(v: &mut V, node: &mut ImplItemType) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_visibility_mut(&mut node.vis); |
| if let Some(it) = &mut node.defaultness { |
| tokens_helper(v, &mut it.span) |
| }; |
| tokens_helper(v, &mut node.type_token.span); |
| v.visit_ident_mut(&mut node.ident); |
| v.visit_generics_mut(&mut node.generics); |
| tokens_helper(v, &mut node.eq_token.spans); |
| v.visit_type_mut(&mut node.ty); |
| tokens_helper(v, &mut node.semi_token.spans); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_index_mut<V>(v: &mut V, node: &mut Index) |
| where |
| V: VisitMut + ?Sized, |
| { |
| skip!(node.index); |
| v.visit_span_mut(&mut node.span); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_item_mut<V>(v: &mut V, node: &mut Item) |
| where |
| V: VisitMut + ?Sized, |
| { |
| match node { |
| Item::Const(_binding_0) => { |
| v.visit_item_const_mut(_binding_0); |
| } |
| Item::Enum(_binding_0) => { |
| v.visit_item_enum_mut(_binding_0); |
| } |
| Item::ExternCrate(_binding_0) => { |
| v.visit_item_extern_crate_mut(_binding_0); |
| } |
| Item::Fn(_binding_0) => { |
| v.visit_item_fn_mut(_binding_0); |
| } |
| Item::ForeignMod(_binding_0) => { |
| v.visit_item_foreign_mod_mut(_binding_0); |
| } |
| Item::Impl(_binding_0) => { |
| v.visit_item_impl_mut(_binding_0); |
| } |
| Item::Macro(_binding_0) => { |
| v.visit_item_macro_mut(_binding_0); |
| } |
| Item::Macro2(_binding_0) => { |
| v.visit_item_macro2_mut(_binding_0); |
| } |
| Item::Mod(_binding_0) => { |
| v.visit_item_mod_mut(_binding_0); |
| } |
| Item::Static(_binding_0) => { |
| v.visit_item_static_mut(_binding_0); |
| } |
| Item::Struct(_binding_0) => { |
| v.visit_item_struct_mut(_binding_0); |
| } |
| Item::Trait(_binding_0) => { |
| v.visit_item_trait_mut(_binding_0); |
| } |
| Item::TraitAlias(_binding_0) => { |
| v.visit_item_trait_alias_mut(_binding_0); |
| } |
| Item::Type(_binding_0) => { |
| v.visit_item_type_mut(_binding_0); |
| } |
| Item::Union(_binding_0) => { |
| v.visit_item_union_mut(_binding_0); |
| } |
| Item::Use(_binding_0) => { |
| v.visit_item_use_mut(_binding_0); |
| } |
| Item::Verbatim(_binding_0) => { |
| skip!(_binding_0); |
| } |
| _ => unreachable!(), |
| } |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_item_const_mut<V>(v: &mut V, node: &mut ItemConst) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_visibility_mut(&mut node.vis); |
| tokens_helper(v, &mut node.const_token.span); |
| v.visit_ident_mut(&mut node.ident); |
| tokens_helper(v, &mut node.colon_token.spans); |
| v.visit_type_mut(&mut *node.ty); |
| tokens_helper(v, &mut node.eq_token.spans); |
| v.visit_expr_mut(&mut *node.expr); |
| tokens_helper(v, &mut node.semi_token.spans); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_item_enum_mut<V>(v: &mut V, node: &mut ItemEnum) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_visibility_mut(&mut node.vis); |
| tokens_helper(v, &mut node.enum_token.span); |
| v.visit_ident_mut(&mut node.ident); |
| v.visit_generics_mut(&mut node.generics); |
| tokens_helper(v, &mut node.brace_token.span); |
| for el in Punctuated::pairs_mut(&mut node.variants) { |
| let (it, p) = el.into_tuple(); |
| v.visit_variant_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_item_extern_crate_mut<V>(v: &mut V, node: &mut ItemExternCrate) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_visibility_mut(&mut node.vis); |
| tokens_helper(v, &mut node.extern_token.span); |
| tokens_helper(v, &mut node.crate_token.span); |
| v.visit_ident_mut(&mut node.ident); |
| if let Some(it) = &mut node.rename { |
| tokens_helper(v, &mut (it).0.span); |
| v.visit_ident_mut(&mut (it).1); |
| }; |
| tokens_helper(v, &mut node.semi_token.spans); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_item_fn_mut<V>(v: &mut V, node: &mut ItemFn) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_visibility_mut(&mut node.vis); |
| v.visit_signature_mut(&mut node.sig); |
| v.visit_block_mut(&mut *node.block); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_item_foreign_mod_mut<V>(v: &mut V, node: &mut ItemForeignMod) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_abi_mut(&mut node.abi); |
| tokens_helper(v, &mut node.brace_token.span); |
| for it in &mut node.items { |
| v.visit_foreign_item_mut(it) |
| } |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_item_impl_mut<V>(v: &mut V, node: &mut ItemImpl) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| if let Some(it) = &mut node.defaultness { |
| tokens_helper(v, &mut it.span) |
| }; |
| if let Some(it) = &mut node.unsafety { |
| tokens_helper(v, &mut it.span) |
| }; |
| tokens_helper(v, &mut node.impl_token.span); |
| v.visit_generics_mut(&mut node.generics); |
| if let Some(it) = &mut node.trait_ { |
| if let Some(it) = &mut (it).0 { |
| tokens_helper(v, &mut it.spans) |
| }; |
| v.visit_path_mut(&mut (it).1); |
| tokens_helper(v, &mut (it).2.span); |
| }; |
| v.visit_type_mut(&mut *node.self_ty); |
| tokens_helper(v, &mut node.brace_token.span); |
| for it in &mut node.items { |
| v.visit_impl_item_mut(it) |
| } |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_item_macro_mut<V>(v: &mut V, node: &mut ItemMacro) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| if let Some(it) = &mut node.ident { |
| v.visit_ident_mut(it) |
| }; |
| v.visit_macro_mut(&mut node.mac); |
| if let Some(it) = &mut node.semi_token { |
| tokens_helper(v, &mut it.spans) |
| }; |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_item_macro2_mut<V>(v: &mut V, node: &mut ItemMacro2) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_visibility_mut(&mut node.vis); |
| tokens_helper(v, &mut node.macro_token.span); |
| v.visit_ident_mut(&mut node.ident); |
| skip!(node.rules); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_item_mod_mut<V>(v: &mut V, node: &mut ItemMod) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_visibility_mut(&mut node.vis); |
| tokens_helper(v, &mut node.mod_token.span); |
| v.visit_ident_mut(&mut node.ident); |
| if let Some(it) = &mut node.content { |
| tokens_helper(v, &mut (it).0.span); |
| for it in &mut (it).1 { |
| v.visit_item_mut(it) |
| } |
| }; |
| if let Some(it) = &mut node.semi { |
| tokens_helper(v, &mut it.spans) |
| }; |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_item_static_mut<V>(v: &mut V, node: &mut ItemStatic) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_visibility_mut(&mut node.vis); |
| tokens_helper(v, &mut node.static_token.span); |
| if let Some(it) = &mut node.mutability { |
| tokens_helper(v, &mut it.span) |
| }; |
| v.visit_ident_mut(&mut node.ident); |
| tokens_helper(v, &mut node.colon_token.spans); |
| v.visit_type_mut(&mut *node.ty); |
| tokens_helper(v, &mut node.eq_token.spans); |
| v.visit_expr_mut(&mut *node.expr); |
| tokens_helper(v, &mut node.semi_token.spans); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_item_struct_mut<V>(v: &mut V, node: &mut ItemStruct) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_visibility_mut(&mut node.vis); |
| tokens_helper(v, &mut node.struct_token.span); |
| v.visit_ident_mut(&mut node.ident); |
| v.visit_generics_mut(&mut node.generics); |
| v.visit_fields_mut(&mut node.fields); |
| if let Some(it) = &mut node.semi_token { |
| tokens_helper(v, &mut it.spans) |
| }; |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_item_trait_mut<V>(v: &mut V, node: &mut ItemTrait) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_visibility_mut(&mut node.vis); |
| if let Some(it) = &mut node.unsafety { |
| tokens_helper(v, &mut it.span) |
| }; |
| if let Some(it) = &mut node.auto_token { |
| tokens_helper(v, &mut it.span) |
| }; |
| tokens_helper(v, &mut node.trait_token.span); |
| v.visit_ident_mut(&mut node.ident); |
| v.visit_generics_mut(&mut node.generics); |
| if let Some(it) = &mut node.colon_token { |
| tokens_helper(v, &mut it.spans) |
| }; |
| for el in Punctuated::pairs_mut(&mut node.supertraits) { |
| let (it, p) = el.into_tuple(); |
| v.visit_type_param_bound_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| tokens_helper(v, &mut node.brace_token.span); |
| for it in &mut node.items { |
| v.visit_trait_item_mut(it) |
| } |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_item_trait_alias_mut<V>(v: &mut V, node: &mut ItemTraitAlias) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_visibility_mut(&mut node.vis); |
| tokens_helper(v, &mut node.trait_token.span); |
| v.visit_ident_mut(&mut node.ident); |
| v.visit_generics_mut(&mut node.generics); |
| tokens_helper(v, &mut node.eq_token.spans); |
| for el in Punctuated::pairs_mut(&mut node.bounds) { |
| let (it, p) = el.into_tuple(); |
| v.visit_type_param_bound_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| tokens_helper(v, &mut node.semi_token.spans); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_item_type_mut<V>(v: &mut V, node: &mut ItemType) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_visibility_mut(&mut node.vis); |
| tokens_helper(v, &mut node.type_token.span); |
| v.visit_ident_mut(&mut node.ident); |
| v.visit_generics_mut(&mut node.generics); |
| tokens_helper(v, &mut node.eq_token.spans); |
| v.visit_type_mut(&mut *node.ty); |
| tokens_helper(v, &mut node.semi_token.spans); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_item_union_mut<V>(v: &mut V, node: &mut ItemUnion) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_visibility_mut(&mut node.vis); |
| tokens_helper(v, &mut node.union_token.span); |
| v.visit_ident_mut(&mut node.ident); |
| v.visit_generics_mut(&mut node.generics); |
| v.visit_fields_named_mut(&mut node.fields); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_item_use_mut<V>(v: &mut V, node: &mut ItemUse) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_visibility_mut(&mut node.vis); |
| tokens_helper(v, &mut node.use_token.span); |
| if let Some(it) = &mut node.leading_colon { |
| tokens_helper(v, &mut it.spans) |
| }; |
| v.visit_use_tree_mut(&mut node.tree); |
| tokens_helper(v, &mut node.semi_token.spans); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_label_mut<V>(v: &mut V, node: &mut Label) |
| where |
| V: VisitMut + ?Sized, |
| { |
| v.visit_lifetime_mut(&mut node.name); |
| tokens_helper(v, &mut node.colon_token.spans); |
| } |
| pub fn visit_lifetime_mut<V>(v: &mut V, node: &mut Lifetime) |
| where |
| V: VisitMut + ?Sized, |
| { |
| v.visit_span_mut(&mut node.apostrophe); |
| v.visit_ident_mut(&mut node.ident); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_lifetime_def_mut<V>(v: &mut V, node: &mut LifetimeDef) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_lifetime_mut(&mut node.lifetime); |
| if let Some(it) = &mut node.colon_token { |
| tokens_helper(v, &mut it.spans) |
| }; |
| for el in Punctuated::pairs_mut(&mut node.bounds) { |
| let (it, p) = el.into_tuple(); |
| v.visit_lifetime_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| } |
| pub fn visit_lit_mut<V>(v: &mut V, node: &mut Lit) |
| where |
| V: VisitMut + ?Sized, |
| { |
| match node { |
| Lit::Str(_binding_0) => { |
| v.visit_lit_str_mut(_binding_0); |
| } |
| Lit::ByteStr(_binding_0) => { |
| v.visit_lit_byte_str_mut(_binding_0); |
| } |
| Lit::Byte(_binding_0) => { |
| v.visit_lit_byte_mut(_binding_0); |
| } |
| Lit::Char(_binding_0) => { |
| v.visit_lit_char_mut(_binding_0); |
| } |
| Lit::Int(_binding_0) => { |
| v.visit_lit_int_mut(_binding_0); |
| } |
| Lit::Float(_binding_0) => { |
| v.visit_lit_float_mut(_binding_0); |
| } |
| Lit::Bool(_binding_0) => { |
| v.visit_lit_bool_mut(_binding_0); |
| } |
| Lit::Verbatim(_binding_0) => { |
| skip!(_binding_0); |
| } |
| } |
| } |
| pub fn visit_lit_bool_mut<V>(v: &mut V, node: &mut LitBool) |
| where |
| V: VisitMut + ?Sized, |
| { |
| skip!(node.value); |
| v.visit_span_mut(&mut node.span); |
| } |
| pub fn visit_lit_byte_mut<V>(v: &mut V, node: &mut LitByte) |
| where |
| V: VisitMut + ?Sized, |
| { |
| } |
| pub fn visit_lit_byte_str_mut<V>(v: &mut V, node: &mut LitByteStr) |
| where |
| V: VisitMut + ?Sized, |
| { |
| } |
| pub fn visit_lit_char_mut<V>(v: &mut V, node: &mut LitChar) |
| where |
| V: VisitMut + ?Sized, |
| { |
| } |
| pub fn visit_lit_float_mut<V>(v: &mut V, node: &mut LitFloat) |
| where |
| V: VisitMut + ?Sized, |
| { |
| } |
| pub fn visit_lit_int_mut<V>(v: &mut V, node: &mut LitInt) |
| where |
| V: VisitMut + ?Sized, |
| { |
| } |
| pub fn visit_lit_str_mut<V>(v: &mut V, node: &mut LitStr) |
| where |
| V: VisitMut + ?Sized, |
| { |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_local_mut<V>(v: &mut V, node: &mut Local) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| tokens_helper(v, &mut node.let_token.span); |
| v.visit_pat_mut(&mut node.pat); |
| if let Some(it) = &mut node.init { |
| tokens_helper(v, &mut (it).0.spans); |
| v.visit_expr_mut(&mut *(it).1); |
| }; |
| tokens_helper(v, &mut node.semi_token.spans); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_macro_mut<V>(v: &mut V, node: &mut Macro) |
| where |
| V: VisitMut + ?Sized, |
| { |
| v.visit_path_mut(&mut node.path); |
| tokens_helper(v, &mut node.bang_token.spans); |
| v.visit_macro_delimiter_mut(&mut node.delimiter); |
| skip!(node.tokens); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_macro_delimiter_mut<V>(v: &mut V, node: &mut MacroDelimiter) |
| where |
| V: VisitMut + ?Sized, |
| { |
| match node { |
| MacroDelimiter::Paren(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.span); |
| } |
| MacroDelimiter::Brace(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.span); |
| } |
| MacroDelimiter::Bracket(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.span); |
| } |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_member_mut<V>(v: &mut V, node: &mut Member) |
| where |
| V: VisitMut + ?Sized, |
| { |
| match node { |
| Member::Named(_binding_0) => { |
| v.visit_ident_mut(_binding_0); |
| } |
| Member::Unnamed(_binding_0) => { |
| v.visit_index_mut(_binding_0); |
| } |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_meta_mut<V>(v: &mut V, node: &mut Meta) |
| where |
| V: VisitMut + ?Sized, |
| { |
| match node { |
| Meta::Path(_binding_0) => { |
| v.visit_path_mut(_binding_0); |
| } |
| Meta::List(_binding_0) => { |
| v.visit_meta_list_mut(_binding_0); |
| } |
| Meta::NameValue(_binding_0) => { |
| v.visit_meta_name_value_mut(_binding_0); |
| } |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_meta_list_mut<V>(v: &mut V, node: &mut MetaList) |
| where |
| V: VisitMut + ?Sized, |
| { |
| v.visit_path_mut(&mut node.path); |
| tokens_helper(v, &mut node.paren_token.span); |
| for el in Punctuated::pairs_mut(&mut node.nested) { |
| let (it, p) = el.into_tuple(); |
| v.visit_nested_meta_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_meta_name_value_mut<V>(v: &mut V, node: &mut MetaNameValue) |
| where |
| V: VisitMut + ?Sized, |
| { |
| v.visit_path_mut(&mut node.path); |
| tokens_helper(v, &mut node.eq_token.spans); |
| v.visit_lit_mut(&mut node.lit); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_method_turbofish_mut<V>(v: &mut V, node: &mut MethodTurbofish) |
| where |
| V: VisitMut + ?Sized, |
| { |
| tokens_helper(v, &mut node.colon2_token.spans); |
| tokens_helper(v, &mut node.lt_token.spans); |
| for el in Punctuated::pairs_mut(&mut node.args) { |
| let (it, p) = el.into_tuple(); |
| v.visit_generic_method_argument_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| tokens_helper(v, &mut node.gt_token.spans); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_nested_meta_mut<V>(v: &mut V, node: &mut NestedMeta) |
| where |
| V: VisitMut + ?Sized, |
| { |
| match node { |
| NestedMeta::Meta(_binding_0) => { |
| v.visit_meta_mut(_binding_0); |
| } |
| NestedMeta::Lit(_binding_0) => { |
| v.visit_lit_mut(_binding_0); |
| } |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_parenthesized_generic_arguments_mut<V>( |
| v: &mut V, |
| node: &mut ParenthesizedGenericArguments, |
| ) where |
| V: VisitMut + ?Sized, |
| { |
| tokens_helper(v, &mut node.paren_token.span); |
| for el in Punctuated::pairs_mut(&mut node.inputs) { |
| let (it, p) = el.into_tuple(); |
| v.visit_type_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| v.visit_return_type_mut(&mut node.output); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_pat_mut<V>(v: &mut V, node: &mut Pat) |
| where |
| V: VisitMut + ?Sized, |
| { |
| match node { |
| Pat::Box(_binding_0) => { |
| v.visit_pat_box_mut(_binding_0); |
| } |
| Pat::Ident(_binding_0) => { |
| v.visit_pat_ident_mut(_binding_0); |
| } |
| Pat::Lit(_binding_0) => { |
| v.visit_pat_lit_mut(_binding_0); |
| } |
| Pat::Macro(_binding_0) => { |
| v.visit_pat_macro_mut(_binding_0); |
| } |
| Pat::Or(_binding_0) => { |
| v.visit_pat_or_mut(_binding_0); |
| } |
| Pat::Path(_binding_0) => { |
| v.visit_pat_path_mut(_binding_0); |
| } |
| Pat::Range(_binding_0) => { |
| v.visit_pat_range_mut(_binding_0); |
| } |
| Pat::Reference(_binding_0) => { |
| v.visit_pat_reference_mut(_binding_0); |
| } |
| Pat::Rest(_binding_0) => { |
| v.visit_pat_rest_mut(_binding_0); |
| } |
| Pat::Slice(_binding_0) => { |
| v.visit_pat_slice_mut(_binding_0); |
| } |
| Pat::Struct(_binding_0) => { |
| v.visit_pat_struct_mut(_binding_0); |
| } |
| Pat::Tuple(_binding_0) => { |
| v.visit_pat_tuple_mut(_binding_0); |
| } |
| Pat::TupleStruct(_binding_0) => { |
| v.visit_pat_tuple_struct_mut(_binding_0); |
| } |
| Pat::Type(_binding_0) => { |
| v.visit_pat_type_mut(_binding_0); |
| } |
| Pat::Verbatim(_binding_0) => { |
| skip!(_binding_0); |
| } |
| Pat::Wild(_binding_0) => { |
| v.visit_pat_wild_mut(_binding_0); |
| } |
| _ => unreachable!(), |
| } |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_pat_box_mut<V>(v: &mut V, node: &mut PatBox) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| tokens_helper(v, &mut node.box_token.span); |
| v.visit_pat_mut(&mut *node.pat); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_pat_ident_mut<V>(v: &mut V, node: &mut PatIdent) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| if let Some(it) = &mut node.by_ref { |
| tokens_helper(v, &mut it.span) |
| }; |
| if let Some(it) = &mut node.mutability { |
| tokens_helper(v, &mut it.span) |
| }; |
| v.visit_ident_mut(&mut node.ident); |
| if let Some(it) = &mut node.subpat { |
| tokens_helper(v, &mut (it).0.spans); |
| v.visit_pat_mut(&mut *(it).1); |
| }; |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_pat_lit_mut<V>(v: &mut V, node: &mut PatLit) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_expr_mut(&mut *node.expr); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_pat_macro_mut<V>(v: &mut V, node: &mut PatMacro) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_macro_mut(&mut node.mac); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_pat_or_mut<V>(v: &mut V, node: &mut PatOr) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| if let Some(it) = &mut node.leading_vert { |
| tokens_helper(v, &mut it.spans) |
| }; |
| for el in Punctuated::pairs_mut(&mut node.cases) { |
| let (it, p) = el.into_tuple(); |
| v.visit_pat_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_pat_path_mut<V>(v: &mut V, node: &mut PatPath) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| if let Some(it) = &mut node.qself { |
| v.visit_qself_mut(it) |
| }; |
| v.visit_path_mut(&mut node.path); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_pat_range_mut<V>(v: &mut V, node: &mut PatRange) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_expr_mut(&mut *node.lo); |
| v.visit_range_limits_mut(&mut node.limits); |
| v.visit_expr_mut(&mut *node.hi); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_pat_reference_mut<V>(v: &mut V, node: &mut PatReference) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| tokens_helper(v, &mut node.and_token.spans); |
| if let Some(it) = &mut node.mutability { |
| tokens_helper(v, &mut it.span) |
| }; |
| v.visit_pat_mut(&mut *node.pat); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_pat_rest_mut<V>(v: &mut V, node: &mut PatRest) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| tokens_helper(v, &mut node.dot2_token.spans); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_pat_slice_mut<V>(v: &mut V, node: &mut PatSlice) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| tokens_helper(v, &mut node.bracket_token.span); |
| for el in Punctuated::pairs_mut(&mut node.elems) { |
| let (it, p) = el.into_tuple(); |
| v.visit_pat_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_pat_struct_mut<V>(v: &mut V, node: &mut PatStruct) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_path_mut(&mut node.path); |
| tokens_helper(v, &mut node.brace_token.span); |
| for el in Punctuated::pairs_mut(&mut node.fields) { |
| let (it, p) = el.into_tuple(); |
| v.visit_field_pat_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| if let Some(it) = &mut node.dot2_token { |
| tokens_helper(v, &mut it.spans) |
| }; |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_pat_tuple_mut<V>(v: &mut V, node: &mut PatTuple) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| tokens_helper(v, &mut node.paren_token.span); |
| for el in Punctuated::pairs_mut(&mut node.elems) { |
| let (it, p) = el.into_tuple(); |
| v.visit_pat_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_pat_tuple_struct_mut<V>(v: &mut V, node: &mut PatTupleStruct) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_path_mut(&mut node.path); |
| v.visit_pat_tuple_mut(&mut node.pat); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_pat_type_mut<V>(v: &mut V, node: &mut PatType) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_pat_mut(&mut *node.pat); |
| tokens_helper(v, &mut node.colon_token.spans); |
| v.visit_type_mut(&mut *node.ty); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_pat_wild_mut<V>(v: &mut V, node: &mut PatWild) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| tokens_helper(v, &mut node.underscore_token.spans); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_path_mut<V>(v: &mut V, node: &mut Path) |
| where |
| V: VisitMut + ?Sized, |
| { |
| if let Some(it) = &mut node.leading_colon { |
| tokens_helper(v, &mut it.spans) |
| }; |
| for el in Punctuated::pairs_mut(&mut node.segments) { |
| let (it, p) = el.into_tuple(); |
| v.visit_path_segment_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_path_arguments_mut<V>(v: &mut V, node: &mut PathArguments) |
| where |
| V: VisitMut + ?Sized, |
| { |
| match node { |
| PathArguments::None => {} |
| PathArguments::AngleBracketed(_binding_0) => { |
| v.visit_angle_bracketed_generic_arguments_mut(_binding_0); |
| } |
| PathArguments::Parenthesized(_binding_0) => { |
| v.visit_parenthesized_generic_arguments_mut(_binding_0); |
| } |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_path_segment_mut<V>(v: &mut V, node: &mut PathSegment) |
| where |
| V: VisitMut + ?Sized, |
| { |
| v.visit_ident_mut(&mut node.ident); |
| v.visit_path_arguments_mut(&mut node.arguments); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_predicate_eq_mut<V>(v: &mut V, node: &mut PredicateEq) |
| where |
| V: VisitMut + ?Sized, |
| { |
| v.visit_type_mut(&mut node.lhs_ty); |
| tokens_helper(v, &mut node.eq_token.spans); |
| v.visit_type_mut(&mut node.rhs_ty); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_predicate_lifetime_mut<V>(v: &mut V, node: &mut PredicateLifetime) |
| where |
| V: VisitMut + ?Sized, |
| { |
| v.visit_lifetime_mut(&mut node.lifetime); |
| tokens_helper(v, &mut node.colon_token.spans); |
| for el in Punctuated::pairs_mut(&mut node.bounds) { |
| let (it, p) = el.into_tuple(); |
| v.visit_lifetime_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_predicate_type_mut<V>(v: &mut V, node: &mut PredicateType) |
| where |
| V: VisitMut + ?Sized, |
| { |
| if let Some(it) = &mut node.lifetimes { |
| v.visit_bound_lifetimes_mut(it) |
| }; |
| v.visit_type_mut(&mut node.bounded_ty); |
| tokens_helper(v, &mut node.colon_token.spans); |
| for el in Punctuated::pairs_mut(&mut node.bounds) { |
| let (it, p) = el.into_tuple(); |
| v.visit_type_param_bound_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_qself_mut<V>(v: &mut V, node: &mut QSelf) |
| where |
| V: VisitMut + ?Sized, |
| { |
| tokens_helper(v, &mut node.lt_token.spans); |
| v.visit_type_mut(&mut *node.ty); |
| skip!(node.position); |
| if let Some(it) = &mut node.as_token { |
| tokens_helper(v, &mut it.span) |
| }; |
| tokens_helper(v, &mut node.gt_token.spans); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_range_limits_mut<V>(v: &mut V, node: &mut RangeLimits) |
| where |
| V: VisitMut + ?Sized, |
| { |
| match node { |
| RangeLimits::HalfOpen(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| } |
| RangeLimits::Closed(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| } |
| } |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_receiver_mut<V>(v: &mut V, node: &mut Receiver) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| if let Some(it) = &mut node.reference { |
| tokens_helper(v, &mut (it).0.spans); |
| if let Some(it) = &mut (it).1 { |
| v.visit_lifetime_mut(it) |
| }; |
| }; |
| if let Some(it) = &mut node.mutability { |
| tokens_helper(v, &mut it.span) |
| }; |
| tokens_helper(v, &mut node.self_token.span); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_return_type_mut<V>(v: &mut V, node: &mut ReturnType) |
| where |
| V: VisitMut + ?Sized, |
| { |
| match node { |
| ReturnType::Default => {} |
| ReturnType::Type(_binding_0, _binding_1) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| v.visit_type_mut(&mut **_binding_1); |
| } |
| } |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_signature_mut<V>(v: &mut V, node: &mut Signature) |
| where |
| V: VisitMut + ?Sized, |
| { |
| if let Some(it) = &mut node.constness { |
| tokens_helper(v, &mut it.span) |
| }; |
| if let Some(it) = &mut node.asyncness { |
| tokens_helper(v, &mut it.span) |
| }; |
| if let Some(it) = &mut node.unsafety { |
| tokens_helper(v, &mut it.span) |
| }; |
| if let Some(it) = &mut node.abi { |
| v.visit_abi_mut(it) |
| }; |
| tokens_helper(v, &mut node.fn_token.span); |
| v.visit_ident_mut(&mut node.ident); |
| v.visit_generics_mut(&mut node.generics); |
| tokens_helper(v, &mut node.paren_token.span); |
| for el in Punctuated::pairs_mut(&mut node.inputs) { |
| let (it, p) = el.into_tuple(); |
| v.visit_fn_arg_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| if let Some(it) = &mut node.variadic { |
| v.visit_variadic_mut(it) |
| }; |
| v.visit_return_type_mut(&mut node.output); |
| } |
| pub fn visit_span_mut<V>(v: &mut V, node: &mut Span) |
| where |
| V: VisitMut + ?Sized, |
| { |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_stmt_mut<V>(v: &mut V, node: &mut Stmt) |
| where |
| V: VisitMut + ?Sized, |
| { |
| match node { |
| Stmt::Local(_binding_0) => { |
| v.visit_local_mut(_binding_0); |
| } |
| Stmt::Item(_binding_0) => { |
| v.visit_item_mut(_binding_0); |
| } |
| Stmt::Expr(_binding_0) => { |
| v.visit_expr_mut(_binding_0); |
| } |
| Stmt::Semi(_binding_0, _binding_1) => { |
| v.visit_expr_mut(_binding_0); |
| tokens_helper(v, &mut _binding_1.spans); |
| } |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_trait_bound_mut<V>(v: &mut V, node: &mut TraitBound) |
| where |
| V: VisitMut + ?Sized, |
| { |
| if let Some(it) = &mut node.paren_token { |
| tokens_helper(v, &mut it.span) |
| }; |
| v.visit_trait_bound_modifier_mut(&mut node.modifier); |
| if let Some(it) = &mut node.lifetimes { |
| v.visit_bound_lifetimes_mut(it) |
| }; |
| v.visit_path_mut(&mut node.path); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_trait_bound_modifier_mut<V>(v: &mut V, node: &mut TraitBoundModifier) |
| where |
| V: VisitMut + ?Sized, |
| { |
| match node { |
| TraitBoundModifier::None => {} |
| TraitBoundModifier::Maybe(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| } |
| } |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_trait_item_mut<V>(v: &mut V, node: &mut TraitItem) |
| where |
| V: VisitMut + ?Sized, |
| { |
| match node { |
| TraitItem::Const(_binding_0) => { |
| v.visit_trait_item_const_mut(_binding_0); |
| } |
| TraitItem::Method(_binding_0) => { |
| v.visit_trait_item_method_mut(_binding_0); |
| } |
| TraitItem::Type(_binding_0) => { |
| v.visit_trait_item_type_mut(_binding_0); |
| } |
| TraitItem::Macro(_binding_0) => { |
| v.visit_trait_item_macro_mut(_binding_0); |
| } |
| TraitItem::Verbatim(_binding_0) => { |
| skip!(_binding_0); |
| } |
| _ => unreachable!(), |
| } |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_trait_item_const_mut<V>(v: &mut V, node: &mut TraitItemConst) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| tokens_helper(v, &mut node.const_token.span); |
| v.visit_ident_mut(&mut node.ident); |
| tokens_helper(v, &mut node.colon_token.spans); |
| v.visit_type_mut(&mut node.ty); |
| if let Some(it) = &mut node.default { |
| tokens_helper(v, &mut (it).0.spans); |
| v.visit_expr_mut(&mut (it).1); |
| }; |
| tokens_helper(v, &mut node.semi_token.spans); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_trait_item_macro_mut<V>(v: &mut V, node: &mut TraitItemMacro) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_macro_mut(&mut node.mac); |
| if let Some(it) = &mut node.semi_token { |
| tokens_helper(v, &mut it.spans) |
| }; |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_trait_item_method_mut<V>(v: &mut V, node: &mut TraitItemMethod) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_signature_mut(&mut node.sig); |
| if let Some(it) = &mut node.default { |
| v.visit_block_mut(it) |
| }; |
| if let Some(it) = &mut node.semi_token { |
| tokens_helper(v, &mut it.spans) |
| }; |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_trait_item_type_mut<V>(v: &mut V, node: &mut TraitItemType) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| tokens_helper(v, &mut node.type_token.span); |
| v.visit_ident_mut(&mut node.ident); |
| v.visit_generics_mut(&mut node.generics); |
| if let Some(it) = &mut node.colon_token { |
| tokens_helper(v, &mut it.spans) |
| }; |
| for el in Punctuated::pairs_mut(&mut node.bounds) { |
| let (it, p) = el.into_tuple(); |
| v.visit_type_param_bound_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| if let Some(it) = &mut node.default { |
| tokens_helper(v, &mut (it).0.spans); |
| v.visit_type_mut(&mut (it).1); |
| }; |
| tokens_helper(v, &mut node.semi_token.spans); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_type_mut<V>(v: &mut V, node: &mut Type) |
| where |
| V: VisitMut + ?Sized, |
| { |
| match node { |
| Type::Array(_binding_0) => { |
| v.visit_type_array_mut(_binding_0); |
| } |
| Type::BareFn(_binding_0) => { |
| v.visit_type_bare_fn_mut(_binding_0); |
| } |
| Type::Group(_binding_0) => { |
| v.visit_type_group_mut(_binding_0); |
| } |
| Type::ImplTrait(_binding_0) => { |
| v.visit_type_impl_trait_mut(_binding_0); |
| } |
| Type::Infer(_binding_0) => { |
| v.visit_type_infer_mut(_binding_0); |
| } |
| Type::Macro(_binding_0) => { |
| v.visit_type_macro_mut(_binding_0); |
| } |
| Type::Never(_binding_0) => { |
| v.visit_type_never_mut(_binding_0); |
| } |
| Type::Paren(_binding_0) => { |
| v.visit_type_paren_mut(_binding_0); |
| } |
| Type::Path(_binding_0) => { |
| v.visit_type_path_mut(_binding_0); |
| } |
| Type::Ptr(_binding_0) => { |
| v.visit_type_ptr_mut(_binding_0); |
| } |
| Type::Reference(_binding_0) => { |
| v.visit_type_reference_mut(_binding_0); |
| } |
| Type::Slice(_binding_0) => { |
| v.visit_type_slice_mut(_binding_0); |
| } |
| Type::TraitObject(_binding_0) => { |
| v.visit_type_trait_object_mut(_binding_0); |
| } |
| Type::Tuple(_binding_0) => { |
| v.visit_type_tuple_mut(_binding_0); |
| } |
| Type::Verbatim(_binding_0) => { |
| skip!(_binding_0); |
| } |
| _ => unreachable!(), |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_type_array_mut<V>(v: &mut V, node: &mut TypeArray) |
| where |
| V: VisitMut + ?Sized, |
| { |
| tokens_helper(v, &mut node.bracket_token.span); |
| v.visit_type_mut(&mut *node.elem); |
| tokens_helper(v, &mut node.semi_token.spans); |
| v.visit_expr_mut(&mut node.len); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_type_bare_fn_mut<V>(v: &mut V, node: &mut TypeBareFn) |
| where |
| V: VisitMut + ?Sized, |
| { |
| if let Some(it) = &mut node.lifetimes { |
| v.visit_bound_lifetimes_mut(it) |
| }; |
| if let Some(it) = &mut node.unsafety { |
| tokens_helper(v, &mut it.span) |
| }; |
| if let Some(it) = &mut node.abi { |
| v.visit_abi_mut(it) |
| }; |
| tokens_helper(v, &mut node.fn_token.span); |
| tokens_helper(v, &mut node.paren_token.span); |
| for el in Punctuated::pairs_mut(&mut node.inputs) { |
| let (it, p) = el.into_tuple(); |
| v.visit_bare_fn_arg_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| if let Some(it) = &mut node.variadic { |
| v.visit_variadic_mut(it) |
| }; |
| v.visit_return_type_mut(&mut node.output); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_type_group_mut<V>(v: &mut V, node: &mut TypeGroup) |
| where |
| V: VisitMut + ?Sized, |
| { |
| tokens_helper(v, &mut node.group_token.span); |
| v.visit_type_mut(&mut *node.elem); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_type_impl_trait_mut<V>(v: &mut V, node: &mut TypeImplTrait) |
| where |
| V: VisitMut + ?Sized, |
| { |
| tokens_helper(v, &mut node.impl_token.span); |
| for el in Punctuated::pairs_mut(&mut node.bounds) { |
| let (it, p) = el.into_tuple(); |
| v.visit_type_param_bound_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_type_infer_mut<V>(v: &mut V, node: &mut TypeInfer) |
| where |
| V: VisitMut + ?Sized, |
| { |
| tokens_helper(v, &mut node.underscore_token.spans); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_type_macro_mut<V>(v: &mut V, node: &mut TypeMacro) |
| where |
| V: VisitMut + ?Sized, |
| { |
| v.visit_macro_mut(&mut node.mac); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_type_never_mut<V>(v: &mut V, node: &mut TypeNever) |
| where |
| V: VisitMut + ?Sized, |
| { |
| tokens_helper(v, &mut node.bang_token.spans); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_type_param_mut<V>(v: &mut V, node: &mut TypeParam) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_ident_mut(&mut node.ident); |
| if let Some(it) = &mut node.colon_token { |
| tokens_helper(v, &mut it.spans) |
| }; |
| for el in Punctuated::pairs_mut(&mut node.bounds) { |
| let (it, p) = el.into_tuple(); |
| v.visit_type_param_bound_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| if let Some(it) = &mut node.eq_token { |
| tokens_helper(v, &mut it.spans) |
| }; |
| if let Some(it) = &mut node.default { |
| v.visit_type_mut(it) |
| }; |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_type_param_bound_mut<V>(v: &mut V, node: &mut TypeParamBound) |
| where |
| V: VisitMut + ?Sized, |
| { |
| match node { |
| TypeParamBound::Trait(_binding_0) => { |
| v.visit_trait_bound_mut(_binding_0); |
| } |
| TypeParamBound::Lifetime(_binding_0) => { |
| v.visit_lifetime_mut(_binding_0); |
| } |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_type_paren_mut<V>(v: &mut V, node: &mut TypeParen) |
| where |
| V: VisitMut + ?Sized, |
| { |
| tokens_helper(v, &mut node.paren_token.span); |
| v.visit_type_mut(&mut *node.elem); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_type_path_mut<V>(v: &mut V, node: &mut TypePath) |
| where |
| V: VisitMut + ?Sized, |
| { |
| if let Some(it) = &mut node.qself { |
| v.visit_qself_mut(it) |
| }; |
| v.visit_path_mut(&mut node.path); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_type_ptr_mut<V>(v: &mut V, node: &mut TypePtr) |
| where |
| V: VisitMut + ?Sized, |
| { |
| tokens_helper(v, &mut node.star_token.spans); |
| if let Some(it) = &mut node.const_token { |
| tokens_helper(v, &mut it.span) |
| }; |
| if let Some(it) = &mut node.mutability { |
| tokens_helper(v, &mut it.span) |
| }; |
| v.visit_type_mut(&mut *node.elem); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_type_reference_mut<V>(v: &mut V, node: &mut TypeReference) |
| where |
| V: VisitMut + ?Sized, |
| { |
| tokens_helper(v, &mut node.and_token.spans); |
| if let Some(it) = &mut node.lifetime { |
| v.visit_lifetime_mut(it) |
| }; |
| if let Some(it) = &mut node.mutability { |
| tokens_helper(v, &mut it.span) |
| }; |
| v.visit_type_mut(&mut *node.elem); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_type_slice_mut<V>(v: &mut V, node: &mut TypeSlice) |
| where |
| V: VisitMut + ?Sized, |
| { |
| tokens_helper(v, &mut node.bracket_token.span); |
| v.visit_type_mut(&mut *node.elem); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_type_trait_object_mut<V>(v: &mut V, node: &mut TypeTraitObject) |
| where |
| V: VisitMut + ?Sized, |
| { |
| if let Some(it) = &mut node.dyn_token { |
| tokens_helper(v, &mut it.span) |
| }; |
| for el in Punctuated::pairs_mut(&mut node.bounds) { |
| let (it, p) = el.into_tuple(); |
| v.visit_type_param_bound_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_type_tuple_mut<V>(v: &mut V, node: &mut TypeTuple) |
| where |
| V: VisitMut + ?Sized, |
| { |
| tokens_helper(v, &mut node.paren_token.span); |
| for el in Punctuated::pairs_mut(&mut node.elems) { |
| let (it, p) = el.into_tuple(); |
| v.visit_type_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_un_op_mut<V>(v: &mut V, node: &mut UnOp) |
| where |
| V: VisitMut + ?Sized, |
| { |
| match node { |
| UnOp::Deref(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| } |
| UnOp::Not(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| } |
| UnOp::Neg(_binding_0) => { |
| tokens_helper(v, &mut _binding_0.spans); |
| } |
| } |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_use_glob_mut<V>(v: &mut V, node: &mut UseGlob) |
| where |
| V: VisitMut + ?Sized, |
| { |
| tokens_helper(v, &mut node.star_token.spans); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_use_group_mut<V>(v: &mut V, node: &mut UseGroup) |
| where |
| V: VisitMut + ?Sized, |
| { |
| tokens_helper(v, &mut node.brace_token.span); |
| for el in Punctuated::pairs_mut(&mut node.items) { |
| let (it, p) = el.into_tuple(); |
| v.visit_use_tree_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_use_name_mut<V>(v: &mut V, node: &mut UseName) |
| where |
| V: VisitMut + ?Sized, |
| { |
| v.visit_ident_mut(&mut node.ident); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_use_path_mut<V>(v: &mut V, node: &mut UsePath) |
| where |
| V: VisitMut + ?Sized, |
| { |
| v.visit_ident_mut(&mut node.ident); |
| tokens_helper(v, &mut node.colon2_token.spans); |
| v.visit_use_tree_mut(&mut *node.tree); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_use_rename_mut<V>(v: &mut V, node: &mut UseRename) |
| where |
| V: VisitMut + ?Sized, |
| { |
| v.visit_ident_mut(&mut node.ident); |
| tokens_helper(v, &mut node.as_token.span); |
| v.visit_ident_mut(&mut node.rename); |
| } |
| #[cfg(feature = "full")] |
| pub fn visit_use_tree_mut<V>(v: &mut V, node: &mut UseTree) |
| where |
| V: VisitMut + ?Sized, |
| { |
| match node { |
| UseTree::Path(_binding_0) => { |
| v.visit_use_path_mut(_binding_0); |
| } |
| UseTree::Name(_binding_0) => { |
| v.visit_use_name_mut(_binding_0); |
| } |
| UseTree::Rename(_binding_0) => { |
| v.visit_use_rename_mut(_binding_0); |
| } |
| UseTree::Glob(_binding_0) => { |
| v.visit_use_glob_mut(_binding_0); |
| } |
| UseTree::Group(_binding_0) => { |
| v.visit_use_group_mut(_binding_0); |
| } |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_variadic_mut<V>(v: &mut V, node: &mut Variadic) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| tokens_helper(v, &mut node.dots.spans); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_variant_mut<V>(v: &mut V, node: &mut Variant) |
| where |
| V: VisitMut + ?Sized, |
| { |
| for it in &mut node.attrs { |
| v.visit_attribute_mut(it) |
| } |
| v.visit_ident_mut(&mut node.ident); |
| v.visit_fields_mut(&mut node.fields); |
| if let Some(it) = &mut node.discriminant { |
| tokens_helper(v, &mut (it).0.spans); |
| v.visit_expr_mut(&mut (it).1); |
| }; |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_vis_crate_mut<V>(v: &mut V, node: &mut VisCrate) |
| where |
| V: VisitMut + ?Sized, |
| { |
| tokens_helper(v, &mut node.crate_token.span); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_vis_public_mut<V>(v: &mut V, node: &mut VisPublic) |
| where |
| V: VisitMut + ?Sized, |
| { |
| tokens_helper(v, &mut node.pub_token.span); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_vis_restricted_mut<V>(v: &mut V, node: &mut VisRestricted) |
| where |
| V: VisitMut + ?Sized, |
| { |
| tokens_helper(v, &mut node.pub_token.span); |
| tokens_helper(v, &mut node.paren_token.span); |
| if let Some(it) = &mut node.in_token { |
| tokens_helper(v, &mut it.span) |
| }; |
| v.visit_path_mut(&mut *node.path); |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_visibility_mut<V>(v: &mut V, node: &mut Visibility) |
| where |
| V: VisitMut + ?Sized, |
| { |
| match node { |
| Visibility::Public(_binding_0) => { |
| v.visit_vis_public_mut(_binding_0); |
| } |
| Visibility::Crate(_binding_0) => { |
| v.visit_vis_crate_mut(_binding_0); |
| } |
| Visibility::Restricted(_binding_0) => { |
| v.visit_vis_restricted_mut(_binding_0); |
| } |
| Visibility::Inherited => {} |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_where_clause_mut<V>(v: &mut V, node: &mut WhereClause) |
| where |
| V: VisitMut + ?Sized, |
| { |
| tokens_helper(v, &mut node.where_token.span); |
| for el in Punctuated::pairs_mut(&mut node.predicates) { |
| let (it, p) = el.into_tuple(); |
| v.visit_where_predicate_mut(it); |
| if let Some(p) = p { |
| tokens_helper(v, &mut p.spans); |
| } |
| } |
| } |
| #[cfg(any(feature = "derive", feature = "full"))] |
| pub fn visit_where_predicate_mut<V>(v: &mut V, node: &mut WherePredicate) |
| where |
| V: VisitMut + ?Sized, |
| { |
| match node { |
| WherePredicate::Type(_binding_0) => { |
| v.visit_predicate_type_mut(_binding_0); |
| } |
| WherePredicate::Lifetime(_binding_0) => { |
| v.visit_predicate_lifetime_mut(_binding_0); |
| } |
| WherePredicate::Eq(_binding_0) => { |
| v.visit_predicate_eq_mut(_binding_0); |
| } |
| } |
| } |
