Struct syntax::ext::expand::PatIdentRenamerUnstable

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

A tree-folder that applies every rename in its list to the idents that are in PatIdent patterns. This is more narrowly focused than IdentRenamer, and is needed for FnDecl, where we want to rename the args but not the fn name or the generics etc.

Trait Implementations

impl<'a> Folder for PatIdentRenamer<'a>

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

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_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_ident(&mut self, i: Ident) -> Ident

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