Struct Crateify 

pub struct Crateify(/* private fields */);

Implementations

impl Crateify

pub fn new() -> Self

pub fn new_as_crate(crate_ident: Ident) -> Self

Trait Implementations

impl Default for Crateify

fn default() -> Self

Returns the “default value” for a type.

impl FullMut for Crateify

fn visit_path_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Path)

where D: DirectMut<Self, Path> + ?Sized,

Visits syn::Path nodes

fn visit_item_use_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ItemUse)

where D: DirectMut<Self, ItemUse> + ?Sized,

Visits syn::ItemUse nodes

fn visit_abi_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Abi)

where D: DirectMut<Self, Abi> + ?Sized,

Visits syn::Abi nodes

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

fn visit_arm_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Arm)

where D: DirectMut<Self, Arm> + ?Sized,

Visits syn::Arm nodes

fn visit_assoc_const_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut AssocConst, )

where D: DirectMut<Self, AssocConst> + ?Sized,

Visits syn::AssocConst nodes

fn visit_assoc_type_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut AssocType)

where D: DirectMut<Self, AssocType> + ?Sized,

Visits syn::AssocType nodes

fn visit_attr_style_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut AttrStyle)

where D: DirectMut<Self, AttrStyle> + ?Sized,

Visits syn::AttrStyle nodes

fn visit_attribute_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Attribute)

where D: DirectMut<Self, Attribute> + ?Sized,

Visits syn::Attribute nodes

fn visit_bare_fn_arg_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut BareFnArg)

where D: DirectMut<Self, BareFnArg> + ?Sized,

Visits syn::BareFnArg nodes

fn visit_bare_variadic_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut BareVariadic, )

where D: DirectMut<Self, BareVariadic> + ?Sized,

Visits syn::BareVariadic nodes

fn visit_bin_op_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut BinOp)

where D: DirectMut<Self, BinOp> + ?Sized,

Visits syn::BinOp nodes

fn visit_block_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Block)

where D: DirectMut<Self, Block> + ?Sized,

Visits syn::Block nodes

fn visit_bound_lifetimes_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut BoundLifetimes, )

where D: DirectMut<Self, BoundLifetimes> + ?Sized,

Visits syn::BoundLifetimes nodes

fn visit_captured_param_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut CapturedParam, )

where D: DirectMut<Self, CapturedParam> + ?Sized,

Visits syn::CapturedParam nodes

fn visit_const_param_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ConstParam, )

where D: DirectMut<Self, ConstParam> + ?Sized,

Visits syn::ConstParam nodes

fn visit_constraint_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Constraint)

where D: DirectMut<Self, Constraint> + ?Sized,

Visits syn::Constraint nodes

fn visit_data_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Data)

where D: DirectMut<Self, Data> + ?Sized,

Visits syn::Data nodes

fn visit_data_enum_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut DataEnum)

where D: DirectMut<Self, DataEnum> + ?Sized,

Visits syn::DataEnum nodes

fn visit_data_struct_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut DataStruct, )

where D: DirectMut<Self, DataStruct> + ?Sized,

Visits syn::DataStruct nodes

fn visit_data_union_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut DataUnion)

where D: DirectMut<Self, DataUnion> + ?Sized,

Visits syn::DataUnion nodes

fn visit_derive_input_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut DeriveInput, )

where D: DirectMut<Self, DeriveInput> + ?Sized,

Visits syn::DeriveInput nodes

fn visit_expr_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Expr)

where D: DirectMut<Self, Expr> + ?Sized,

Visits syn::Expr nodes

fn visit_expr_array_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprArray)

where D: DirectMut<Self, ExprArray> + ?Sized,

Visits syn::ExprArray nodes

fn visit_expr_assign_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ExprAssign, )

where D: DirectMut<Self, ExprAssign> + ?Sized,

Visits syn::ExprAssign nodes

fn visit_expr_async_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprAsync)

where D: DirectMut<Self, ExprAsync> + ?Sized,

Visits syn::ExprAsync nodes

fn visit_expr_await_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprAwait)

where D: DirectMut<Self, ExprAwait> + ?Sized,

Visits syn::ExprAwait nodes

fn visit_expr_binary_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ExprBinary, )

where D: DirectMut<Self, ExprBinary> + ?Sized,

Visits syn::ExprBinary nodes

fn visit_expr_block_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprBlock)

where D: DirectMut<Self, ExprBlock> + ?Sized,

Visits syn::ExprBlock nodes

fn visit_expr_break_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprBreak)

where D: DirectMut<Self, ExprBreak> + ?Sized,

Visits syn::ExprBreak nodes

fn visit_expr_call_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprCall)

where D: DirectMut<Self, ExprCall> + ?Sized,

Visits syn::ExprCall nodes

fn visit_expr_cast_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprCast)

where D: DirectMut<Self, ExprCast> + ?Sized,

Visits syn::ExprCast nodes

fn visit_expr_closure_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ExprClosure, )

where D: DirectMut<Self, ExprClosure> + ?Sized,

Visits syn::ExprClosure nodes

fn visit_expr_const_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprConst)

where D: DirectMut<Self, ExprConst> + ?Sized,

Visits syn::ExprConst nodes

fn visit_expr_continue_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ExprContinue, )

where D: DirectMut<Self, ExprContinue> + ?Sized,

Visits syn::ExprContinue nodes

fn visit_expr_field_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprField)

where D: DirectMut<Self, ExprField> + ?Sized,

Visits syn::ExprField nodes

fn visit_expr_for_loop_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ExprForLoop, )

where D: DirectMut<Self, ExprForLoop> + ?Sized,

Visits syn::ExprForLoop nodes

fn visit_expr_group_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprGroup)

where D: DirectMut<Self, ExprGroup> + ?Sized,

Visits syn::ExprGroup nodes

fn visit_expr_if_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprIf)

where D: DirectMut<Self, ExprIf> + ?Sized,

Visits syn::ExprIf nodes

fn visit_expr_index_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprIndex)

where D: DirectMut<Self, ExprIndex> + ?Sized,

Visits syn::ExprIndex nodes

fn visit_expr_infer_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprInfer)

where D: DirectMut<Self, ExprInfer> + ?Sized,

Visits syn::ExprInfer nodes

fn visit_expr_let_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprLet)

where D: DirectMut<Self, ExprLet> + ?Sized,

Visits syn::ExprLet nodes

fn visit_expr_lit_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprLit)

where D: DirectMut<Self, ExprLit> + ?Sized,

Visits syn::ExprLit nodes

fn visit_expr_loop_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprLoop)

where D: DirectMut<Self, ExprLoop> + ?Sized,

Visits syn::ExprLoop nodes

fn visit_expr_macro_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprMacro)

where D: DirectMut<Self, ExprMacro> + ?Sized,

Visits syn::ExprMacro nodes

fn visit_expr_match_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprMatch)

where D: DirectMut<Self, ExprMatch> + ?Sized,

Visits syn::ExprMatch nodes

fn visit_expr_method_call_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ExprMethodCall, )

where D: DirectMut<Self, ExprMethodCall> + ?Sized,

Visits syn::ExprMethodCall nodes

fn visit_expr_paren_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprParen)

where D: DirectMut<Self, ExprParen> + ?Sized,

Visits syn::ExprParen nodes

fn visit_expr_path_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprPath)

where D: DirectMut<Self, ExprPath> + ?Sized,

Visits syn::ExprPath nodes

fn visit_expr_range_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprRange)

where D: DirectMut<Self, ExprRange> + ?Sized,

Visits syn::ExprRange nodes

fn visit_expr_raw_addr_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ExprRawAddr, )

where D: DirectMut<Self, ExprRawAddr> + ?Sized,

Visits syn::ExprRawAddr nodes

fn visit_expr_reference_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ExprReference, )

where D: DirectMut<Self, ExprReference> + ?Sized,

Visits syn::ExprReference nodes

fn visit_expr_repeat_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ExprRepeat, )

where D: DirectMut<Self, ExprRepeat> + ?Sized,

Visits syn::ExprRepeat nodes

fn visit_expr_return_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ExprReturn, )

where D: DirectMut<Self, ExprReturn> + ?Sized,

Visits syn::ExprReturn nodes

fn visit_expr_struct_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ExprStruct, )

where D: DirectMut<Self, ExprStruct> + ?Sized,

Visits syn::ExprStruct nodes

fn visit_expr_try_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprTry)

where D: DirectMut<Self, ExprTry> + ?Sized,

Visits syn::ExprTry nodes

fn visit_expr_try_block_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ExprTryBlock, )

where D: DirectMut<Self, ExprTryBlock> + ?Sized,

Visits syn::ExprTryBlock nodes

fn visit_expr_tuple_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprTuple)

where D: DirectMut<Self, ExprTuple> + ?Sized,

Visits syn::ExprTuple nodes

fn visit_expr_unary_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprUnary)

where D: DirectMut<Self, ExprUnary> + ?Sized,

Visits syn::ExprUnary nodes

fn visit_expr_unsafe_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ExprUnsafe, )

where D: DirectMut<Self, ExprUnsafe> + ?Sized,

Visits syn::ExprUnsafe nodes

fn visit_expr_while_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprWhile)

where D: DirectMut<Self, ExprWhile> + ?Sized,

Visits syn::ExprWhile nodes

fn visit_expr_yield_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ExprYield)

where D: DirectMut<Self, ExprYield> + ?Sized,

Visits syn::ExprYield nodes

fn visit_field_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Field)

where D: DirectMut<Self, Field> + ?Sized,

Visits syn::Field nodes

fn visit_field_mutability_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut FieldMutability, )

where D: DirectMut<Self, FieldMutability> + ?Sized,

Visits syn::FieldMutability nodes

fn visit_field_pat_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut FieldPat)

where D: DirectMut<Self, FieldPat> + ?Sized,

Visits syn::FieldPat nodes

fn visit_field_value_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut FieldValue, )

where D: DirectMut<Self, FieldValue> + ?Sized,

Visits syn::FieldValue nodes

fn visit_fields_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Fields)

where D: DirectMut<Self, Fields> + ?Sized,

Visits syn::Fields nodes

fn visit_fields_named_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut FieldsNamed, )

where D: DirectMut<Self, FieldsNamed> + ?Sized,

Visits syn::FieldsNamed nodes

fn visit_fields_unnamed_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut FieldsUnnamed, )

where D: DirectMut<Self, FieldsUnnamed> + ?Sized,

Visits syn::FieldsUnnamed nodes

fn visit_file_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut File)

where D: DirectMut<Self, File> + ?Sized,

Visits syn::File nodes

fn visit_fn_arg_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut FnArg)

where D: DirectMut<Self, FnArg> + ?Sized,

Visits syn::FnArg nodes

fn visit_foreign_item_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ForeignItem, )

where D: DirectMut<Self, ForeignItem> + ?Sized,

Visits syn::ForeignItem nodes

fn visit_foreign_item_fn_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ForeignItemFn, )

where D: DirectMut<Self, ForeignItemFn> + ?Sized,

Visits syn::ForeignItemFn nodes

fn visit_foreign_item_macro_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ForeignItemMacro, )

where D: DirectMut<Self, ForeignItemMacro> + ?Sized,

Visits syn::ForeignItemMacro nodes

fn visit_foreign_item_static_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ForeignItemStatic, )

where D: DirectMut<Self, ForeignItemStatic> + ?Sized,

Visits syn::ForeignItemStatic nodes

fn visit_foreign_item_type_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ForeignItemType, )

where D: DirectMut<Self, ForeignItemType> + ?Sized,

Visits syn::ForeignItemType nodes

fn visit_generic_argument_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut GenericArgument, )

where D: DirectMut<Self, GenericArgument> + ?Sized,

Visits syn::GenericArgument nodes

fn visit_generic_param_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut GenericParam, )

where D: DirectMut<Self, GenericParam> + ?Sized,

Visits syn::GenericParam nodes

fn visit_generics_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Generics)

where D: DirectMut<Self, Generics> + ?Sized,

Visits syn::Generics nodes

fn visit_ident_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Ident)

where D: DirectMut<Self, Ident> + ?Sized,

Visits proc_macro2::Ident nodes

fn visit_impl_item_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ImplItem)

where D: DirectMut<Self, ImplItem> + ?Sized,

Visits syn::ImplItem nodes

fn visit_impl_item_const_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ImplItemConst, )

where D: DirectMut<Self, ImplItemConst> + ?Sized,

Visits syn::ImplItemConst nodes

fn visit_impl_item_fn_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ImplItemFn, )

where D: DirectMut<Self, ImplItemFn> + ?Sized,

Visits syn::ImplItemFn nodes

fn visit_impl_item_macro_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ImplItemMacro, )

where D: DirectMut<Self, ImplItemMacro> + ?Sized,

Visits syn::ImplItemMacro nodes

fn visit_impl_item_type_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ImplItemType, )

where D: DirectMut<Self, ImplItemType> + ?Sized,

Visits syn::ImplItemType nodes

fn visit_impl_restriction_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ImplRestriction, )

where D: DirectMut<Self, ImplRestriction> + ?Sized,

Visits syn::ImplRestriction nodes

fn visit_index_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Index)

where D: DirectMut<Self, Index> + ?Sized,

Visits syn::Index nodes

fn visit_item_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Item)

where D: DirectMut<Self, Item> + ?Sized,

Visits syn::Item nodes

fn visit_item_const_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ItemConst)

where D: DirectMut<Self, ItemConst> + ?Sized,

Visits syn::ItemConst nodes

fn visit_item_enum_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ItemEnum)

where D: DirectMut<Self, ItemEnum> + ?Sized,

Visits syn::ItemEnum nodes

fn visit_item_extern_crate_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ItemExternCrate, )

where D: DirectMut<Self, ItemExternCrate> + ?Sized,

Visits syn::ItemExternCrate nodes

fn visit_item_fn_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ItemFn)

where D: DirectMut<Self, ItemFn> + ?Sized,

Visits syn::ItemFn nodes

fn visit_item_foreign_mod_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ItemForeignMod, )

where D: DirectMut<Self, ItemForeignMod> + ?Sized,

Visits syn::ItemForeignMod nodes

fn visit_item_impl_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ItemImpl)

where D: DirectMut<Self, ItemImpl> + ?Sized,

Visits syn::ItemImpl nodes

fn visit_item_macro_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ItemMacro)

where D: DirectMut<Self, ItemMacro> + ?Sized,

Visits syn::ItemMacro nodes

fn visit_item_mod_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ItemMod)

where D: DirectMut<Self, ItemMod> + ?Sized,

Visits syn::ItemMod nodes

fn visit_item_static_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ItemStatic, )

where D: DirectMut<Self, ItemStatic> + ?Sized,

Visits syn::ItemStatic nodes

fn visit_item_struct_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ItemStruct, )

where D: DirectMut<Self, ItemStruct> + ?Sized,

Visits syn::ItemStruct nodes

fn visit_item_trait_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ItemTrait)

where D: DirectMut<Self, ItemTrait> + ?Sized,

Visits syn::ItemTrait nodes

fn visit_item_trait_alias_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ItemTraitAlias, )

where D: DirectMut<Self, ItemTraitAlias> + ?Sized,

Visits syn::ItemTraitAlias nodes

fn visit_item_type_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ItemType)

where D: DirectMut<Self, ItemType> + ?Sized,

Visits syn::ItemType nodes

fn visit_item_union_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut ItemUnion)

where D: DirectMut<Self, ItemUnion> + ?Sized,

Visits syn::ItemUnion nodes

fn visit_label_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Label)

where D: DirectMut<Self, Label> + ?Sized,

Visits syn::Label nodes

fn visit_lifetime_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Lifetime)

where D: DirectMut<Self, Lifetime> + ?Sized,

Visits syn::Lifetime nodes

fn visit_lifetime_param_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut LifetimeParam, )

where D: DirectMut<Self, LifetimeParam> + ?Sized,

Visits syn::LifetimeParam nodes

fn visit_lit_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Lit)

where D: DirectMut<Self, Lit> + ?Sized,

Visits syn::Lit nodes

fn visit_lit_bool_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut LitBool)

where D: DirectMut<Self, LitBool> + ?Sized,

Visits syn::LitBool nodes

fn visit_lit_byte_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut LitByte)

where D: DirectMut<Self, LitByte> + ?Sized,

Visits syn::LitByte nodes

fn visit_lit_byte_str_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut LitByteStr, )

where D: DirectMut<Self, LitByteStr> + ?Sized,

Visits syn::LitByteStr nodes

fn visit_lit_cstr_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut LitCStr)

where D: DirectMut<Self, LitCStr> + ?Sized,

Visits syn::LitCStr nodes

fn visit_lit_char_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut LitChar)

where D: DirectMut<Self, LitChar> + ?Sized,

Visits syn::LitChar nodes

fn visit_lit_float_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut LitFloat)

where D: DirectMut<Self, LitFloat> + ?Sized,

Visits syn::LitFloat nodes

fn visit_lit_int_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut LitInt)

where D: DirectMut<Self, LitInt> + ?Sized,

Visits syn::LitInt nodes

fn visit_lit_str_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut LitStr)

where D: DirectMut<Self, LitStr> + ?Sized,

Visits syn::LitStr nodes

fn visit_local_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Local)

where D: DirectMut<Self, Local> + ?Sized,

Visits syn::Local nodes

fn visit_local_init_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut LocalInit)

where D: DirectMut<Self, LocalInit> + ?Sized,

Visits syn::LocalInit nodes

fn visit_macro_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Macro)

where D: DirectMut<Self, Macro> + ?Sized,

Visits syn::Macro nodes

fn visit_macro_delimiter_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut MacroDelimiter, )

where D: DirectMut<Self, MacroDelimiter> + ?Sized,

Visits syn::MacroDelimiter nodes

fn visit_member_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Member)

where D: DirectMut<Self, Member> + ?Sized,

Visits syn::Member nodes

fn visit_meta_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Meta)

where D: DirectMut<Self, Meta> + ?Sized,

Visits syn::Meta nodes

fn visit_meta_list_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut MetaList)

where D: DirectMut<Self, MetaList> + ?Sized,

Visits syn::MetaList nodes

fn visit_meta_name_value_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut MetaNameValue, )

where D: DirectMut<Self, MetaNameValue> + ?Sized,

Visits syn::MetaNameValue nodes

fn visit_parenthesized_generic_arguments_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ParenthesizedGenericArguments, )

where D: DirectMut<Self, ParenthesizedGenericArguments> + ?Sized,

Visits syn::ParenthesizedGenericArguments nodes

fn visit_pat_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Pat)

where D: DirectMut<Self, Pat> + ?Sized,

Visits syn::Pat nodes

fn visit_pat_ident_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut PatIdent)

where D: DirectMut<Self, PatIdent> + ?Sized,

Visits syn::PatIdent nodes

fn visit_pat_or_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut PatOr)

where D: DirectMut<Self, PatOr> + ?Sized,

Visits syn::PatOr nodes

fn visit_pat_paren_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut PatParen)

where D: DirectMut<Self, PatParen> + ?Sized,

Visits syn::PatParen nodes

fn visit_pat_reference_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut PatReference, )

where D: DirectMut<Self, PatReference> + ?Sized,

Visits syn::PatReference nodes

fn visit_pat_rest_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut PatRest)

where D: DirectMut<Self, PatRest> + ?Sized,

Visits syn::PatRest nodes

fn visit_pat_slice_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut PatSlice)

where D: DirectMut<Self, PatSlice> + ?Sized,

Visits syn::PatSlice nodes

fn visit_pat_struct_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut PatStruct)

where D: DirectMut<Self, PatStruct> + ?Sized,

Visits syn::PatStruct nodes

fn visit_pat_tuple_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut PatTuple)

where D: DirectMut<Self, PatTuple> + ?Sized,

Visits syn::PatTuple nodes

fn visit_pat_tuple_struct_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut PatTupleStruct, )

where D: DirectMut<Self, PatTupleStruct> + ?Sized,

Visits syn::PatTupleStruct nodes

fn visit_pat_type_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut PatType)

where D: DirectMut<Self, PatType> + ?Sized,

Visits syn::PatType nodes

fn visit_pat_wild_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut PatWild)

where D: DirectMut<Self, PatWild> + ?Sized,

Visits syn::PatWild nodes

fn visit_path_arguments_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut PathArguments, )

where D: DirectMut<Self, PathArguments> + ?Sized,

Visits syn::PathArguments nodes

fn visit_path_segment_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut PathSegment, )

where D: DirectMut<Self, PathSegment> + ?Sized,

Visits syn::PathSegment nodes

fn visit_pointer_mutability_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut PointerMutability, )

where D: DirectMut<Self, PointerMutability> + ?Sized,

Visits syn::PointerMutability nodes

fn visit_precise_capture_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut PreciseCapture, )

where D: DirectMut<Self, PreciseCapture> + ?Sized,

Visits syn::PreciseCapture nodes

fn visit_predicate_lifetime_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut PredicateLifetime, )

where D: DirectMut<Self, PredicateLifetime> + ?Sized,

Visits syn::PredicateLifetime nodes

fn visit_predicate_type_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut PredicateType, )

where D: DirectMut<Self, PredicateType> + ?Sized,

Visits syn::PredicateType nodes

fn visit_qself_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut QSelf)

where D: DirectMut<Self, QSelf> + ?Sized,

Visits syn::QSelf nodes

fn visit_range_limits_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut RangeLimits, )

where D: DirectMut<Self, RangeLimits> + ?Sized,

Visits syn::RangeLimits nodes

fn visit_receiver_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Receiver)

where D: DirectMut<Self, Receiver> + ?Sized,

Visits syn::Receiver nodes

fn visit_return_type_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut ReturnType, )

where D: DirectMut<Self, ReturnType> + ?Sized,

Visits syn::ReturnType nodes

fn visit_signature_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Signature)

where D: DirectMut<Self, Signature> + ?Sized,

Visits syn::Signature nodes

fn visit_static_mutability_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut StaticMutability, )

where D: DirectMut<Self, StaticMutability> + ?Sized,

Visits syn::StaticMutability nodes

fn visit_stmt_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Stmt)

where D: DirectMut<Self, Stmt> + ?Sized,

Visits syn::Stmt nodes

fn visit_stmt_macro_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut StmtMacro)

where D: DirectMut<Self, StmtMacro> + ?Sized,

Visits syn::StmtMacro nodes

fn visit_token_stream_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut TokenStream, )

where D: DirectMut<Self, TokenStream> + ?Sized,

Visits proc_macro2::TokenStream nodes

fn visit_trait_bound_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut TraitBound, )

where D: DirectMut<Self, TraitBound> + ?Sized,

Visits syn::TraitBound nodes

fn visit_trait_bound_modifier_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut TraitBoundModifier, )

where D: DirectMut<Self, TraitBoundModifier> + ?Sized,

Visits syn::TraitBoundModifier nodes

fn visit_trait_item_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut TraitItem)

where D: DirectMut<Self, TraitItem> + ?Sized,

Visits syn::TraitItem nodes

fn visit_trait_item_const_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut TraitItemConst, )

where D: DirectMut<Self, TraitItemConst> + ?Sized,

Visits syn::TraitItemConst nodes

fn visit_trait_item_fn_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut TraitItemFn, )

where D: DirectMut<Self, TraitItemFn> + ?Sized,

Visits syn::TraitItemFn nodes

fn visit_trait_item_macro_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut TraitItemMacro, )

where D: DirectMut<Self, TraitItemMacro> + ?Sized,

Visits syn::TraitItemMacro nodes

fn visit_trait_item_type_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut TraitItemType, )

where D: DirectMut<Self, TraitItemType> + ?Sized,

Visits syn::TraitItemType nodes

fn visit_type_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Type)

where D: DirectMut<Self, Type> + ?Sized,

Visits syn::Type nodes

fn visit_type_array_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut TypeArray)

where D: DirectMut<Self, TypeArray> + ?Sized,

Visits syn::TypeArray nodes

fn visit_type_bare_fn_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut TypeBareFn, )

where D: DirectMut<Self, TypeBareFn> + ?Sized,

Visits syn::TypeBareFn nodes

fn visit_type_group_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut TypeGroup)

where D: DirectMut<Self, TypeGroup> + ?Sized,

Visits syn::TypeGroup nodes

fn visit_type_impl_trait_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut TypeImplTrait, )

where D: DirectMut<Self, TypeImplTrait> + ?Sized,

Visits syn::TypeImplTrait nodes

fn visit_type_infer_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut TypeInfer)

where D: DirectMut<Self, TypeInfer> + ?Sized,

Visits syn::TypeInfer nodes

fn visit_type_macro_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut TypeMacro)

where D: DirectMut<Self, TypeMacro> + ?Sized,

Visits syn::TypeMacro nodes

fn visit_type_never_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut TypeNever)

where D: DirectMut<Self, TypeNever> + ?Sized,

Visits syn::TypeNever nodes

fn visit_type_param_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut TypeParam)

where D: DirectMut<Self, TypeParam> + ?Sized,

Visits syn::TypeParam nodes

fn visit_type_param_bound_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut TypeParamBound, )

where D: DirectMut<Self, TypeParamBound> + ?Sized,

Visits syn::TypeParamBound nodes

fn visit_type_paren_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut TypeParen)

where D: DirectMut<Self, TypeParen> + ?Sized,

Visits syn::TypeParen nodes

fn visit_type_path_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut TypePath)

where D: DirectMut<Self, TypePath> + ?Sized,

Visits syn::TypePath nodes

fn visit_type_ptr_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut TypePtr)

where D: DirectMut<Self, TypePtr> + ?Sized,

Visits syn::TypePtr nodes

fn visit_type_reference_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut TypeReference, )

where D: DirectMut<Self, TypeReference> + ?Sized,

Visits syn::TypeReference nodes

fn visit_type_slice_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut TypeSlice)

where D: DirectMut<Self, TypeSlice> + ?Sized,

Visits syn::TypeSlice nodes

fn visit_type_trait_object_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut TypeTraitObject, )

where D: DirectMut<Self, TypeTraitObject> + ?Sized,

Visits syn::TypeTraitObject nodes

fn visit_type_tuple_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut TypeTuple)

where D: DirectMut<Self, TypeTuple> + ?Sized,

Visits syn::TypeTuple nodes

fn visit_un_op_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut UnOp)

where D: DirectMut<Self, UnOp> + ?Sized,

Visits syn::UnOp nodes

fn visit_use_glob_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut UseGlob)

where D: DirectMut<Self, UseGlob> + ?Sized,

Visits syn::UseGlob nodes

fn visit_use_group_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut UseGroup)

where D: DirectMut<Self, UseGroup> + ?Sized,

Visits syn::UseGroup nodes

fn visit_use_name_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut UseName)

where D: DirectMut<Self, UseName> + ?Sized,

Visits syn::UseName nodes

fn visit_use_path_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut UsePath)

where D: DirectMut<Self, UsePath> + ?Sized,

Visits syn::UsePath nodes

fn visit_use_rename_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut UseRename)

where D: DirectMut<Self, UseRename> + ?Sized,

Visits syn::UseRename nodes

fn visit_use_tree_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut UseTree)

where D: DirectMut<Self, UseTree> + ?Sized,

Visits syn::UseTree nodes

fn visit_variadic_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Variadic)

where D: DirectMut<Self, Variadic> + ?Sized,

Visits syn::Variadic nodes

fn visit_variant_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Variant)

where D: DirectMut<Self, Variant> + ?Sized,

Visits syn::Variant nodes

fn visit_vis_restricted_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut VisRestricted, )

where D: DirectMut<Self, VisRestricted> + ?Sized,

Visits syn::VisRestricted nodes

fn visit_visibility_mut<D>(visitor: Visitor<'_, D, Self>, node: &mut Visibility)

where D: DirectMut<Self, Visibility> + ?Sized,

Visits syn::Visibility nodes

fn visit_where_clause_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut WhereClause, )

where D: DirectMut<Self, WhereClause> + ?Sized,

Visits syn::WhereClause nodes

fn visit_where_predicate_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut WherePredicate, )

where D: DirectMut<Self, WherePredicate> + ?Sized,

Visits syn::WherePredicate nodes

fn visit_generics_enter_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut GenericsEnter, )

where D: DirectMut<Self, GenericsEnter> + ?Sized,

Visits crate::syn::GenericsEnter nodes

fn visit_generics_exit_mut<D>( visitor: Visitor<'_, D, Self>, node: &mut GenericsExit, )

where D: DirectMut<Self, GenericsExit> + ?Sized,

Visits crate::syn::GenericsExit nodes