Struct syntax::ext::expand::IdentRenamerUnstable

pub struct IdentRenamer<'a> {
    // some fields omitted
}

A tree-folder that applies every rename in its (mutable) list to every identifier, including both bindings and varrefs (and lots of things that will turn out to be neither)

Trait Implementations

impl<'a> Folder for IdentRenamer<'a>

fn fold_ident(&mut self, id: Ident) -> Ident

fn fold_mac(&mut self, mac: Mac) -> Mac

fn fold_crate(&mut self, c: Crate) -> Crate

fn fold_meta_items(&mut self, meta_items: Vec<P<MetaItem>>) -> Vec<P<MetaItem>>

fn fold_meta_item(&mut self, meta_item: P<MetaItem>) -> P<MetaItem>

fn fold_view_path(&mut self, view_path: P<ViewPath>) -> P<ViewPath>

fn fold_foreign_item(&mut self, ni: P<ForeignItem>) -> P<ForeignItem>

fn fold_item(&mut self, i: P<Item>) -> SmallVector<P<Item>>

fn fold_item_simple(&mut self, i: Item) -> Item

fn fold_struct_field(&mut self, sf: StructField) -> StructField

fn fold_item_underscore(&mut self, i: Item_) -> Item_

fn fold_trait_item(&mut self, i: TraitItem) -> SmallVector<TraitItem>

fn fold_impl_item(&mut self, i: ImplItem) -> SmallVector<ImplItem>

fn fold_fn_decl(&mut self, d: P<FnDecl>) -> P<FnDecl>

fn fold_type_method(&mut self, m: TypeMethod) -> TypeMethod

fn fold_method(&mut self, m: P<Method>) -> SmallVector<P<Method>>

fn fold_block(&mut self, b: P<Block>) -> P<Block>

fn fold_stmt(&mut self, s: P<Stmt>) -> SmallVector<P<Stmt>>

fn fold_arm(&mut self, a: Arm) -> Arm

fn fold_pat(&mut self, p: P<Pat>) -> P<Pat>

fn fold_decl(&mut self, d: P<Decl>) -> SmallVector<P<Decl>>

fn fold_expr(&mut self, e: P<Expr>) -> P<Expr>

fn fold_ty(&mut self, t: P<Ty>) -> P<Ty>

fn fold_qpath(&mut self, t: P<QPath>) -> P<QPath>

fn fold_ty_binding(&mut self, t: P<TypeBinding>) -> P<TypeBinding>

fn fold_mod(&mut self, m: Mod) -> Mod

fn fold_foreign_mod(&mut self, nm: ForeignMod) -> ForeignMod

fn fold_variant(&mut self, v: P<Variant>) -> P<Variant>

fn fold_usize(&mut self, i: usize) -> usize

fn fold_path(&mut self, p: Path) -> Path

fn fold_path_parameters(&mut self, p: PathParameters) -> PathParameters

fn fold_angle_bracketed_parameter_data(&mut self, p: AngleBracketedParameterData) -> AngleBracketedParameterData

fn fold_parenthesized_parameter_data(&mut self, p: ParenthesizedParameterData) -> ParenthesizedParameterData

fn fold_local(&mut self, l: P<Local>) -> P<Local>

fn fold_explicit_self(&mut self, es: ExplicitSelf) -> ExplicitSelf

fn fold_explicit_self_underscore(&mut self, es: ExplicitSelf_) -> ExplicitSelf_

fn fold_lifetime(&mut self, l: Lifetime) -> Lifetime

fn fold_lifetime_def(&mut self, l: LifetimeDef) -> LifetimeDef

fn fold_attribute(&mut self, at: Attribute) -> Option<Attribute>

fn fold_arg(&mut self, a: Arg) -> Arg

fn fold_generics(&mut self, generics: Generics) -> Generics

fn fold_trait_ref(&mut self, p: TraitRef) -> TraitRef

fn fold_poly_trait_ref(&mut self, p: PolyTraitRef) -> PolyTraitRef

fn fold_struct_def(&mut self, struct_def: P<StructDef>) -> P<StructDef>

fn fold_lifetimes(&mut self, lts: Vec<Lifetime>) -> Vec<Lifetime>

fn fold_lifetime_defs(&mut self, lts: Vec<LifetimeDef>) -> Vec<LifetimeDef>

fn fold_ty_param(&mut self, tp: TyParam) -> TyParam

fn fold_ty_params(&mut self, tps: OwnedSlice<TyParam>) -> OwnedSlice<TyParam>

fn fold_tt(&mut self, tt: &TokenTree) -> TokenTree

fn fold_tts(&mut self, tts: &[TokenTree]) -> Vec<TokenTree>

fn fold_token(&mut self, t: Token) -> Token

fn fold_interpolated(&mut self, nt: Nonterminal) -> Nonterminal

fn fold_opt_lifetime(&mut self, o_lt: Option<Lifetime>) -> Option<Lifetime>

fn fold_variant_arg(&mut self, va: VariantArg) -> VariantArg

fn fold_opt_bounds(&mut self, b: Option<OwnedSlice<TyParamBound>>) -> Option<OwnedSlice<TyParamBound>>

fn fold_bounds(&mut self, b: OwnedSlice<TyParamBound>) -> OwnedSlice<TyParamBound>

fn fold_ty_param_bound(&mut self, tpb: TyParamBound) -> TyParamBound

fn fold_mt(&mut self, mt: MutTy) -> MutTy

fn fold_field(&mut self, field: Field) -> Field

fn fold_where_clause(&mut self, where_clause: WhereClause) -> WhereClause

fn fold_where_predicate(&mut self, where_predicate: WherePredicate) -> WherePredicate

fn fold_typedef(&mut self, typedef: Typedef) -> Typedef

fn fold_associated_type(&mut self, associated_type: AssociatedType) -> AssociatedType

fn new_id(&mut self, i: NodeId) -> NodeId

fn new_span(&mut self, sp: Span) -> Span