Struct syntex_syntax::ext::expand::PatIdentRenamer [−] [src]

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: P<TraitItem>) -> SmallVector<P<TraitItem>>`

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

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

`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_opt_expr(&mut self, e: P<Expr>) -> Option<P<Expr>>`

`fn fold_exprs(&mut self, es: Vec<P<Expr>>) -> Vec<P<Expr>>`

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

`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_variant_data(&mut self, vdata: VariantData) -> VariantData`

`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_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 new_id(&mut self, i: NodeId) -> NodeId`

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