blob: 4668c9b8e0343c189046cbd2b8e946f995f967c3 [file] [log] [blame]
// THIS FILE IS AUTOMATICALLY GENERATED; DO NOT EDIT
#![cfg_attr(feature = "cargo-clippy", allow(match_same_arms))]
#[cfg(any(feature = "full", feature = "derive"))]
use gen::helper::visit_mut::*;
use proc_macro2::Span;
#[cfg(any(feature = "full", feature = "derive"))]
use punctuated::Punctuated;
use *;
#[cfg(feature = "full")]
macro_rules! full {
($e:expr) => {
$e
};
}
#[cfg(all(feature = "derive", not(feature = "full")))]
macro_rules! full {
($e:expr) => {
unreachable!()
};
}
#[cfg(any(feature = "full", feature = "derive"))]
macro_rules! skip {
($($tt:tt)*) => {};
}
#[doc = r" Syntax tree traversal to mutate an exclusive borrow of a syntax tree in"]
#[doc = r" place."]
#[doc = r""]
#[doc = r" See the [module documentation] for details."]
#[doc = r""]
#[doc = r" [module documentation]: index.html"]
#[doc = r""]
#[doc = r#" *This trait is available if Syn is built with the `"visit-mut"` feature.*"#]
pub trait VisitMut {
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_abi_mut(&mut self, i: &mut Abi) {
visit_abi_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
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_arg_captured_mut(&mut self, i: &mut ArgCaptured) {
visit_arg_captured_mut(self, i)
}
#[cfg(feature = "full")]
fn visit_arg_self_mut(&mut self, i: &mut ArgSelf) {
visit_arg_self_mut(self, i)
}
#[cfg(feature = "full")]
fn visit_arg_self_ref_mut(&mut self, i: &mut ArgSelfRef) {
visit_arg_self_ref_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
#[cfg(feature = "full")]
fn visit_arm_mut(&mut self, i: &mut Arm) {
visit_arm_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_attr_style_mut(&mut self, i: &mut AttrStyle) {
visit_attr_style_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_attribute_mut(&mut self, i: &mut Attribute) {
visit_attribute_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_bare_fn_arg_mut(&mut self, i: &mut BareFnArg) {
visit_bare_fn_arg_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_bare_fn_arg_name_mut(&mut self, i: &mut BareFnArgName) {
visit_bare_fn_arg_name_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_bin_op_mut(&mut self, i: &mut BinOp) {
visit_bin_op_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_binding_mut(&mut self, i: &mut Binding) {
visit_binding_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
#[cfg(feature = "full")]
fn visit_block_mut(&mut self, i: &mut Block) {
visit_block_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_bound_lifetimes_mut(&mut self, i: &mut BoundLifetimes) {
visit_bound_lifetimes_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_const_param_mut(&mut self, i: &mut ConstParam) {
visit_const_param_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
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 = "full", feature = "derive"))]
fn visit_expr_mut(&mut self, i: &mut Expr) {
visit_expr_mut(self, i)
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_array_mut(&mut self, i: &mut ExprArray) {
visit_expr_array_mut(self, i)
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_assign_mut(&mut self, i: &mut ExprAssign) {
visit_expr_assign_mut(self, i)
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_assign_op_mut(&mut self, i: &mut ExprAssignOp) {
visit_expr_assign_op_mut(self, i)
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_async_mut(&mut self, i: &mut ExprAsync) {
visit_expr_async_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_binary_mut(&mut self, i: &mut ExprBinary) {
visit_expr_binary_mut(self, i)
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_block_mut(&mut self, i: &mut ExprBlock) {
visit_expr_block_mut(self, i)
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_box_mut(&mut self, i: &mut ExprBox) {
visit_expr_box_mut(self, i)
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_break_mut(&mut self, i: &mut ExprBreak) {
visit_expr_break_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_call_mut(&mut self, i: &mut ExprCall) {
visit_expr_call_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_cast_mut(&mut self, i: &mut ExprCast) {
visit_expr_cast_mut(self, i)
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_closure_mut(&mut self, i: &mut ExprClosure) {
visit_expr_closure_mut(self, i)
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_continue_mut(&mut self, i: &mut ExprContinue) {
visit_expr_continue_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_field_mut(&mut self, i: &mut ExprField) {
visit_expr_field_mut(self, i)
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_for_loop_mut(&mut self, i: &mut ExprForLoop) {
visit_expr_for_loop_mut(self, i)
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_group_mut(&mut self, i: &mut ExprGroup) {
visit_expr_group_mut(self, i)
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_if_mut(&mut self, i: &mut ExprIf) {
visit_expr_if_mut(self, i)
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_in_place_mut(&mut self, i: &mut ExprInPlace) {
visit_expr_in_place_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_index_mut(&mut self, i: &mut ExprIndex) {
visit_expr_index_mut(self, i)
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_let_mut(&mut self, i: &mut ExprLet) {
visit_expr_let_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_lit_mut(&mut self, i: &mut ExprLit) {
visit_expr_lit_mut(self, i)
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_loop_mut(&mut self, i: &mut ExprLoop) {
visit_expr_loop_mut(self, i)
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_macro_mut(&mut self, i: &mut ExprMacro) {
visit_expr_macro_mut(self, i)
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_match_mut(&mut self, i: &mut ExprMatch) {
visit_expr_match_mut(self, i)
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_method_call_mut(&mut self, i: &mut ExprMethodCall) {
visit_expr_method_call_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_paren_mut(&mut self, i: &mut ExprParen) {
visit_expr_paren_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_path_mut(&mut self, i: &mut ExprPath) {
visit_expr_path_mut(self, i)
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_range_mut(&mut self, i: &mut ExprRange) {
visit_expr_range_mut(self, i)
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_reference_mut(&mut self, i: &mut ExprReference) {
visit_expr_reference_mut(self, i)
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_repeat_mut(&mut self, i: &mut ExprRepeat) {
visit_expr_repeat_mut(self, i)
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_return_mut(&mut self, i: &mut ExprReturn) {
visit_expr_return_mut(self, i)
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_struct_mut(&mut self, i: &mut ExprStruct) {
visit_expr_struct_mut(self, i)
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_try_mut(&mut self, i: &mut ExprTry) {
visit_expr_try_mut(self, i)
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_try_block_mut(&mut self, i: &mut ExprTryBlock) {
visit_expr_try_block_mut(self, i)
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_tuple_mut(&mut self, i: &mut ExprTuple) {
visit_expr_tuple_mut(self, i)
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_type_mut(&mut self, i: &mut ExprType) {
visit_expr_type_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_unary_mut(&mut self, i: &mut ExprUnary) {
visit_expr_unary_mut(self, i)
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_unsafe_mut(&mut self, i: &mut ExprUnsafe) {
visit_expr_unsafe_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_verbatim_mut(&mut self, i: &mut ExprVerbatim) {
visit_expr_verbatim_mut(self, i)
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_while_mut(&mut self, i: &mut ExprWhile) {
visit_expr_while_mut(self, i)
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_expr_yield_mut(&mut self, i: &mut ExprYield) {
visit_expr_yield_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_field_mut(&mut self, i: &mut Field) {
visit_field_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
#[cfg(feature = "full")]
fn visit_field_pat_mut(&mut self, i: &mut FieldPat) {
visit_field_pat_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
#[cfg(feature = "full")]
fn visit_field_value_mut(&mut self, i: &mut FieldValue) {
visit_field_value_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_fields_mut(&mut self, i: &mut Fields) {
visit_fields_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_fields_named_mut(&mut self, i: &mut FieldsNamed) {
visit_fields_named_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
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_fn_decl_mut(&mut self, i: &mut FnDecl) {
visit_fn_decl_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(feature = "full")]
fn visit_foreign_item_verbatim_mut(&mut self, i: &mut ForeignItemVerbatim) {
visit_foreign_item_verbatim_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_generic_argument_mut(&mut self, i: &mut GenericArgument) {
visit_generic_argument_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
#[cfg(feature = "full")]
fn visit_generic_method_argument_mut(&mut self, i: &mut GenericMethodArgument) {
visit_generic_method_argument_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_generic_param_mut(&mut self, i: &mut GenericParam) {
visit_generic_param_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
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_existential_mut(&mut self, i: &mut ImplItemExistential) {
visit_impl_item_existential_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(feature = "full")]
fn visit_impl_item_verbatim_mut(&mut self, i: &mut ImplItemVerbatim) {
visit_impl_item_verbatim_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
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_existential_mut(&mut self, i: &mut ItemExistential) {
visit_item_existential_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_item_verbatim_mut(&mut self, i: &mut ItemVerbatim) {
visit_item_verbatim_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
#[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 = "full", feature = "derive"))]
fn visit_lifetime_def_mut(&mut self, i: &mut LifetimeDef) {
visit_lifetime_def_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_lit_mut(&mut self, i: &mut Lit) {
visit_lit_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_lit_bool_mut(&mut self, i: &mut LitBool) {
visit_lit_bool_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_lit_byte_mut(&mut self, i: &mut LitByte) {
visit_lit_byte_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_lit_byte_str_mut(&mut self, i: &mut LitByteStr) {
visit_lit_byte_str_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_lit_char_mut(&mut self, i: &mut LitChar) {
visit_lit_char_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_lit_float_mut(&mut self, i: &mut LitFloat) {
visit_lit_float_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_lit_int_mut(&mut self, i: &mut LitInt) {
visit_lit_int_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_lit_str_mut(&mut self, i: &mut LitStr) {
visit_lit_str_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_lit_verbatim_mut(&mut self, i: &mut LitVerbatim) {
visit_lit_verbatim_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
#[cfg(feature = "full")]
fn visit_local_mut(&mut self, i: &mut Local) {
visit_local_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_macro_mut(&mut self, i: &mut Macro) {
visit_macro_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_macro_delimiter_mut(&mut self, i: &mut MacroDelimiter) {
visit_macro_delimiter_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_member_mut(&mut self, i: &mut Member) {
visit_member_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_meta_mut(&mut self, i: &mut Meta) {
visit_meta_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_meta_list_mut(&mut self, i: &mut MetaList) {
visit_meta_list_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_meta_name_value_mut(&mut self, i: &mut MetaNameValue) {
visit_meta_name_value_mut(self, i)
}
#[cfg(feature = "full")]
fn visit_method_sig_mut(&mut self, i: &mut MethodSig) {
visit_method_sig_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
#[cfg(feature = "full")]
fn visit_method_turbofish_mut(&mut self, i: &mut MethodTurbofish) {
visit_method_turbofish_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_nested_meta_mut(&mut self, i: &mut NestedMeta) {
visit_nested_meta_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_parenthesized_generic_arguments_mut(&mut self, i: &mut ParenthesizedGenericArguments) {
visit_parenthesized_generic_arguments_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
#[cfg(feature = "full")]
fn visit_pat_mut(&mut self, i: &mut Pat) {
visit_pat_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
#[cfg(feature = "full")]
fn visit_pat_box_mut(&mut self, i: &mut PatBox) {
visit_pat_box_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
#[cfg(feature = "full")]
fn visit_pat_ident_mut(&mut self, i: &mut PatIdent) {
visit_pat_ident_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
#[cfg(feature = "full")]
fn visit_pat_lit_mut(&mut self, i: &mut PatLit) {
visit_pat_lit_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
#[cfg(feature = "full")]
fn visit_pat_macro_mut(&mut self, i: &mut PatMacro) {
visit_pat_macro_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
#[cfg(feature = "full")]
fn visit_pat_path_mut(&mut self, i: &mut PatPath) {
visit_pat_path_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
#[cfg(feature = "full")]
fn visit_pat_range_mut(&mut self, i: &mut PatRange) {
visit_pat_range_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
#[cfg(feature = "full")]
fn visit_pat_ref_mut(&mut self, i: &mut PatRef) {
visit_pat_ref_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
#[cfg(feature = "full")]
fn visit_pat_slice_mut(&mut self, i: &mut PatSlice) {
visit_pat_slice_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
#[cfg(feature = "full")]
fn visit_pat_struct_mut(&mut self, i: &mut PatStruct) {
visit_pat_struct_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
#[cfg(feature = "full")]
fn visit_pat_tuple_mut(&mut self, i: &mut PatTuple) {
visit_pat_tuple_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
#[cfg(feature = "full")]
fn visit_pat_tuple_struct_mut(&mut self, i: &mut PatTupleStruct) {
visit_pat_tuple_struct_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
#[cfg(feature = "full")]
fn visit_pat_verbatim_mut(&mut self, i: &mut PatVerbatim) {
visit_pat_verbatim_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
#[cfg(feature = "full")]
fn visit_pat_wild_mut(&mut self, i: &mut PatWild) {
visit_pat_wild_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_path_mut(&mut self, i: &mut Path) {
visit_path_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_path_arguments_mut(&mut self, i: &mut PathArguments) {
visit_path_arguments_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_path_segment_mut(&mut self, i: &mut PathSegment) {
visit_path_segment_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_predicate_eq_mut(&mut self, i: &mut PredicateEq) {
visit_predicate_eq_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_predicate_lifetime_mut(&mut self, i: &mut PredicateLifetime) {
visit_predicate_lifetime_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_predicate_type_mut(&mut self, i: &mut PredicateType) {
visit_predicate_type_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_qself_mut(&mut self, i: &mut QSelf) {
visit_qself_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
#[cfg(feature = "full")]
fn visit_range_limits_mut(&mut self, i: &mut RangeLimits) {
visit_range_limits_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_return_type_mut(&mut self, i: &mut ReturnType) {
visit_return_type_mut(self, i)
}
fn visit_span_mut(&mut self, i: &mut Span) {
visit_span_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
#[cfg(feature = "full")]
fn visit_stmt_mut(&mut self, i: &mut Stmt) {
visit_stmt_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_trait_bound_mut(&mut self, i: &mut TraitBound) {
visit_trait_bound_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
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(feature = "full")]
fn visit_trait_item_verbatim_mut(&mut self, i: &mut TraitItemVerbatim) {
visit_trait_item_verbatim_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_type_mut(&mut self, i: &mut Type) {
visit_type_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_type_array_mut(&mut self, i: &mut TypeArray) {
visit_type_array_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_type_bare_fn_mut(&mut self, i: &mut TypeBareFn) {
visit_type_bare_fn_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_type_group_mut(&mut self, i: &mut TypeGroup) {
visit_type_group_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_type_impl_trait_mut(&mut self, i: &mut TypeImplTrait) {
visit_type_impl_trait_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_type_infer_mut(&mut self, i: &mut TypeInfer) {
visit_type_infer_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_type_macro_mut(&mut self, i: &mut TypeMacro) {
visit_type_macro_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_type_never_mut(&mut self, i: &mut TypeNever) {
visit_type_never_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_type_param_mut(&mut self, i: &mut TypeParam) {
visit_type_param_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_type_param_bound_mut(&mut self, i: &mut TypeParamBound) {
visit_type_param_bound_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_type_paren_mut(&mut self, i: &mut TypeParen) {
visit_type_paren_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_type_path_mut(&mut self, i: &mut TypePath) {
visit_type_path_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_type_ptr_mut(&mut self, i: &mut TypePtr) {
visit_type_ptr_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_type_reference_mut(&mut self, i: &mut TypeReference) {
visit_type_reference_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_type_slice_mut(&mut self, i: &mut TypeSlice) {
visit_type_slice_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_type_trait_object_mut(&mut self, i: &mut TypeTraitObject) {
visit_type_trait_object_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_type_tuple_mut(&mut self, i: &mut TypeTuple) {
visit_type_tuple_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_type_verbatim_mut(&mut self, i: &mut TypeVerbatim) {
visit_type_verbatim_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
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 = "full", feature = "derive"))]
fn visit_variant_mut(&mut self, i: &mut Variant) {
visit_variant_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_vis_crate_mut(&mut self, i: &mut VisCrate) {
visit_vis_crate_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_vis_public_mut(&mut self, i: &mut VisPublic) {
visit_vis_public_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_vis_restricted_mut(&mut self, i: &mut VisRestricted) {
visit_vis_restricted_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_visibility_mut(&mut self, i: &mut Visibility) {
visit_visibility_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_where_clause_mut(&mut self, i: &mut WhereClause) {
visit_where_clause_mut(self, i)
}
#[cfg(any(feature = "full", feature = "derive"))]
fn visit_where_predicate_mut(&mut self, i: &mut WherePredicate) {
visit_where_predicate_mut(self, i)
}
}
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_abi_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Abi) {
tokens_helper(_visitor, &mut _i.extern_token.span);
if let Some(ref mut it) = _i.name {
_visitor.visit_lit_str_mut(it)
};
}
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_angle_bracketed_generic_arguments_mut<V: VisitMut + ?Sized>(
_visitor: &mut V,
_i: &mut AngleBracketedGenericArguments,
) {
if let Some(ref mut it) = _i.colon2_token {
tokens_helper(_visitor, &mut it.spans)
};
tokens_helper(_visitor, &mut _i.lt_token.spans);
for mut el in Punctuated::pairs_mut(&mut _i.args) {
let it = el.value_mut();
_visitor.visit_generic_argument_mut(it)
}
tokens_helper(_visitor, &mut _i.gt_token.spans);
}
#[cfg(feature = "full")]
pub fn visit_arg_captured_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ArgCaptured) {
_visitor.visit_pat_mut(&mut _i.pat);
tokens_helper(_visitor, &mut _i.colon_token.spans);
_visitor.visit_type_mut(&mut _i.ty);
}
#[cfg(feature = "full")]
pub fn visit_arg_self_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ArgSelf) {
if let Some(ref mut it) = _i.mutability {
tokens_helper(_visitor, &mut it.span)
};
tokens_helper(_visitor, &mut _i.self_token.span);
}
#[cfg(feature = "full")]
pub fn visit_arg_self_ref_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ArgSelfRef) {
tokens_helper(_visitor, &mut _i.and_token.spans);
if let Some(ref mut it) = _i.lifetime {
_visitor.visit_lifetime_mut(it)
};
if let Some(ref mut it) = _i.mutability {
tokens_helper(_visitor, &mut it.span)
};
tokens_helper(_visitor, &mut _i.self_token.span);
}
#[cfg(any(feature = "full", feature = "derive"))]
#[cfg(feature = "full")]
pub fn visit_arm_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Arm) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
if let Some(ref mut it) = _i.leading_vert {
tokens_helper(_visitor, &mut it.spans)
};
for mut el in Punctuated::pairs_mut(&mut _i.pats) {
let it = el.value_mut();
_visitor.visit_pat_mut(it)
}
if let Some(ref mut it) = _i.guard {
tokens_helper(_visitor, &mut (it).0.span);
_visitor.visit_expr_mut(&mut *(it).1);
};
tokens_helper(_visitor, &mut _i.fat_arrow_token.spans);
_visitor.visit_expr_mut(&mut *_i.body);
if let Some(ref mut it) = _i.comma {
tokens_helper(_visitor, &mut it.spans)
};
}
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_attr_style_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut AttrStyle) {
match *_i {
AttrStyle::Outer => {}
AttrStyle::Inner(ref mut _binding_0) => {
tokens_helper(_visitor, &mut _binding_0.spans);
}
}
}
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_attribute_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Attribute) {
tokens_helper(_visitor, &mut _i.pound_token.spans);
_visitor.visit_attr_style_mut(&mut _i.style);
tokens_helper(_visitor, &mut _i.bracket_token.span);
_visitor.visit_path_mut(&mut _i.path);
skip!(_i.tts);
}
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_bare_fn_arg_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut BareFnArg) {
if let Some(ref mut it) = _i.name {
_visitor.visit_bare_fn_arg_name_mut(&mut (it).0);
tokens_helper(_visitor, &mut (it).1.spans);
};
_visitor.visit_type_mut(&mut _i.ty);
}
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_bare_fn_arg_name_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut BareFnArgName) {
match *_i {
BareFnArgName::Named(ref mut _binding_0) => {
_visitor.visit_ident_mut(_binding_0);
}
BareFnArgName::Wild(ref mut _binding_0) => {
tokens_helper(_visitor, &mut _binding_0.spans);
}
}
}
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_bin_op_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut BinOp) {
match *_i {
BinOp::Add(ref mut _binding_0) => {
tokens_helper(_visitor, &mut _binding_0.spans);
}
BinOp::Sub(ref mut _binding_0) => {
tokens_helper(_visitor, &mut _binding_0.spans);
}
BinOp::Mul(ref mut _binding_0) => {
tokens_helper(_visitor, &mut _binding_0.spans);
}
BinOp::Div(ref mut _binding_0) => {
tokens_helper(_visitor, &mut _binding_0.spans);
}
BinOp::Rem(ref mut _binding_0) => {
tokens_helper(_visitor, &mut _binding_0.spans);
}
BinOp::And(ref mut _binding_0) => {
tokens_helper(_visitor, &mut _binding_0.spans);
}
BinOp::Or(ref mut _binding_0) => {
tokens_helper(_visitor, &mut _binding_0.spans);
}
BinOp::BitXor(ref mut _binding_0) => {
tokens_helper(_visitor, &mut _binding_0.spans);
}
BinOp::BitAnd(ref mut _binding_0) => {
tokens_helper(_visitor, &mut _binding_0.spans);
}
BinOp::BitOr(ref mut _binding_0) => {
tokens_helper(_visitor, &mut _binding_0.spans);
}
BinOp::Shl(ref mut _binding_0) => {
tokens_helper(_visitor, &mut _binding_0.spans);
}
BinOp::Shr(ref mut _binding_0) => {
tokens_helper(_visitor, &mut _binding_0.spans);
}
BinOp::Eq(ref mut _binding_0) => {
tokens_helper(_visitor, &mut _binding_0.spans);
}
BinOp::Lt(ref mut _binding_0) => {
tokens_helper(_visitor, &mut _binding_0.spans);
}
BinOp::Le(ref mut _binding_0) => {
tokens_helper(_visitor, &mut _binding_0.spans);
}
BinOp::Ne(ref mut _binding_0) => {
tokens_helper(_visitor, &mut _binding_0.spans);
}
BinOp::Ge(ref mut _binding_0) => {
tokens_helper(_visitor, &mut _binding_0.spans);
}
BinOp::Gt(ref mut _binding_0) => {
tokens_helper(_visitor, &mut _binding_0.spans);
}
BinOp::AddEq(ref mut _binding_0) => {
tokens_helper(_visitor, &mut _binding_0.spans);
}
BinOp::SubEq(ref mut _binding_0) => {
tokens_helper(_visitor, &mut _binding_0.spans);
}
BinOp::MulEq(ref mut _binding_0) => {
tokens_helper(_visitor, &mut _binding_0.spans);
}
BinOp::DivEq(ref mut _binding_0) => {
tokens_helper(_visitor, &mut _binding_0.spans);
}
BinOp::RemEq(ref mut _binding_0) => {
tokens_helper(_visitor, &mut _binding_0.spans);
}
BinOp::BitXorEq(ref mut _binding_0) => {
tokens_helper(_visitor, &mut _binding_0.spans);
}
BinOp::BitAndEq(ref mut _binding_0) => {
tokens_helper(_visitor, &mut _binding_0.spans);
}
BinOp::BitOrEq(ref mut _binding_0) => {
tokens_helper(_visitor, &mut _binding_0.spans);
}
BinOp::ShlEq(ref mut _binding_0) => {
tokens_helper(_visitor, &mut _binding_0.spans);
}
BinOp::ShrEq(ref mut _binding_0) => {
tokens_helper(_visitor, &mut _binding_0.spans);
}
}
}
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_binding_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Binding) {
_visitor.visit_ident_mut(&mut _i.ident);
tokens_helper(_visitor, &mut _i.eq_token.spans);
_visitor.visit_type_mut(&mut _i.ty);
}
#[cfg(any(feature = "full", feature = "derive"))]
#[cfg(feature = "full")]
pub fn visit_block_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Block) {
tokens_helper(_visitor, &mut _i.brace_token.span);
for it in &mut _i.stmts {
_visitor.visit_stmt_mut(it)
}
}
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_bound_lifetimes_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut BoundLifetimes) {
tokens_helper(_visitor, &mut _i.for_token.span);
tokens_helper(_visitor, &mut _i.lt_token.spans);
for mut el in Punctuated::pairs_mut(&mut _i.lifetimes) {
let it = el.value_mut();
_visitor.visit_lifetime_def_mut(it)
}
tokens_helper(_visitor, &mut _i.gt_token.spans);
}
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_const_param_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ConstParam) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
tokens_helper(_visitor, &mut _i.const_token.span);
_visitor.visit_ident_mut(&mut _i.ident);
tokens_helper(_visitor, &mut _i.colon_token.spans);
_visitor.visit_type_mut(&mut _i.ty);
if let Some(ref mut it) = _i.eq_token {
tokens_helper(_visitor, &mut it.spans)
};
if let Some(ref mut it) = _i.default {
_visitor.visit_expr_mut(it)
};
}
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_constraint_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Constraint) {
_visitor.visit_ident_mut(&mut _i.ident);
tokens_helper(_visitor, &mut _i.colon_token.spans);
for mut el in Punctuated::pairs_mut(&mut _i.bounds) {
let it = el.value_mut();
_visitor.visit_type_param_bound_mut(it)
}
}
#[cfg(feature = "derive")]
pub fn visit_data_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Data) {
match *_i {
Data::Struct(ref mut _binding_0) => {
_visitor.visit_data_struct_mut(_binding_0);
}
Data::Enum(ref mut _binding_0) => {
_visitor.visit_data_enum_mut(_binding_0);
}
Data::Union(ref mut _binding_0) => {
_visitor.visit_data_union_mut(_binding_0);
}
}
}
#[cfg(feature = "derive")]
pub fn visit_data_enum_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut DataEnum) {
tokens_helper(_visitor, &mut _i.enum_token.span);
tokens_helper(_visitor, &mut _i.brace_token.span);
for mut el in Punctuated::pairs_mut(&mut _i.variants) {
let it = el.value_mut();
_visitor.visit_variant_mut(it)
}
}
#[cfg(feature = "derive")]
pub fn visit_data_struct_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut DataStruct) {
tokens_helper(_visitor, &mut _i.struct_token.span);
_visitor.visit_fields_mut(&mut _i.fields);
if let Some(ref mut it) = _i.semi_token {
tokens_helper(_visitor, &mut it.spans)
};
}
#[cfg(feature = "derive")]
pub fn visit_data_union_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut DataUnion) {
tokens_helper(_visitor, &mut _i.union_token.span);
_visitor.visit_fields_named_mut(&mut _i.fields);
}
#[cfg(feature = "derive")]
pub fn visit_derive_input_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut DeriveInput) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
_visitor.visit_visibility_mut(&mut _i.vis);
_visitor.visit_ident_mut(&mut _i.ident);
_visitor.visit_generics_mut(&mut _i.generics);
_visitor.visit_data_mut(&mut _i.data);
}
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Expr) {
match *_i {
Expr::Box(ref mut _binding_0) => {
full!(_visitor.visit_expr_box_mut(_binding_0));
}
Expr::InPlace(ref mut _binding_0) => {
full!(_visitor.visit_expr_in_place_mut(_binding_0));
}
Expr::Array(ref mut _binding_0) => {
full!(_visitor.visit_expr_array_mut(_binding_0));
}
Expr::Call(ref mut _binding_0) => {
_visitor.visit_expr_call_mut(_binding_0);
}
Expr::MethodCall(ref mut _binding_0) => {
full!(_visitor.visit_expr_method_call_mut(_binding_0));
}
Expr::Tuple(ref mut _binding_0) => {
full!(_visitor.visit_expr_tuple_mut(_binding_0));
}
Expr::Binary(ref mut _binding_0) => {
_visitor.visit_expr_binary_mut(_binding_0);
}
Expr::Unary(ref mut _binding_0) => {
_visitor.visit_expr_unary_mut(_binding_0);
}
Expr::Lit(ref mut _binding_0) => {
_visitor.visit_expr_lit_mut(_binding_0);
}
Expr::Cast(ref mut _binding_0) => {
_visitor.visit_expr_cast_mut(_binding_0);
}
Expr::Type(ref mut _binding_0) => {
full!(_visitor.visit_expr_type_mut(_binding_0));
}
Expr::Let(ref mut _binding_0) => {
full!(_visitor.visit_expr_let_mut(_binding_0));
}
Expr::If(ref mut _binding_0) => {
full!(_visitor.visit_expr_if_mut(_binding_0));
}
Expr::While(ref mut _binding_0) => {
full!(_visitor.visit_expr_while_mut(_binding_0));
}
Expr::ForLoop(ref mut _binding_0) => {
full!(_visitor.visit_expr_for_loop_mut(_binding_0));
}
Expr::Loop(ref mut _binding_0) => {
full!(_visitor.visit_expr_loop_mut(_binding_0));
}
Expr::Match(ref mut _binding_0) => {
full!(_visitor.visit_expr_match_mut(_binding_0));
}
Expr::Closure(ref mut _binding_0) => {
full!(_visitor.visit_expr_closure_mut(_binding_0));
}
Expr::Unsafe(ref mut _binding_0) => {
full!(_visitor.visit_expr_unsafe_mut(_binding_0));
}
Expr::Block(ref mut _binding_0) => {
full!(_visitor.visit_expr_block_mut(_binding_0));
}
Expr::Assign(ref mut _binding_0) => {
full!(_visitor.visit_expr_assign_mut(_binding_0));
}
Expr::AssignOp(ref mut _binding_0) => {
full!(_visitor.visit_expr_assign_op_mut(_binding_0));
}
Expr::Field(ref mut _binding_0) => {
_visitor.visit_expr_field_mut(_binding_0);
}
Expr::Index(ref mut _binding_0) => {
_visitor.visit_expr_index_mut(_binding_0);
}
Expr::Range(ref mut _binding_0) => {
full!(_visitor.visit_expr_range_mut(_binding_0));
}
Expr::Path(ref mut _binding_0) => {
_visitor.visit_expr_path_mut(_binding_0);
}
Expr::Reference(ref mut _binding_0) => {
full!(_visitor.visit_expr_reference_mut(_binding_0));
}
Expr::Break(ref mut _binding_0) => {
full!(_visitor.visit_expr_break_mut(_binding_0));
}
Expr::Continue(ref mut _binding_0) => {
full!(_visitor.visit_expr_continue_mut(_binding_0));
}
Expr::Return(ref mut _binding_0) => {
full!(_visitor.visit_expr_return_mut(_binding_0));
}
Expr::Macro(ref mut _binding_0) => {
full!(_visitor.visit_expr_macro_mut(_binding_0));
}
Expr::Struct(ref mut _binding_0) => {
full!(_visitor.visit_expr_struct_mut(_binding_0));
}
Expr::Repeat(ref mut _binding_0) => {
full!(_visitor.visit_expr_repeat_mut(_binding_0));
}
Expr::Paren(ref mut _binding_0) => {
_visitor.visit_expr_paren_mut(_binding_0);
}
Expr::Group(ref mut _binding_0) => {
full!(_visitor.visit_expr_group_mut(_binding_0));
}
Expr::Try(ref mut _binding_0) => {
full!(_visitor.visit_expr_try_mut(_binding_0));
}
Expr::Async(ref mut _binding_0) => {
full!(_visitor.visit_expr_async_mut(_binding_0));
}
Expr::TryBlock(ref mut _binding_0) => {
full!(_visitor.visit_expr_try_block_mut(_binding_0));
}
Expr::Yield(ref mut _binding_0) => {
full!(_visitor.visit_expr_yield_mut(_binding_0));
}
Expr::Verbatim(ref mut _binding_0) => {
_visitor.visit_expr_verbatim_mut(_binding_0);
}
}
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_array_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprArray) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
tokens_helper(_visitor, &mut _i.bracket_token.span);
for mut el in Punctuated::pairs_mut(&mut _i.elems) {
let it = el.value_mut();
_visitor.visit_expr_mut(it)
}
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_assign_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprAssign) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
_visitor.visit_expr_mut(&mut *_i.left);
tokens_helper(_visitor, &mut _i.eq_token.spans);
_visitor.visit_expr_mut(&mut *_i.right);
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_assign_op_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprAssignOp) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
_visitor.visit_expr_mut(&mut *_i.left);
_visitor.visit_bin_op_mut(&mut _i.op);
_visitor.visit_expr_mut(&mut *_i.right);
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_async_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprAsync) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
tokens_helper(_visitor, &mut _i.async_token.span);
if let Some(ref mut it) = _i.capture {
tokens_helper(_visitor, &mut it.span)
};
_visitor.visit_block_mut(&mut _i.block);
}
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_binary_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprBinary) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
_visitor.visit_expr_mut(&mut *_i.left);
_visitor.visit_bin_op_mut(&mut _i.op);
_visitor.visit_expr_mut(&mut *_i.right);
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_block_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprBlock) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
if let Some(ref mut it) = _i.label {
_visitor.visit_label_mut(it)
};
_visitor.visit_block_mut(&mut _i.block);
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_box_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprBox) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
tokens_helper(_visitor, &mut _i.box_token.span);
_visitor.visit_expr_mut(&mut *_i.expr);
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_break_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprBreak) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
tokens_helper(_visitor, &mut _i.break_token.span);
if let Some(ref mut it) = _i.label {
_visitor.visit_lifetime_mut(it)
};
if let Some(ref mut it) = _i.expr {
_visitor.visit_expr_mut(&mut **it)
};
}
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_call_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprCall) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
_visitor.visit_expr_mut(&mut *_i.func);
tokens_helper(_visitor, &mut _i.paren_token.span);
for mut el in Punctuated::pairs_mut(&mut _i.args) {
let it = el.value_mut();
_visitor.visit_expr_mut(it)
}
}
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_cast_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprCast) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
_visitor.visit_expr_mut(&mut *_i.expr);
tokens_helper(_visitor, &mut _i.as_token.span);
_visitor.visit_type_mut(&mut *_i.ty);
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_closure_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprClosure) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
if let Some(ref mut it) = _i.asyncness {
tokens_helper(_visitor, &mut it.span)
};
if let Some(ref mut it) = _i.movability {
tokens_helper(_visitor, &mut it.span)
};
if let Some(ref mut it) = _i.capture {
tokens_helper(_visitor, &mut it.span)
};
tokens_helper(_visitor, &mut _i.or1_token.spans);
for mut el in Punctuated::pairs_mut(&mut _i.inputs) {
let it = el.value_mut();
_visitor.visit_fn_arg_mut(it)
}
tokens_helper(_visitor, &mut _i.or2_token.spans);
_visitor.visit_return_type_mut(&mut _i.output);
_visitor.visit_expr_mut(&mut *_i.body);
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_continue_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprContinue) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
tokens_helper(_visitor, &mut _i.continue_token.span);
if let Some(ref mut it) = _i.label {
_visitor.visit_lifetime_mut(it)
};
}
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_field_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprField) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
_visitor.visit_expr_mut(&mut *_i.base);
tokens_helper(_visitor, &mut _i.dot_token.spans);
_visitor.visit_member_mut(&mut _i.member);
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_for_loop_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprForLoop) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
if let Some(ref mut it) = _i.label {
_visitor.visit_label_mut(it)
};
tokens_helper(_visitor, &mut _i.for_token.span);
_visitor.visit_pat_mut(&mut *_i.pat);
tokens_helper(_visitor, &mut _i.in_token.span);
_visitor.visit_expr_mut(&mut *_i.expr);
_visitor.visit_block_mut(&mut _i.body);
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_group_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprGroup) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
tokens_helper(_visitor, &mut _i.group_token.span);
_visitor.visit_expr_mut(&mut *_i.expr);
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_if_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprIf) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
tokens_helper(_visitor, &mut _i.if_token.span);
_visitor.visit_expr_mut(&mut *_i.cond);
_visitor.visit_block_mut(&mut _i.then_branch);
if let Some(ref mut it) = _i.else_branch {
tokens_helper(_visitor, &mut (it).0.span);
_visitor.visit_expr_mut(&mut *(it).1);
};
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_in_place_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprInPlace) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
_visitor.visit_expr_mut(&mut *_i.place);
tokens_helper(_visitor, &mut _i.arrow_token.spans);
_visitor.visit_expr_mut(&mut *_i.value);
}
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_index_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprIndex) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
_visitor.visit_expr_mut(&mut *_i.expr);
tokens_helper(_visitor, &mut _i.bracket_token.span);
_visitor.visit_expr_mut(&mut *_i.index);
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_let_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprLet) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
tokens_helper(_visitor, &mut _i.let_token.span);
for mut el in Punctuated::pairs_mut(&mut _i.pats) {
let it = el.value_mut();
_visitor.visit_pat_mut(it)
}
tokens_helper(_visitor, &mut _i.eq_token.spans);
_visitor.visit_expr_mut(&mut *_i.expr);
}
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_lit_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprLit) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
_visitor.visit_lit_mut(&mut _i.lit);
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_loop_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprLoop) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
if let Some(ref mut it) = _i.label {
_visitor.visit_label_mut(it)
};
tokens_helper(_visitor, &mut _i.loop_token.span);
_visitor.visit_block_mut(&mut _i.body);
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_macro_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprMacro) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
_visitor.visit_macro_mut(&mut _i.mac);
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_match_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprMatch) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
tokens_helper(_visitor, &mut _i.match_token.span);
_visitor.visit_expr_mut(&mut *_i.expr);
tokens_helper(_visitor, &mut _i.brace_token.span);
for it in &mut _i.arms {
_visitor.visit_arm_mut(it)
}
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_method_call_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprMethodCall) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
_visitor.visit_expr_mut(&mut *_i.receiver);
tokens_helper(_visitor, &mut _i.dot_token.spans);
_visitor.visit_ident_mut(&mut _i.method);
if let Some(ref mut it) = _i.turbofish {
_visitor.visit_method_turbofish_mut(it)
};
tokens_helper(_visitor, &mut _i.paren_token.span);
for mut el in Punctuated::pairs_mut(&mut _i.args) {
let it = el.value_mut();
_visitor.visit_expr_mut(it)
}
}
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_paren_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprParen) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
tokens_helper(_visitor, &mut _i.paren_token.span);
_visitor.visit_expr_mut(&mut *_i.expr);
}
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_path_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprPath) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
if let Some(ref mut it) = _i.qself {
_visitor.visit_qself_mut(it)
};
_visitor.visit_path_mut(&mut _i.path);
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_range_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprRange) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
if let Some(ref mut it) = _i.from {
_visitor.visit_expr_mut(&mut **it)
};
_visitor.visit_range_limits_mut(&mut _i.limits);
if let Some(ref mut it) = _i.to {
_visitor.visit_expr_mut(&mut **it)
};
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_reference_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprReference) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
tokens_helper(_visitor, &mut _i.and_token.spans);
if let Some(ref mut it) = _i.mutability {
tokens_helper(_visitor, &mut it.span)
};
_visitor.visit_expr_mut(&mut *_i.expr);
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_repeat_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprRepeat) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
tokens_helper(_visitor, &mut _i.bracket_token.span);
_visitor.visit_expr_mut(&mut *_i.expr);
tokens_helper(_visitor, &mut _i.semi_token.spans);
_visitor.visit_expr_mut(&mut *_i.len);
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_return_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprReturn) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
tokens_helper(_visitor, &mut _i.return_token.span);
if let Some(ref mut it) = _i.expr {
_visitor.visit_expr_mut(&mut **it)
};
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_struct_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprStruct) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
_visitor.visit_path_mut(&mut _i.path);
tokens_helper(_visitor, &mut _i.brace_token.span);
for mut el in Punctuated::pairs_mut(&mut _i.fields) {
let it = el.value_mut();
_visitor.visit_field_value_mut(it)
}
if let Some(ref mut it) = _i.dot2_token {
tokens_helper(_visitor, &mut it.spans)
};
if let Some(ref mut it) = _i.rest {
_visitor.visit_expr_mut(&mut **it)
};
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_try_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprTry) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
_visitor.visit_expr_mut(&mut *_i.expr);
tokens_helper(_visitor, &mut _i.question_token.spans);
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_try_block_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprTryBlock) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
tokens_helper(_visitor, &mut _i.try_token.span);
_visitor.visit_block_mut(&mut _i.block);
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_tuple_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprTuple) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
tokens_helper(_visitor, &mut _i.paren_token.span);
for mut el in Punctuated::pairs_mut(&mut _i.elems) {
let it = el.value_mut();
_visitor.visit_expr_mut(it)
}
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_type_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprType) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
_visitor.visit_expr_mut(&mut *_i.expr);
tokens_helper(_visitor, &mut _i.colon_token.spans);
_visitor.visit_type_mut(&mut *_i.ty);
}
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_unary_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprUnary) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
_visitor.visit_un_op_mut(&mut _i.op);
_visitor.visit_expr_mut(&mut *_i.expr);
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_unsafe_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprUnsafe) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
tokens_helper(_visitor, &mut _i.unsafe_token.span);
_visitor.visit_block_mut(&mut _i.block);
}
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_verbatim_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprVerbatim) {
skip!(_i.tts);
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_while_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprWhile) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
if let Some(ref mut it) = _i.label {
_visitor.visit_label_mut(it)
};
tokens_helper(_visitor, &mut _i.while_token.span);
_visitor.visit_expr_mut(&mut *_i.cond);
_visitor.visit_block_mut(&mut _i.body);
}
#[cfg(feature = "full")]
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_expr_yield_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprYield) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
tokens_helper(_visitor, &mut _i.yield_token.span);
if let Some(ref mut it) = _i.expr {
_visitor.visit_expr_mut(&mut **it)
};
}
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_field_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Field) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
_visitor.visit_visibility_mut(&mut _i.vis);
if let Some(ref mut it) = _i.ident {
_visitor.visit_ident_mut(it)
};
if let Some(ref mut it) = _i.colon_token {
tokens_helper(_visitor, &mut it.spans)
};
_visitor.visit_type_mut(&mut _i.ty);
}
#[cfg(any(feature = "full", feature = "derive"))]
#[cfg(feature = "full")]
pub fn visit_field_pat_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut FieldPat) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
_visitor.visit_member_mut(&mut _i.member);
if let Some(ref mut it) = _i.colon_token {
tokens_helper(_visitor, &mut it.spans)
};
_visitor.visit_pat_mut(&mut *_i.pat);
}
#[cfg(any(feature = "full", feature = "derive"))]
#[cfg(feature = "full")]
pub fn visit_field_value_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut FieldValue) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
_visitor.visit_member_mut(&mut _i.member);
if let Some(ref mut it) = _i.colon_token {
tokens_helper(_visitor, &mut it.spans)
};
_visitor.visit_expr_mut(&mut _i.expr);
}
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_fields_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Fields) {
match *_i {
Fields::Named(ref mut _binding_0) => {
_visitor.visit_fields_named_mut(_binding_0);
}
Fields::Unnamed(ref mut _binding_0) => {
_visitor.visit_fields_unnamed_mut(_binding_0);
}
Fields::Unit => {}
}
}
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_fields_named_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut FieldsNamed) {
tokens_helper(_visitor, &mut _i.brace_token.span);
for mut el in Punctuated::pairs_mut(&mut _i.named) {
let it = el.value_mut();
_visitor.visit_field_mut(it)
}
}
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_fields_unnamed_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut FieldsUnnamed) {
tokens_helper(_visitor, &mut _i.paren_token.span);
for mut el in Punctuated::pairs_mut(&mut _i.unnamed) {
let it = el.value_mut();
_visitor.visit_field_mut(it)
}
}
#[cfg(feature = "full")]
pub fn visit_file_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut File) {
skip!(_i.shebang);
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
for it in &mut _i.items {
_visitor.visit_item_mut(it)
}
}
#[cfg(feature = "full")]
pub fn visit_fn_arg_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut FnArg) {
match *_i {
FnArg::SelfRef(ref mut _binding_0) => {
_visitor.visit_arg_self_ref_mut(_binding_0);
}
FnArg::SelfValue(ref mut _binding_0) => {
_visitor.visit_arg_self_mut(_binding_0);
}
FnArg::Captured(ref mut _binding_0) => {
_visitor.visit_arg_captured_mut(_binding_0);
}
FnArg::Inferred(ref mut _binding_0) => {
_visitor.visit_pat_mut(_binding_0);
}
FnArg::Ignored(ref mut _binding_0) => {
_visitor.visit_type_mut(_binding_0);
}
}
}
#[cfg(feature = "full")]
pub fn visit_fn_decl_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut FnDecl) {
tokens_helper(_visitor, &mut _i.fn_token.span);
_visitor.visit_generics_mut(&mut _i.generics);
tokens_helper(_visitor, &mut _i.paren_token.span);
for mut el in Punctuated::pairs_mut(&mut _i.inputs) {
let it = el.value_mut();
_visitor.visit_fn_arg_mut(it)
}
if let Some(ref mut it) = _i.variadic {
tokens_helper(_visitor, &mut it.spans)
};
_visitor.visit_return_type_mut(&mut _i.output);
}
#[cfg(feature = "full")]
pub fn visit_foreign_item_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ForeignItem) {
match *_i {
ForeignItem::Fn(ref mut _binding_0) => {
_visitor.visit_foreign_item_fn_mut(_binding_0);
}
ForeignItem::Static(ref mut _binding_0) => {
_visitor.visit_foreign_item_static_mut(_binding_0);
}
ForeignItem::Type(ref mut _binding_0) => {
_visitor.visit_foreign_item_type_mut(_binding_0);
}
ForeignItem::Macro(ref mut _binding_0) => {
_visitor.visit_foreign_item_macro_mut(_binding_0);
}
ForeignItem::Verbatim(ref mut _binding_0) => {
_visitor.visit_foreign_item_verbatim_mut(_binding_0);
}
}
}
#[cfg(feature = "full")]
pub fn visit_foreign_item_fn_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ForeignItemFn) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
_visitor.visit_visibility_mut(&mut _i.vis);
_visitor.visit_ident_mut(&mut _i.ident);
_visitor.visit_fn_decl_mut(&mut *_i.decl);
tokens_helper(_visitor, &mut _i.semi_token.spans);
}
#[cfg(feature = "full")]
pub fn visit_foreign_item_macro_mut<V: VisitMut + ?Sized>(
_visitor: &mut V,
_i: &mut ForeignItemMacro,
) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
_visitor.visit_macro_mut(&mut _i.mac);
if let Some(ref mut it) = _i.semi_token {
tokens_helper(_visitor, &mut it.spans)
};
}
#[cfg(feature = "full")]
pub fn visit_foreign_item_static_mut<V: VisitMut + ?Sized>(
_visitor: &mut V,
_i: &mut ForeignItemStatic,
) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
_visitor.visit_visibility_mut(&mut _i.vis);
tokens_helper(_visitor, &mut _i.static_token.span);
if let Some(ref mut it) = _i.mutability {
tokens_helper(_visitor, &mut it.span)
};
_visitor.visit_ident_mut(&mut _i.ident);
tokens_helper(_visitor, &mut _i.colon_token.spans);
_visitor.visit_type_mut(&mut *_i.ty);
tokens_helper(_visitor, &mut _i.semi_token.spans);
}
#[cfg(feature = "full")]
pub fn visit_foreign_item_type_mut<V: VisitMut + ?Sized>(
_visitor: &mut V,
_i: &mut ForeignItemType,
) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
_visitor.visit_visibility_mut(&mut _i.vis);
tokens_helper(_visitor, &mut _i.type_token.span);
_visitor.visit_ident_mut(&mut _i.ident);
tokens_helper(_visitor, &mut _i.semi_token.spans);
}
#[cfg(feature = "full")]
pub fn visit_foreign_item_verbatim_mut<V: VisitMut + ?Sized>(
_visitor: &mut V,
_i: &mut ForeignItemVerbatim,
) {
skip!(_i.tts);
}
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_generic_argument_mut<V: VisitMut + ?Sized>(
_visitor: &mut V,
_i: &mut GenericArgument,
) {
match *_i {
GenericArgument::Lifetime(ref mut _binding_0) => {
_visitor.visit_lifetime_mut(_binding_0);
}
GenericArgument::Type(ref mut _binding_0) => {
_visitor.visit_type_mut(_binding_0);
}
GenericArgument::Binding(ref mut _binding_0) => {
_visitor.visit_binding_mut(_binding_0);
}
GenericArgument::Constraint(ref mut _binding_0) => {
_visitor.visit_constraint_mut(_binding_0);
}
GenericArgument::Const(ref mut _binding_0) => {
_visitor.visit_expr_mut(_binding_0);
}
}
}
#[cfg(any(feature = "full", feature = "derive"))]
#[cfg(feature = "full")]
pub fn visit_generic_method_argument_mut<V: VisitMut + ?Sized>(
_visitor: &mut V,
_i: &mut GenericMethodArgument,
) {
match *_i {
GenericMethodArgument::Type(ref mut _binding_0) => {
_visitor.visit_type_mut(_binding_0);
}
GenericMethodArgument::Const(ref mut _binding_0) => {
_visitor.visit_expr_mut(_binding_0);
}
}
}
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_generic_param_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut GenericParam) {
match *_i {
GenericParam::Type(ref mut _binding_0) => {
_visitor.visit_type_param_mut(_binding_0);
}
GenericParam::Lifetime(ref mut _binding_0) => {
_visitor.visit_lifetime_def_mut(_binding_0);
}
GenericParam::Const(ref mut _binding_0) => {
_visitor.visit_const_param_mut(_binding_0);
}
}
}
#[cfg(any(feature = "full", feature = "derive"))]
pub fn visit_generics_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Generics) {
if let Some(ref mut it) = _i.lt_token {
tokens_helper(_visitor, &mut it.spans)
};
for mut el in Punctuated::pairs_mut(&mut _i.params) {
let it = el.value_mut();
_visitor.visit_generic_param_mut(it)
}
if let Some(ref mut it) = _i.gt_token {
tokens_helper(_visitor, &mut it.spans)
};
if let Some(ref mut it) = _i.where_clause {
_visitor.visit_where_clause_mut(it)
};
}
pub fn visit_ident_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Ident) {}
#[cfg(feature = "full")]
pub fn visit_impl_item_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ImplItem) {
match *_i {
ImplItem::Const(ref mut _binding_0) => {
_visitor.visit_impl_item_const_mut(_binding_0);
}
ImplItem::Method(ref mut _binding_0) => {
_visitor.visit_impl_item_method_mut(_binding_0);
}
ImplItem::Type(ref mut _binding_0) => {
_visitor.visit_impl_item_type_mut(_binding_0);
}
ImplItem::Existential(ref mut _binding_0) => {
_visitor.visit_impl_item_existential_mut(_binding_0);
}
ImplItem::Macro(ref mut _binding_0) => {
_visitor.visit_impl_item_macro_mut(_binding_0);
}
ImplItem::Verbatim(ref mut _binding_0) => {
_visitor.visit_impl_item_verbatim_mut(_binding_0);
}
}
}
#[cfg(feature = "full")]
pub fn visit_impl_item_const_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ImplItemConst) {
for it in &mut _i.attrs {
_visitor.visit_attribute_mut(it)
}
_visitor.visit_visibility_mut(&mut _i.vis);
if let Some(ref mut it) = _i.defaultness {
tokens_helper(_visitor, &mut it.span)
};
tokens_helper(_visitor, &mut _i.const_token.span);
_visitor.visit_ident_mut(&mut _i.ident);
tokens_helper(_visitor, &mut _i.colon_token.spans);
_visitor.visit_type_mut(&mut _i.ty);
tokens_helper(_visitor, &mut _i.eq_token.spans);
_visitor.visit_expr_mut(&mut _i.expr);
tokens_helper(_visitor, &mut _i.semi_token.spans);
}
#[cfg(feature = "full")]
pub fn visit_impl_item_existential_mut<V: VisitMut + ?Sized>(
_visitor: &mut V,
_i: &mut ImplItemExistential,
) {