telety_impl::visitor

Struct ApplyGenericArguments

Source 
pub struct ApplyGenericArguments<'p> { /* private fields */ }

Implementations§

Source§

impl<'p> ApplyGenericArguments<'p>

Source

pub fn new<'a>( params: &'p Generics, args: impl IntoIterator<Item = &'a GenericArgument>, ) -> Result<Self>

Trait Implementations§

Source§

impl<'p> FullMut for ApplyGenericArguments<'p>

Source§

fn visit_lifetime_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Lifetime)
where D: DirectMut<Self, Lifetime> + ?Sized,

Visits syn::Lifetime nodes
Source§

fn visit_type_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Type)
where D: DirectMut<Self, Type> + ?Sized,

Visits syn::Type nodes
Source§

fn visit_expr_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Expr)
where D: DirectMut<Self, Expr> + ?Sized,

Visits syn::Expr nodes
Source§

fn visit_abi_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Abi)
where D: DirectMut<Self, Abi> + ?Sized,

Visits syn::Abi nodes
Source§

fn visit_angle_bracketed_generic_arguments_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut AngleBracketedGenericArguments, )
where D: DirectMut<Self, AngleBracketedGenericArguments> + ?Sized,

Visits syn::AngleBracketedGenericArguments nodes
Source§

fn visit_arm_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Arm)
where D: DirectMut<Self, Arm> + ?Sized,

Visits syn::Arm nodes
Source§

fn visit_assoc_const_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut AssocConst, )
where D: DirectMut<Self, AssocConst> + ?Sized,

Visits syn::AssocConst nodes
Source§

fn visit_assoc_type_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut AssocType)
where D: DirectMut<Self, AssocType> + ?Sized,

Visits syn::AssocType nodes
Source§

fn visit_attr_style_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut AttrStyle)
where D: DirectMut<Self, AttrStyle> + ?Sized,

Visits syn::AttrStyle nodes
Source§

fn visit_attribute_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Attribute)
where D: DirectMut<Self, Attribute> + ?Sized,

Visits syn::Attribute nodes
Source§

fn visit_bare_fn_arg_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut BareFnArg)
where D: DirectMut<Self, BareFnArg> + ?Sized,

Visits syn::BareFnArg nodes
Source§

fn visit_bare_variadic_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut BareVariadic, )
where D: DirectMut<Self, BareVariadic> + ?Sized,

Visits syn::BareVariadic nodes
Source§

fn visit_bin_op_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut BinOp)
where D: DirectMut<Self, BinOp> + ?Sized,

Visits syn::BinOp nodes
Source§

fn visit_block_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Block)
where D: DirectMut<Self, Block> + ?Sized,

Visits syn::Block nodes
Source§

fn visit_bound_lifetimes_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut BoundLifetimes, )
where D: DirectMut<Self, BoundLifetimes> + ?Sized,

Visits syn::BoundLifetimes nodes
Source§

fn visit_captured_param_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut CapturedParam, )
where D: DirectMut<Self, CapturedParam> + ?Sized,

Visits syn::CapturedParam nodes
Source§

fn visit_const_param_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ConstParam, )
where D: DirectMut<Self, ConstParam> + ?Sized,

Visits syn::ConstParam nodes
Source§

fn visit_constraint_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Constraint)
where D: DirectMut<Self, Constraint> + ?Sized,

Visits syn::Constraint nodes
Source§

fn visit_data_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Data)
where D: DirectMut<Self, Data> + ?Sized,

Visits syn::Data nodes
Source§

fn visit_data_enum_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut DataEnum)
where D: DirectMut<Self, DataEnum> + ?Sized,

Visits syn::DataEnum nodes
Source§

fn visit_data_struct_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut DataStruct, )
where D: DirectMut<Self, DataStruct> + ?Sized,

Visits syn::DataStruct nodes
Source§

fn visit_data_union_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut DataUnion)
where D: DirectMut<Self, DataUnion> + ?Sized,

Visits syn::DataUnion nodes
Source§

fn visit_derive_input_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut DeriveInput, )
where D: DirectMut<Self, DeriveInput> + ?Sized,

Visits syn::DeriveInput nodes
Source§

fn visit_expr_array_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprArray)
where D: DirectMut<Self, ExprArray> + ?Sized,

Visits syn::ExprArray nodes
Source§

fn visit_expr_assign_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ExprAssign, )
where D: DirectMut<Self, ExprAssign> + ?Sized,

Visits syn::ExprAssign nodes
Source§

fn visit_expr_async_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprAsync)
where D: DirectMut<Self, ExprAsync> + ?Sized,

Visits syn::ExprAsync nodes
Source§

fn visit_expr_await_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprAwait)
where D: DirectMut<Self, ExprAwait> + ?Sized,

Visits syn::ExprAwait nodes
Source§

fn visit_expr_binary_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ExprBinary, )
where D: DirectMut<Self, ExprBinary> + ?Sized,

Visits syn::ExprBinary nodes
Source§

fn visit_expr_block_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprBlock)
where D: DirectMut<Self, ExprBlock> + ?Sized,

Visits syn::ExprBlock nodes
Source§

fn visit_expr_break_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprBreak)
where D: DirectMut<Self, ExprBreak> + ?Sized,

Visits syn::ExprBreak nodes
Source§

fn visit_expr_call_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprCall)
where D: DirectMut<Self, ExprCall> + ?Sized,

Visits syn::ExprCall nodes
Source§

fn visit_expr_cast_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprCast)
where D: DirectMut<Self, ExprCast> + ?Sized,

Visits syn::ExprCast nodes
Source§

fn visit_expr_closure_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ExprClosure, )
where D: DirectMut<Self, ExprClosure> + ?Sized,

Visits syn::ExprClosure nodes
Source§

fn visit_expr_const_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprConst)
where D: DirectMut<Self, ExprConst> + ?Sized,

Visits syn::ExprConst nodes
Source§

fn visit_expr_continue_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ExprContinue, )
where D: DirectMut<Self, ExprContinue> + ?Sized,

Visits syn::ExprContinue nodes
Source§

fn visit_expr_field_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprField)
where D: DirectMut<Self, ExprField> + ?Sized,

Visits syn::ExprField nodes
Source§

fn visit_expr_for_loop_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ExprForLoop, )
where D: DirectMut<Self, ExprForLoop> + ?Sized,

Visits syn::ExprForLoop nodes
Source§

fn visit_expr_group_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprGroup)
where D: DirectMut<Self, ExprGroup> + ?Sized,

Visits syn::ExprGroup nodes
Source§

fn visit_expr_if_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprIf)
where D: DirectMut<Self, ExprIf> + ?Sized,

Visits syn::ExprIf nodes
Source§

fn visit_expr_index_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprIndex)
where D: DirectMut<Self, ExprIndex> + ?Sized,

Visits syn::ExprIndex nodes
Source§

fn visit_expr_infer_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprInfer)
where D: DirectMut<Self, ExprInfer> + ?Sized,

Visits syn::ExprInfer nodes
Source§

fn visit_expr_let_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprLet)
where D: DirectMut<Self, ExprLet> + ?Sized,

Visits syn::ExprLet nodes
Source§

fn visit_expr_lit_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprLit)
where D: DirectMut<Self, ExprLit> + ?Sized,

Visits syn::ExprLit nodes
Source§

fn visit_expr_loop_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprLoop)
where D: DirectMut<Self, ExprLoop> + ?Sized,

Visits syn::ExprLoop nodes
Source§

fn visit_expr_macro_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprMacro)
where D: DirectMut<Self, ExprMacro> + ?Sized,

Visits syn::ExprMacro nodes
Source§

fn visit_expr_match_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprMatch)
where D: DirectMut<Self, ExprMatch> + ?Sized,

Visits syn::ExprMatch nodes
Source§

fn visit_expr_method_call_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ExprMethodCall, )
where D: DirectMut<Self, ExprMethodCall> + ?Sized,

Visits syn::ExprMethodCall nodes
Source§

fn visit_expr_paren_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprParen)
where D: DirectMut<Self, ExprParen> + ?Sized,

Visits syn::ExprParen nodes
Source§

fn visit_expr_path_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprPath)
where D: DirectMut<Self, ExprPath> + ?Sized,

Visits syn::ExprPath nodes
Source§

fn visit_expr_range_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprRange)
where D: DirectMut<Self, ExprRange> + ?Sized,

Visits syn::ExprRange nodes
Source§

fn visit_expr_raw_addr_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ExprRawAddr, )
where D: DirectMut<Self, ExprRawAddr> + ?Sized,

Visits syn::ExprRawAddr nodes
Source§

fn visit_expr_reference_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ExprReference, )
where D: DirectMut<Self, ExprReference> + ?Sized,

Visits syn::ExprReference nodes
Source§

fn visit_expr_repeat_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ExprRepeat, )
where D: DirectMut<Self, ExprRepeat> + ?Sized,

Visits syn::ExprRepeat nodes
Source§

fn visit_expr_return_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ExprReturn, )
where D: DirectMut<Self, ExprReturn> + ?Sized,

Visits syn::ExprReturn nodes
Source§

fn visit_expr_struct_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ExprStruct, )
where D: DirectMut<Self, ExprStruct> + ?Sized,

Visits syn::ExprStruct nodes
Source§

fn visit_expr_try_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprTry)
where D: DirectMut<Self, ExprTry> + ?Sized,

Visits syn::ExprTry nodes
Source§

fn visit_expr_try_block_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ExprTryBlock, )
where D: DirectMut<Self, ExprTryBlock> + ?Sized,

Visits syn::ExprTryBlock nodes
Source§

fn visit_expr_tuple_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprTuple)
where D: DirectMut<Self, ExprTuple> + ?Sized,

Visits syn::ExprTuple nodes
Source§

fn visit_expr_unary_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprUnary)
where D: DirectMut<Self, ExprUnary> + ?Sized,

Visits syn::ExprUnary nodes
Source§

fn visit_expr_unsafe_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ExprUnsafe, )
where D: DirectMut<Self, ExprUnsafe> + ?Sized,

Visits syn::ExprUnsafe nodes
Source§

fn visit_expr_while_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprWhile)
where D: DirectMut<Self, ExprWhile> + ?Sized,

Visits syn::ExprWhile nodes
Source§

fn visit_expr_yield_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprYield)
where D: DirectMut<Self, ExprYield> + ?Sized,

Visits syn::ExprYield nodes
Source§

fn visit_field_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Field)
where D: DirectMut<Self, Field> + ?Sized,

Visits syn::Field nodes
Source§

fn visit_field_mutability_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut FieldMutability, )
where D: DirectMut<Self, FieldMutability> + ?Sized,

Visits syn::FieldMutability nodes
Source§

fn visit_field_pat_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut FieldPat)
where D: DirectMut<Self, FieldPat> + ?Sized,

Visits syn::FieldPat nodes
Source§

fn visit_field_value_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut FieldValue, )
where D: DirectMut<Self, FieldValue> + ?Sized,

Visits syn::FieldValue nodes
Source§

fn visit_fields_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Fields)
where D: DirectMut<Self, Fields> + ?Sized,

Visits syn::Fields nodes
Source§

fn visit_fields_named_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut FieldsNamed, )
where D: DirectMut<Self, FieldsNamed> + ?Sized,

Visits syn::FieldsNamed nodes
Source§

fn visit_fields_unnamed_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut FieldsUnnamed, )
where D: DirectMut<Self, FieldsUnnamed> + ?Sized,

Visits syn::FieldsUnnamed nodes
Source§

fn visit_file_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut File)
where D: DirectMut<Self, File> + ?Sized,

Visits syn::File nodes
Source§

fn visit_fn_arg_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut FnArg)
where D: DirectMut<Self, FnArg> + ?Sized,

Visits syn::FnArg nodes
Source§

fn visit_foreign_item_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ForeignItem, )
where D: DirectMut<Self, ForeignItem> + ?Sized,

Visits syn::ForeignItem nodes
Source§

fn visit_foreign_item_fn_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ForeignItemFn, )
where D: DirectMut<Self, ForeignItemFn> + ?Sized,

Visits syn::ForeignItemFn nodes
Source§

fn visit_foreign_item_macro_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ForeignItemMacro, )
where D: DirectMut<Self, ForeignItemMacro> + ?Sized,

Visits syn::ForeignItemMacro nodes
Source§

fn visit_foreign_item_static_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ForeignItemStatic, )
where D: DirectMut<Self, ForeignItemStatic> + ?Sized,

Visits syn::ForeignItemStatic nodes
Source§

fn visit_foreign_item_type_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ForeignItemType, )
where D: DirectMut<Self, ForeignItemType> + ?Sized,

Visits syn::ForeignItemType nodes
Source§

fn visit_generic_argument_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut GenericArgument, )
where D: DirectMut<Self, GenericArgument> + ?Sized,

Visits syn::GenericArgument nodes
Source§

fn visit_generic_param_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut GenericParam, )
where D: DirectMut<Self, GenericParam> + ?Sized,

Visits syn::GenericParam nodes
Source§

fn visit_generics_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Generics)
where D: DirectMut<Self, Generics> + ?Sized,

Visits syn::Generics nodes
Source§

fn visit_ident_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Ident)
where D: DirectMut<Self, Ident> + ?Sized,

Visits proc_macro2::Ident nodes
Source§

fn visit_impl_item_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ImplItem)
where D: DirectMut<Self, ImplItem> + ?Sized,

Visits syn::ImplItem nodes
Source§

fn visit_impl_item_const_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ImplItemConst, )
where D: DirectMut<Self, ImplItemConst> + ?Sized,

Visits syn::ImplItemConst nodes
Source§

fn visit_impl_item_fn_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ImplItemFn, )
where D: DirectMut<Self, ImplItemFn> + ?Sized,

Visits syn::ImplItemFn nodes
Source§

fn visit_impl_item_macro_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ImplItemMacro, )
where D: DirectMut<Self, ImplItemMacro> + ?Sized,

Visits syn::ImplItemMacro nodes
Source§

fn visit_impl_item_type_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ImplItemType, )
where D: DirectMut<Self, ImplItemType> + ?Sized,

Visits syn::ImplItemType nodes
Source§

fn visit_impl_restriction_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ImplRestriction, )
where D: DirectMut<Self, ImplRestriction> + ?Sized,

Visits syn::ImplRestriction nodes
Source§

fn visit_index_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Index)
where D: DirectMut<Self, Index> + ?Sized,

Visits syn::Index nodes
Source§

fn visit_item_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Item)
where D: DirectMut<Self, Item> + ?Sized,

Visits syn::Item nodes
Source§

fn visit_item_const_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ItemConst)
where D: DirectMut<Self, ItemConst> + ?Sized,

Visits syn::ItemConst nodes
Source§

fn visit_item_enum_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ItemEnum)
where D: DirectMut<Self, ItemEnum> + ?Sized,

Visits syn::ItemEnum nodes
Source§

fn visit_item_extern_crate_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ItemExternCrate, )
where D: DirectMut<Self, ItemExternCrate> + ?Sized,

Visits syn::ItemExternCrate nodes
Source§

fn visit_item_fn_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ItemFn)
where D: DirectMut<Self, ItemFn> + ?Sized,

Visits syn::ItemFn nodes
Source§

fn visit_item_foreign_mod_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ItemForeignMod, )
where D: DirectMut<Self, ItemForeignMod> + ?Sized,

Visits syn::ItemForeignMod nodes
Source§

fn visit_item_impl_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ItemImpl)
where D: DirectMut<Self, ItemImpl> + ?Sized,

Visits syn::ItemImpl nodes
Source§

fn visit_item_macro_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ItemMacro)
where D: DirectMut<Self, ItemMacro> + ?Sized,

Visits syn::ItemMacro nodes
Source§

fn visit_item_mod_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ItemMod)
where D: DirectMut<Self, ItemMod> + ?Sized,

Visits syn::ItemMod nodes
Source§

fn visit_item_static_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ItemStatic, )
where D: DirectMut<Self, ItemStatic> + ?Sized,

Visits syn::ItemStatic nodes
Source§

fn visit_item_struct_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ItemStruct, )
where D: DirectMut<Self, ItemStruct> + ?Sized,

Visits syn::ItemStruct nodes
Source§

fn visit_item_trait_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ItemTrait)
where D: DirectMut<Self, ItemTrait> + ?Sized,

Visits syn::ItemTrait nodes
Source§

fn visit_item_trait_alias_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ItemTraitAlias, )
where D: DirectMut<Self, ItemTraitAlias> + ?Sized,

Visits syn::ItemTraitAlias nodes
Source§

fn visit_item_type_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ItemType)
where D: DirectMut<Self, ItemType> + ?Sized,

Visits syn::ItemType nodes
Source§

fn visit_item_union_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ItemUnion)
where D: DirectMut<Self, ItemUnion> + ?Sized,

Visits syn::ItemUnion nodes
Source§

fn visit_item_use_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ItemUse)
where D: DirectMut<Self, ItemUse> + ?Sized,

Visits syn::ItemUse nodes
Source§

fn visit_label_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Label)
where D: DirectMut<Self, Label> + ?Sized,

Visits syn::Label nodes
Source§

fn visit_lifetime_param_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut LifetimeParam, )
where D: DirectMut<Self, LifetimeParam> + ?Sized,

Visits syn::LifetimeParam nodes
Source§

fn visit_lit_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Lit)
where D: DirectMut<Self, Lit> + ?Sized,

Visits syn::Lit nodes
Source§

fn visit_lit_bool_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut LitBool)
where D: DirectMut<Self, LitBool> + ?Sized,

Visits syn::LitBool nodes
Source§

fn visit_lit_byte_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut LitByte)
where D: DirectMut<Self, LitByte> + ?Sized,

Visits syn::LitByte nodes
Source§

fn visit_lit_byte_str_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut LitByteStr, )
where D: DirectMut<Self, LitByteStr> + ?Sized,

Visits syn::LitByteStr nodes
Source§

fn visit_lit_cstr_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut LitCStr)
where D: DirectMut<Self, LitCStr> + ?Sized,

Visits syn::LitCStr nodes
Source§

fn visit_lit_char_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut LitChar)
where D: DirectMut<Self, LitChar> + ?Sized,

Visits syn::LitChar nodes
Source§

fn visit_lit_float_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut LitFloat)
where D: DirectMut<Self, LitFloat> + ?Sized,

Visits syn::LitFloat nodes
Source§

fn visit_lit_int_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut LitInt)
where D: DirectMut<Self, LitInt> + ?Sized,

Visits syn::LitInt nodes
Source§

fn visit_lit_str_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut LitStr)
where D: DirectMut<Self, LitStr> + ?Sized,

Visits syn::LitStr nodes
Source§

fn visit_local_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Local)
where D: DirectMut<Self, Local> + ?Sized,

Visits syn::Local nodes
Source§

fn visit_local_init_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut LocalInit)
where D: DirectMut<Self, LocalInit> + ?Sized,

Visits syn::LocalInit nodes
Source§

fn visit_macro_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Macro)
where D: DirectMut<Self, Macro> + ?Sized,

Visits syn::Macro nodes
Source§

fn visit_macro_delimiter_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut MacroDelimiter, )
where D: DirectMut<Self, MacroDelimiter> + ?Sized,

Visits syn::MacroDelimiter nodes
Source§

fn visit_member_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Member)
where D: DirectMut<Self, Member> + ?Sized,

Visits syn::Member nodes
Source§

fn visit_meta_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Meta)
where D: DirectMut<Self, Meta> + ?Sized,

Visits syn::Meta nodes
Source§

fn visit_meta_list_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut MetaList)
where D: DirectMut<Self, MetaList> + ?Sized,

Visits syn::MetaList nodes
Source§

fn visit_meta_name_value_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut MetaNameValue, )
where D: DirectMut<Self, MetaNameValue> + ?Sized,

Visits syn::MetaNameValue nodes
Source§

fn visit_parenthesized_generic_arguments_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ParenthesizedGenericArguments, )
where D: DirectMut<Self, ParenthesizedGenericArguments> + ?Sized,

Visits syn::ParenthesizedGenericArguments nodes
Source§

fn visit_pat_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Pat)
where D: DirectMut<Self, Pat> + ?Sized,

Visits syn::Pat nodes
Source§

fn visit_pat_ident_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut PatIdent)
where D: DirectMut<Self, PatIdent> + ?Sized,

Visits syn::PatIdent nodes
Source§

fn visit_pat_or_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut PatOr)
where D: DirectMut<Self, PatOr> + ?Sized,

Visits syn::PatOr nodes
Source§

fn visit_pat_paren_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut PatParen)
where D: DirectMut<Self, PatParen> + ?Sized,

Visits syn::PatParen nodes
Source§

fn visit_pat_reference_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut PatReference, )
where D: DirectMut<Self, PatReference> + ?Sized,

Visits syn::PatReference nodes
Source§

fn visit_pat_rest_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut PatRest)
where D: DirectMut<Self, PatRest> + ?Sized,

Visits syn::PatRest nodes
Source§

fn visit_pat_slice_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut PatSlice)
where D: DirectMut<Self, PatSlice> + ?Sized,

Visits syn::PatSlice nodes
Source§

fn visit_pat_struct_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut PatStruct)
where D: DirectMut<Self, PatStruct> + ?Sized,

Visits syn::PatStruct nodes
Source§

fn visit_pat_tuple_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut PatTuple)
where D: DirectMut<Self, PatTuple> + ?Sized,

Visits syn::PatTuple nodes
Source§

fn visit_pat_tuple_struct_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut PatTupleStruct, )
where D: DirectMut<Self, PatTupleStruct> + ?Sized,

Visits syn::PatTupleStruct nodes
Source§

fn visit_pat_type_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut PatType)
where D: DirectMut<Self, PatType> + ?Sized,

Visits syn::PatType nodes
Source§

fn visit_pat_wild_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut PatWild)
where D: DirectMut<Self, PatWild> + ?Sized,

Visits syn::PatWild nodes
Source§

fn visit_path_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Path)
where D: DirectMut<Self, Path> + ?Sized,

Visits syn::Path nodes
Source§

fn visit_path_arguments_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut PathArguments, )
where D: DirectMut<Self, PathArguments> + ?Sized,

Visits syn::PathArguments nodes
Source§

fn visit_path_segment_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut PathSegment, )
where D: DirectMut<Self, PathSegment> + ?Sized,

Visits syn::PathSegment nodes
Source§

fn visit_pointer_mutability_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut PointerMutability, )
where D: DirectMut<Self, PointerMutability> + ?Sized,

Visits syn::PointerMutability nodes
Source§

fn visit_precise_capture_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut PreciseCapture, )
where D: DirectMut<Self, PreciseCapture> + ?Sized,

Visits syn::PreciseCapture nodes
Source§

fn visit_predicate_lifetime_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut PredicateLifetime, )
where D: DirectMut<Self, PredicateLifetime> + ?Sized,

Visits syn::PredicateLifetime nodes
Source§

fn visit_predicate_type_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut PredicateType, )
where D: DirectMut<Self, PredicateType> + ?Sized,

Visits syn::PredicateType nodes
Source§

fn visit_qself_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut QSelf)
where D: DirectMut<Self, QSelf> + ?Sized,

Visits syn::QSelf nodes
Source§

fn visit_range_limits_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut RangeLimits, )
where D: DirectMut<Self, RangeLimits> + ?Sized,

Visits syn::RangeLimits nodes
Source§

fn visit_receiver_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Receiver)
where D: DirectMut<Self, Receiver> + ?Sized,

Visits syn::Receiver nodes
Source§

fn visit_return_type_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ReturnType, )
where D: DirectMut<Self, ReturnType> + ?Sized,

Visits syn::ReturnType nodes
Source§

fn visit_signature_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Signature)
where D: DirectMut<Self, Signature> + ?Sized,

Visits syn::Signature nodes
Source§

fn visit_static_mutability_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut StaticMutability, )
where D: DirectMut<Self, StaticMutability> + ?Sized,

Visits syn::StaticMutability nodes
Source§

fn visit_stmt_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Stmt)
where D: DirectMut<Self, Stmt> + ?Sized,

Visits syn::Stmt nodes
Source§

fn visit_stmt_macro_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut StmtMacro)
where D: DirectMut<Self, StmtMacro> + ?Sized,

Visits syn::StmtMacro nodes
Source§

fn visit_token_stream_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut TokenStream, )
where D: DirectMut<Self, TokenStream> + ?Sized,

Visits proc_macro2::TokenStream nodes
Source§

fn visit_trait_bound_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut TraitBound, )
where D: DirectMut<Self, TraitBound> + ?Sized,

Visits syn::TraitBound nodes
Source§

fn visit_trait_bound_modifier_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut TraitBoundModifier, )
where D: DirectMut<Self, TraitBoundModifier> + ?Sized,

Visits syn::TraitBoundModifier nodes
Source§

fn visit_trait_item_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut TraitItem)
where D: DirectMut<Self, TraitItem> + ?Sized,

Visits syn::TraitItem nodes
Source§

fn visit_trait_item_const_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut TraitItemConst, )
where D: DirectMut<Self, TraitItemConst> + ?Sized,

Visits syn::TraitItemConst nodes
Source§

fn visit_trait_item_fn_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut TraitItemFn, )
where D: DirectMut<Self, TraitItemFn> + ?Sized,

Visits syn::TraitItemFn nodes
Source§

fn visit_trait_item_macro_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut TraitItemMacro, )
where D: DirectMut<Self, TraitItemMacro> + ?Sized,

Visits syn::TraitItemMacro nodes
Source§

fn visit_trait_item_type_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut TraitItemType, )
where D: DirectMut<Self, TraitItemType> + ?Sized,

Visits syn::TraitItemType nodes
Source§

fn visit_type_array_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut TypeArray)
where D: DirectMut<Self, TypeArray> + ?Sized,

Visits syn::TypeArray nodes
Source§

fn visit_type_bare_fn_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut TypeBareFn, )
where D: DirectMut<Self, TypeBareFn> + ?Sized,

Visits syn::TypeBareFn nodes
Source§

fn visit_type_group_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut TypeGroup)
where D: DirectMut<Self, TypeGroup> + ?Sized,

Visits syn::TypeGroup nodes
Source§

fn visit_type_impl_trait_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut TypeImplTrait, )
where D: DirectMut<Self, TypeImplTrait> + ?Sized,

Visits syn::TypeImplTrait nodes
Source§

fn visit_type_infer_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut TypeInfer)
where D: DirectMut<Self, TypeInfer> + ?Sized,

Visits syn::TypeInfer nodes
Source§

fn visit_type_macro_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut TypeMacro)
where D: DirectMut<Self, TypeMacro> + ?Sized,

Visits syn::TypeMacro nodes
Source§

fn visit_type_never_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut TypeNever)
where D: DirectMut<Self, TypeNever> + ?Sized,

Visits syn::TypeNever nodes
Source§

fn visit_type_param_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut TypeParam)
where D: DirectMut<Self, TypeParam> + ?Sized,

Visits syn::TypeParam nodes
Source§

fn visit_type_param_bound_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut TypeParamBound, )
where D: DirectMut<Self, TypeParamBound> + ?Sized,

Visits syn::TypeParamBound nodes
Source§

fn visit_type_paren_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut TypeParen)
where D: DirectMut<Self, TypeParen> + ?Sized,

Visits syn::TypeParen nodes
Source§

fn visit_type_path_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut TypePath)
where D: DirectMut<Self, TypePath> + ?Sized,

Visits syn::TypePath nodes
Source§

fn visit_type_ptr_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut TypePtr)
where D: DirectMut<Self, TypePtr> + ?Sized,

Visits syn::TypePtr nodes
Source§

fn visit_type_reference_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut TypeReference, )
where D: DirectMut<Self, TypeReference> + ?Sized,

Visits syn::TypeReference nodes
Source§

fn visit_type_slice_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut TypeSlice)
where D: DirectMut<Self, TypeSlice> + ?Sized,

Visits syn::TypeSlice nodes
Source§

fn visit_type_trait_object_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut TypeTraitObject, )
where D: DirectMut<Self, TypeTraitObject> + ?Sized,

Visits syn::TypeTraitObject nodes
Source§

fn visit_type_tuple_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut TypeTuple)
where D: DirectMut<Self, TypeTuple> + ?Sized,

Visits syn::TypeTuple nodes
Source§

fn visit_un_op_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut UnOp)
where D: DirectMut<Self, UnOp> + ?Sized,

Visits syn::UnOp nodes
Source§

fn visit_use_glob_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut UseGlob)
where D: DirectMut<Self, UseGlob> + ?Sized,

Visits syn::UseGlob nodes
Source§

fn visit_use_group_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut UseGroup)
where D: DirectMut<Self, UseGroup> + ?Sized,

Visits syn::UseGroup nodes
Source§

fn visit_use_name_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut UseName)
where D: DirectMut<Self, UseName> + ?Sized,

Visits syn::UseName nodes
Source§

fn visit_use_path_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut UsePath)
where D: DirectMut<Self, UsePath> + ?Sized,

Visits syn::UsePath nodes
Source§

fn visit_use_rename_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut UseRename)
where D: DirectMut<Self, UseRename> + ?Sized,

Visits syn::UseRename nodes
Source§

fn visit_use_tree_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut UseTree)
where D: DirectMut<Self, UseTree> + ?Sized,

Visits syn::UseTree nodes
Source§

fn visit_variadic_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Variadic)
where D: DirectMut<Self, Variadic> + ?Sized,

Visits syn::Variadic nodes
Source§

fn visit_variant_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Variant)
where D: DirectMut<Self, Variant> + ?Sized,

Visits syn::Variant nodes
Source§

fn visit_vis_restricted_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut VisRestricted, )
where D: DirectMut<Self, VisRestricted> + ?Sized,

Visits syn::VisRestricted nodes
Source§

fn visit_visibility_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Visibility)
where D: DirectMut<Self, Visibility> + ?Sized,

Visits syn::Visibility nodes
Source§

fn visit_where_clause_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut WhereClause, )
where D: DirectMut<Self, WhereClause> + ?Sized,

Visits syn::WhereClause nodes
Source§

fn visit_where_predicate_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut WherePredicate, )
where D: DirectMut<Self, WherePredicate> + ?Sized,

Visits syn::WherePredicate nodes
Source§

fn visit_generics_enter_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut GenericsEnter, )
where D: DirectMut<Self, GenericsEnter> + ?Sized,

Visits crate::syn::GenericsEnter nodes
Source§

fn visit_generics_exit_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut GenericsExit, )
where D: DirectMut<Self, GenericsExit> + ?Sized,

Visits crate::syn::GenericsExit nodes

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

impl<T> VisitMut<Abi> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut Abi)
where D: DirectMut<T, Abi> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<AngleBracketedGenericArguments> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>( visitor: Visitor<'_, D, T>, node: &mut AngleBracketedGenericArguments, )
where D: DirectMut<T, AngleBracketedGenericArguments> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<Arm> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut Arm)
where D: DirectMut<T, Arm> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<AssocConst> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut AssocConst)
where D: DirectMut<T, AssocConst> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<AssocType> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut AssocType)
where D: DirectMut<T, AssocType> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<AttrStyle> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut AttrStyle)
where D: DirectMut<T, AttrStyle> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<Attribute> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut Attribute)
where D: DirectMut<T, Attribute> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<BareFnArg> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut BareFnArg)
where D: DirectMut<T, BareFnArg> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<BareVariadic> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut BareVariadic)
where D: DirectMut<T, BareVariadic> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<BinOp> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut BinOp)
where D: DirectMut<T, BinOp> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<Block> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut Block)
where D: DirectMut<T, Block> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<BoundLifetimes> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut BoundLifetimes)
where D: DirectMut<T, BoundLifetimes> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<CapturedParam> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut CapturedParam)
where D: DirectMut<T, CapturedParam> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ConstParam> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ConstParam)
where D: DirectMut<T, ConstParam> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<Constraint> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut Constraint)
where D: DirectMut<T, Constraint> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<Data> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut Data)
where D: DirectMut<T, Data> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<DataEnum> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut DataEnum)
where D: DirectMut<T, DataEnum> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<DataStruct> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut DataStruct)
where D: DirectMut<T, DataStruct> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<DataUnion> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut DataUnion)
where D: DirectMut<T, DataUnion> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<DeriveInput> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut DeriveInput)
where D: DirectMut<T, DeriveInput> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<Expr> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut Expr)
where D: DirectMut<T, Expr> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprArray> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprArray)
where D: DirectMut<T, ExprArray> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprAssign> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprAssign)
where D: DirectMut<T, ExprAssign> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprAsync> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprAsync)
where D: DirectMut<T, ExprAsync> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprAwait> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprAwait)
where D: DirectMut<T, ExprAwait> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprBinary> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprBinary)
where D: DirectMut<T, ExprBinary> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprBlock> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprBlock)
where D: DirectMut<T, ExprBlock> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprBreak> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprBreak)
where D: DirectMut<T, ExprBreak> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprCall> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprCall)
where D: DirectMut<T, ExprCall> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprCast> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprCast)
where D: DirectMut<T, ExprCast> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprClosure> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprClosure)
where D: DirectMut<T, ExprClosure> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprConst> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprConst)
where D: DirectMut<T, ExprConst> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprContinue> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprContinue)
where D: DirectMut<T, ExprContinue> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprField> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprField)
where D: DirectMut<T, ExprField> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprForLoop> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprForLoop)
where D: DirectMut<T, ExprForLoop> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprGroup> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprGroup)
where D: DirectMut<T, ExprGroup> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprIf> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprIf)
where D: DirectMut<T, ExprIf> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprIndex> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprIndex)
where D: DirectMut<T, ExprIndex> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprInfer> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprInfer)
where D: DirectMut<T, ExprInfer> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprLet> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprLet)
where D: DirectMut<T, ExprLet> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprLit> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprLit)
where D: DirectMut<T, ExprLit> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprLoop> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprLoop)
where D: DirectMut<T, ExprLoop> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprMacro> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprMacro)
where D: DirectMut<T, ExprMacro> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprMatch> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprMatch)
where D: DirectMut<T, ExprMatch> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprMethodCall> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprMethodCall)
where D: DirectMut<T, ExprMethodCall> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprParen> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprParen)
where D: DirectMut<T, ExprParen> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprPath> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprPath)
where D: DirectMut<T, ExprPath> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprRange> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprRange)
where D: DirectMut<T, ExprRange> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprRawAddr> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprRawAddr)
where D: DirectMut<T, ExprRawAddr> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprReference> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprReference)
where D: DirectMut<T, ExprReference> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprRepeat> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprRepeat)
where D: DirectMut<T, ExprRepeat> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprReturn> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprReturn)
where D: DirectMut<T, ExprReturn> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprStruct> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprStruct)
where D: DirectMut<T, ExprStruct> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprTry> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprTry)
where D: DirectMut<T, ExprTry> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprTryBlock> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprTryBlock)
where D: DirectMut<T, ExprTryBlock> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprTuple> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprTuple)
where D: DirectMut<T, ExprTuple> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprUnary> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprUnary)
where D: DirectMut<T, ExprUnary> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprUnsafe> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprUnsafe)
where D: DirectMut<T, ExprUnsafe> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprWhile> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprWhile)
where D: DirectMut<T, ExprWhile> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ExprYield> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ExprYield)
where D: DirectMut<T, ExprYield> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<Field> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut Field)
where D: DirectMut<T, Field> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<FieldMutability> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut FieldMutability)
where D: DirectMut<T, FieldMutability> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<FieldPat> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut FieldPat)
where D: DirectMut<T, FieldPat> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<FieldValue> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut FieldValue)
where D: DirectMut<T, FieldValue> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<Fields> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut Fields)
where D: DirectMut<T, Fields> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<FieldsNamed> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut FieldsNamed)
where D: DirectMut<T, FieldsNamed> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<FieldsUnnamed> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut FieldsUnnamed)
where D: DirectMut<T, FieldsUnnamed> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<File> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut File)
where D: DirectMut<T, File> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<FnArg> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut FnArg)
where D: DirectMut<T, FnArg> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ForeignItem> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ForeignItem)
where D: DirectMut<T, ForeignItem> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ForeignItemFn> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ForeignItemFn)
where D: DirectMut<T, ForeignItemFn> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ForeignItemMacro> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ForeignItemMacro)
where D: DirectMut<T, ForeignItemMacro> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ForeignItemStatic> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ForeignItemStatic)
where D: DirectMut<T, ForeignItemStatic> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ForeignItemType> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ForeignItemType)
where D: DirectMut<T, ForeignItemType> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<GenericArgument> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut GenericArgument)
where D: DirectMut<T, GenericArgument> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<GenericParam> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut GenericParam)
where D: DirectMut<T, GenericParam> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<Generics> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut Generics)
where D: DirectMut<T, Generics> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<GenericsEnter> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut GenericsEnter)
where D: DirectMut<T, GenericsEnter> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<GenericsExit> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut GenericsExit)
where D: DirectMut<T, GenericsExit> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<Ident> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut Ident)
where D: DirectMut<T, Ident> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ImplItem> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ImplItem)
where D: DirectMut<T, ImplItem> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ImplItemConst> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ImplItemConst)
where D: DirectMut<T, ImplItemConst> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ImplItemFn> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ImplItemFn)
where D: DirectMut<T, ImplItemFn> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ImplItemMacro> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ImplItemMacro)
where D: DirectMut<T, ImplItemMacro> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ImplItemType> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ImplItemType)
where D: DirectMut<T, ImplItemType> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ImplRestriction> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ImplRestriction)
where D: DirectMut<T, ImplRestriction> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<Index> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut Index)
where D: DirectMut<T, Index> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<Item> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut Item)
where D: DirectMut<T, Item> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ItemConst> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ItemConst)
where D: DirectMut<T, ItemConst> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ItemEnum> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ItemEnum)
where D: DirectMut<T, ItemEnum> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ItemExternCrate> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ItemExternCrate)
where D: DirectMut<T, ItemExternCrate> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ItemFn> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ItemFn)
where D: DirectMut<T, ItemFn> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ItemForeignMod> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ItemForeignMod)
where D: DirectMut<T, ItemForeignMod> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ItemImpl> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ItemImpl)
where D: DirectMut<T, ItemImpl> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ItemMacro> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ItemMacro)
where D: DirectMut<T, ItemMacro> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ItemMod> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ItemMod)
where D: DirectMut<T, ItemMod> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ItemStatic> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ItemStatic)
where D: DirectMut<T, ItemStatic> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ItemStruct> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ItemStruct)
where D: DirectMut<T, ItemStruct> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ItemTrait> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ItemTrait)
where D: DirectMut<T, ItemTrait> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ItemTraitAlias> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ItemTraitAlias)
where D: DirectMut<T, ItemTraitAlias> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ItemType> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ItemType)
where D: DirectMut<T, ItemType> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ItemUnion> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ItemUnion)
where D: DirectMut<T, ItemUnion> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ItemUse> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ItemUse)
where D: DirectMut<T, ItemUse> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<Label> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut Label)
where D: DirectMut<T, Label> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<Lifetime> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut Lifetime)
where D: DirectMut<T, Lifetime> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<LifetimeParam> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut LifetimeParam)
where D: DirectMut<T, LifetimeParam> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<Lit> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut Lit)
where D: DirectMut<T, Lit> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<LitBool> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut LitBool)
where D: DirectMut<T, LitBool> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<LitByte> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut LitByte)
where D: DirectMut<T, LitByte> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<LitByteStr> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut LitByteStr)
where D: DirectMut<T, LitByteStr> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<LitCStr> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut LitCStr)
where D: DirectMut<T, LitCStr> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<LitChar> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut LitChar)
where D: DirectMut<T, LitChar> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<LitFloat> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut LitFloat)
where D: DirectMut<T, LitFloat> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<LitInt> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut LitInt)
where D: DirectMut<T, LitInt> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<LitStr> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut LitStr)
where D: DirectMut<T, LitStr> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<Local> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut Local)
where D: DirectMut<T, Local> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<LocalInit> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut LocalInit)
where D: DirectMut<T, LocalInit> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<Macro> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut Macro)
where D: DirectMut<T, Macro> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<MacroDelimiter> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut MacroDelimiter)
where D: DirectMut<T, MacroDelimiter> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<Member> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut Member)
where D: DirectMut<T, Member> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<Meta> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut Meta)
where D: DirectMut<T, Meta> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<MetaList> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut MetaList)
where D: DirectMut<T, MetaList> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<MetaNameValue> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut MetaNameValue)
where D: DirectMut<T, MetaNameValue> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ParenthesizedGenericArguments> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>( visitor: Visitor<'_, D, T>, node: &mut ParenthesizedGenericArguments, )
where D: DirectMut<T, ParenthesizedGenericArguments> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<Pat> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut Pat)
where D: DirectMut<T, Pat> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<PatIdent> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut PatIdent)
where D: DirectMut<T, PatIdent> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<PatOr> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut PatOr)
where D: DirectMut<T, PatOr> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<PatParen> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut PatParen)
where D: DirectMut<T, PatParen> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<PatReference> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut PatReference)
where D: DirectMut<T, PatReference> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<PatRest> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut PatRest)
where D: DirectMut<T, PatRest> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<PatSlice> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut PatSlice)
where D: DirectMut<T, PatSlice> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<PatStruct> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut PatStruct)
where D: DirectMut<T, PatStruct> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<PatTuple> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut PatTuple)
where D: DirectMut<T, PatTuple> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<PatTupleStruct> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut PatTupleStruct)
where D: DirectMut<T, PatTupleStruct> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<PatType> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut PatType)
where D: DirectMut<T, PatType> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<PatWild> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut PatWild)
where D: DirectMut<T, PatWild> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<Path> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut Path)
where D: DirectMut<T, Path> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<PathArguments> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut PathArguments)
where D: DirectMut<T, PathArguments> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<PathSegment> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut PathSegment)
where D: DirectMut<T, PathSegment> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<PointerMutability> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut PointerMutability)
where D: DirectMut<T, PointerMutability> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<PreciseCapture> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut PreciseCapture)
where D: DirectMut<T, PreciseCapture> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<PredicateLifetime> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut PredicateLifetime)
where D: DirectMut<T, PredicateLifetime> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<PredicateType> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut PredicateType)
where D: DirectMut<T, PredicateType> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<QSelf> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut QSelf)
where D: DirectMut<T, QSelf> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<RangeLimits> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut RangeLimits)
where D: DirectMut<T, RangeLimits> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<Receiver> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut Receiver)
where D: DirectMut<T, Receiver> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<ReturnType> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut ReturnType)
where D: DirectMut<T, ReturnType> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<Signature> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut Signature)
where D: DirectMut<T, Signature> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<StaticMutability> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut StaticMutability)
where D: DirectMut<T, StaticMutability> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<Stmt> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut Stmt)
where D: DirectMut<T, Stmt> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<StmtMacro> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut StmtMacro)
where D: DirectMut<T, StmtMacro> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<TokenStream> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut TokenStream)
where D: DirectMut<T, TokenStream> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<TraitBound> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut TraitBound)
where D: DirectMut<T, TraitBound> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<TraitBoundModifier> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut TraitBoundModifier)
where D: DirectMut<T, TraitBoundModifier> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<TraitItem> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut TraitItem)
where D: DirectMut<T, TraitItem> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<TraitItemConst> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut TraitItemConst)
where D: DirectMut<T, TraitItemConst> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<TraitItemFn> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut TraitItemFn)
where D: DirectMut<T, TraitItemFn> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<TraitItemMacro> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut TraitItemMacro)
where D: DirectMut<T, TraitItemMacro> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<TraitItemType> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut TraitItemType)
where D: DirectMut<T, TraitItemType> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<Type> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut Type)
where D: DirectMut<T, Type> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<TypeArray> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut TypeArray)
where D: DirectMut<T, TypeArray> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<TypeBareFn> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut TypeBareFn)
where D: DirectMut<T, TypeBareFn> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<TypeGroup> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut TypeGroup)
where D: DirectMut<T, TypeGroup> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<TypeImplTrait> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut TypeImplTrait)
where D: DirectMut<T, TypeImplTrait> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<TypeInfer> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut TypeInfer)
where D: DirectMut<T, TypeInfer> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<TypeMacro> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut TypeMacro)
where D: DirectMut<T, TypeMacro> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<TypeNever> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut TypeNever)
where D: DirectMut<T, TypeNever> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<TypeParam> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut TypeParam)
where D: DirectMut<T, TypeParam> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<TypeParamBound> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut TypeParamBound)
where D: DirectMut<T, TypeParamBound> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<TypeParen> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut TypeParen)
where D: DirectMut<T, TypeParen> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<TypePath> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut TypePath)
where D: DirectMut<T, TypePath> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<TypePtr> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut TypePtr)
where D: DirectMut<T, TypePtr> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<TypeReference> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut TypeReference)
where D: DirectMut<T, TypeReference> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<TypeSlice> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut TypeSlice)
where D: DirectMut<T, TypeSlice> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<TypeTraitObject> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut TypeTraitObject)
where D: DirectMut<T, TypeTraitObject> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<TypeTuple> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut TypeTuple)
where D: DirectMut<T, TypeTuple> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<UnOp> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut UnOp)
where D: DirectMut<T, UnOp> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<UseGlob> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut UseGlob)
where D: DirectMut<T, UseGlob> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<UseGroup> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut UseGroup)
where D: DirectMut<T, UseGroup> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<UseName> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut UseName)
where D: DirectMut<T, UseName> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<UsePath> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut UsePath)
where D: DirectMut<T, UsePath> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<UseRename> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut UseRename)
where D: DirectMut<T, UseRename> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<UseTree> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut UseTree)
where D: DirectMut<T, UseTree> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<Variadic> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut Variadic)
where D: DirectMut<T, Variadic> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<Variant> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut Variant)
where D: DirectMut<T, Variant> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<VisRestricted> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut VisRestricted)
where D: DirectMut<T, VisRestricted> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<Visibility> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut Visibility)
where D: DirectMut<T, Visibility> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<WhereClause> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut WhereClause)
where D: DirectMut<T, WhereClause> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.
Source§

impl<T> VisitMut<WherePredicate> for T
where T: FullMut + ?Sized,

Source§

fn visit_mut<D>(visitor: Visitor<'_, D, T>, node: &mut WherePredicate)
where D: DirectMut<T, WherePredicate> + ?Sized,

Performs the visiting action. The default implementation simply calls Visitor::visit_mut(visitor, node), which returns control to the DirectMut implementation to continue to further sub-nodes. If you wish to skip sub-nodes, simply omit this call from your implementation.