[−][src]Trait syntax::fold::Folder

pub trait Folder: Sized {
    fn fold_crate(&mut self, c: Crate) -> Crate { ... }
    fn fold_meta_items(&mut self, meta_items: Vec<MetaItem>) -> Vec<MetaItem> { ... }
    fn fold_meta_list_item(
        &mut self, 
        list_item: NestedMetaItem
    ) -> NestedMetaItem { ... }
    fn fold_meta_item(&mut self, meta_item: MetaItem) -> MetaItem { ... }
    fn fold_use_tree(&mut self, use_tree: UseTree) -> UseTree { ... }
    fn fold_foreign_item(&mut self, ni: ForeignItem) -> OneVector<ForeignItem> { ... }
    fn fold_foreign_item_simple(&mut self, ni: ForeignItem) -> ForeignItem { ... }
    fn fold_item(&mut self, i: P<Item>) -> OneVector<P<Item>> { ... }
    fn fold_item_simple(&mut self, i: Item) -> Item { ... }
    fn fold_fn_header(&mut self, header: FnHeader) -> FnHeader { ... }
    fn fold_struct_field(&mut self, sf: StructField) -> StructField { ... }
    fn fold_item_kind(&mut self, i: ItemKind) -> ItemKind { ... }
    fn fold_trait_item(&mut self, i: TraitItem) -> OneVector<TraitItem> { ... }
    fn fold_impl_item(&mut self, i: ImplItem) -> OneVector<ImplItem> { ... }
    fn fold_fn_decl(&mut self, d: P<FnDecl>) -> P<FnDecl> { ... }
    fn fold_asyncness(&mut self, a: IsAsync) -> IsAsync { ... }
    fn fold_block(&mut self, b: P<Block>) -> P<Block> { ... }
    fn fold_stmt(&mut self, s: Stmt) -> OneVector<Stmt> { ... }
    fn fold_arm(&mut self, a: Arm) -> Arm { ... }
    fn fold_guard(&mut self, g: Guard) -> Guard { ... }
    fn fold_pat(&mut self, p: P<Pat>) -> P<Pat> { ... }
    fn fold_anon_const(&mut self, c: AnonConst) -> AnonConst { ... }
    fn fold_expr(&mut self, e: P<Expr>) -> P<Expr> { ... }
    fn fold_range_end(&mut self, re: RangeEnd) -> RangeEnd { ... }
    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_generic_arg(&mut self, arg: GenericArg) -> GenericArg { ... }
    fn fold_ty(&mut self, t: P<Ty>) -> P<Ty> { ... }
    fn fold_lifetime(&mut self, l: Lifetime) -> Lifetime { ... }
    fn fold_ty_binding(&mut self, t: TypeBinding) -> TypeBinding { ... }
    fn fold_mod(&mut self, m: Mod) -> Mod { ... }
    fn fold_foreign_mod(&mut self, nm: ForeignMod) -> ForeignMod { ... }
    fn fold_global_asm(&mut self, ga: P<GlobalAsm>) -> P<GlobalAsm> { ... }
    fn fold_variant(&mut self, v: Variant) -> 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_qpath(
        &mut self, 
        qs: Option<QSelf>, 
        p: Path
    ) -> (Option<QSelf>, Path) { ... }
    fn fold_generic_args(&mut self, p: GenericArgs) -> GenericArgs { ... }
    fn fold_angle_bracketed_parameter_data(
        &mut self, 
        p: AngleBracketedArgs
    ) -> AngleBracketedArgs { ... }
    fn fold_parenthesized_parameter_data(
        &mut self, 
        p: ParenthesisedArgs
    ) -> ParenthesisedArgs { ... }
    fn fold_local(&mut self, l: P<Local>) -> P<Local> { ... }
    fn fold_mac(&mut self, _mac: Mac) -> Mac { ... }
    fn fold_macro_def(&mut self, def: MacroDef) -> MacroDef { ... }
    fn fold_label(&mut self, label: Label) -> Label { ... }
    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_generic_param(&mut self, param: GenericParam) -> GenericParam { ... }
    fn fold_generic_params(
        &mut self, 
        params: Vec<GenericParam>
    ) -> Vec<GenericParam> { ... }
    fn fold_tt(&mut self, tt: TokenTree) -> TokenTree { ... }
    fn fold_tts(&mut self, tts: TokenStream) -> TokenStream { ... }
    fn fold_token(&mut self, t: Token) -> Token { ... }
    fn fold_interpolated(&mut self, nt: Nonterminal) -> Nonterminal { ... }
    fn fold_opt_bounds(
        &mut self, 
        b: Option<GenericBounds>
    ) -> Option<GenericBounds> { ... }
    fn fold_bounds(&mut self, b: GenericBounds) -> GenericBounds { ... }
    fn fold_param_bound(&mut self, tpb: GenericBound) -> GenericBound { ... }
    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_vis(&mut self, vis: Visibility) -> Visibility { ... }
    fn new_id(&mut self, i: NodeId) -> NodeId { ... }
    fn new_span(&mut self, sp: Span) -> Span { ... }
}

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

Provided Methods

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

Important traits for Vec<u8>

impl Write for Vec<u8>

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_meta_list_item(&mut self, list_item: NestedMetaItem) -> NestedMetaItem`

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_use_tree(&mut self, use_tree: UseTree) -> UseTree`

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_foreign_item_simple(&mut self, ni: ForeignItem) -> ForeignItem`

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_fn_header(&mut self, header: FnHeader) -> FnHeader`

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_item_kind(&mut self, i: ItemKind) -> ItemKind`

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_asyncness(&mut self, a: IsAsync) -> IsAsync`

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_stmt(&mut self, s: Stmt) -> OneVector<Stmt>`

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_guard(&mut self, g: Guard) -> Guard`

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_anon_const(&mut self, c: AnonConst) -> AnonConst`

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_range_end(&mut self, re: RangeEnd) -> RangeEnd`

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_opt_expr(&mut self, e: P<Expr>) -> Option<P<Expr>>`

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

Important traits for Vec<u8>

impl Write for Vec<u8>

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_generic_arg(&mut self, arg: GenericArg) -> GenericArg`

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_global_asm(&mut self, ga: P<GlobalAsm>) -> P<GlobalAsm>`

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_qpath(&mut self, qs: Option<QSelf>, p: Path) -> (Option<QSelf>, Path)`

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_generic_args(&mut self, p: GenericArgs) -> GenericArgs`

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_macro_def(&mut self, def: MacroDef) -> MacroDef`

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_label(&mut self, label: Label) -> Label`

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_variant_data(&mut self, vdata: VariantData) -> VariantData`

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_generic_param(&mut self, param: GenericParam) -> GenericParam`

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

Important traits for Vec<u8>

impl Write for Vec<u8>

`fn fold_generic_params( &mut self, params: Vec<GenericParam> ) -> Vec<GenericParam>`

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_tts(&mut self, tts: TokenStream) -> TokenStream`

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_opt_bounds(&mut self, b: Option<GenericBounds>) -> Option<GenericBounds>`

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_bounds(&mut self, b: GenericBounds) -> GenericBounds`

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_param_bound(&mut self, tpb: GenericBound) -> GenericBound`

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_vis(&mut self, vis: Visibility) -> Visibility`

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

Implementors

`impl Folder for Marker`
[src]

`fn new_span(&mut self, span: Span) -> Span`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_mac(&mut self, mac: Mac) -> Mac`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_crate(&mut self, c: Crate) -> Crate`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

ⓘImportant traits for Vec<u8>
Important traits for Vec<u8>
`impl Write for Vec<u8>`
`fn fold_meta_items(&mut self, meta_items: Vec<MetaItem>) -> Vec<MetaItem>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_meta_list_item(&mut self, list_item: NestedMetaItem) -> NestedMetaItem`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_meta_item(&mut self, meta_item: MetaItem) -> MetaItem`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_use_tree(&mut self, use_tree: UseTree) -> UseTree`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_foreign_item(&mut self, ni: ForeignItem) -> OneVector<ForeignItem>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_foreign_item_simple(&mut self, ni: ForeignItem) -> ForeignItem`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_item(&mut self, i: P<Item>) -> OneVector<P<Item>>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_item_simple(&mut self, i: Item) -> Item`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_fn_header(&mut self, header: FnHeader) -> FnHeader`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_struct_field(&mut self, sf: StructField) -> StructField`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_item_kind(&mut self, i: ItemKind) -> ItemKind`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_trait_item(&mut self, i: TraitItem) -> OneVector<TraitItem>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_impl_item(&mut self, i: ImplItem) -> OneVector<ImplItem>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_asyncness(&mut self, a: IsAsync) -> IsAsync`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_block(&mut self, b: P<Block>) -> P<Block>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_stmt(&mut self, s: Stmt) -> OneVector<Stmt>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_arm(&mut self, a: Arm) -> Arm`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_guard(&mut self, g: Guard) -> Guard`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_pat(&mut self, p: P<Pat>) -> P<Pat>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_anon_const(&mut self, c: AnonConst) -> AnonConst`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_expr(&mut self, e: P<Expr>) -> P<Expr>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_range_end(&mut self, re: RangeEnd) -> RangeEnd`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_opt_expr(&mut self, e: P<Expr>) -> Option<P<Expr>>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

ⓘImportant traits for Vec<u8>
Important traits for Vec<u8>
`impl Write for Vec<u8>`
`fn fold_exprs(&mut self, es: Vec<P<Expr>>) -> Vec<P<Expr>>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_generic_arg(&mut self, arg: GenericArg) -> GenericArg`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_lifetime(&mut self, l: Lifetime) -> Lifetime`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_ty_binding(&mut self, t: TypeBinding) -> TypeBinding`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_mod(&mut self, m: Mod) -> Mod`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_foreign_mod(&mut self, nm: ForeignMod) -> ForeignMod`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_global_asm(&mut self, ga: P<GlobalAsm>) -> P<GlobalAsm>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_variant(&mut self, v: Variant) -> Variant`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_ident(&mut self, i: Ident) -> Ident`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_usize(&mut self, i: usize) -> usize`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_path(&mut self, p: Path) -> Path`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_qpath(&mut self, qs: Option<QSelf>, p: Path) -> (Option<QSelf>, Path)`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_generic_args(&mut self, p: GenericArgs) -> GenericArgs`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_angle_bracketed_parameter_data( &mut self, p: AngleBracketedArgs ) -> AngleBracketedArgs`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_parenthesized_parameter_data( &mut self, p: ParenthesisedArgs ) -> ParenthesisedArgs`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_local(&mut self, l: P<Local>) -> P<Local>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_macro_def(&mut self, def: MacroDef) -> MacroDef`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_label(&mut self, label: Label) -> Label`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_attribute(&mut self, at: Attribute) -> Option<Attribute>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_arg(&mut self, a: Arg) -> Arg`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_generics(&mut self, generics: Generics) -> Generics`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_trait_ref(&mut self, p: TraitRef) -> TraitRef`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_poly_trait_ref(&mut self, p: PolyTraitRef) -> PolyTraitRef`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_variant_data(&mut self, vdata: VariantData) -> VariantData`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_generic_param(&mut self, param: GenericParam) -> GenericParam`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

ⓘImportant traits for Vec<u8>
Important traits for Vec<u8>
`impl Write for Vec<u8>`
`fn fold_generic_params( &mut self, params: Vec<GenericParam> ) -> Vec<GenericParam>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_tt(&mut self, tt: TokenTree) -> TokenTree`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_tts(&mut self, tts: TokenStream) -> TokenStream`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_token(&mut self, t: Token) -> Token`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_interpolated(&mut self, nt: Nonterminal) -> Nonterminal`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_opt_bounds(&mut self, b: Option<GenericBounds>) -> Option<GenericBounds>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_bounds(&mut self, b: GenericBounds) -> GenericBounds`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_param_bound(&mut self, tpb: GenericBound) -> GenericBound`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_mt(&mut self, mt: MutTy) -> MutTy`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_field(&mut self, field: Field) -> Field`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_where_clause(&mut self, where_clause: WhereClause) -> WhereClause`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_where_predicate( &mut self, where_predicate: WherePredicate ) -> WherePredicate`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_vis(&mut self, vis: Visibility) -> Visibility`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn new_id(&mut self, i: NodeId) -> NodeId`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`impl Folder for EntryPointCleaner`
[src]

`fn fold_item(&mut self, i: P<Item>) -> OneVector<P<Item>>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_mac(&mut self, mac: Mac) -> Mac`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_crate(&mut self, c: Crate) -> Crate`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

ⓘImportant traits for Vec<u8>
Important traits for Vec<u8>
`impl Write for Vec<u8>`
`fn fold_meta_items(&mut self, meta_items: Vec<MetaItem>) -> Vec<MetaItem>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_meta_list_item(&mut self, list_item: NestedMetaItem) -> NestedMetaItem`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_meta_item(&mut self, meta_item: MetaItem) -> MetaItem`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_use_tree(&mut self, use_tree: UseTree) -> UseTree`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_foreign_item(&mut self, ni: ForeignItem) -> OneVector<ForeignItem>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_foreign_item_simple(&mut self, ni: ForeignItem) -> ForeignItem`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_item_simple(&mut self, i: Item) -> Item`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_fn_header(&mut self, header: FnHeader) -> FnHeader`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_struct_field(&mut self, sf: StructField) -> StructField`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_item_kind(&mut self, i: ItemKind) -> ItemKind`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_trait_item(&mut self, i: TraitItem) -> OneVector<TraitItem>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_impl_item(&mut self, i: ImplItem) -> OneVector<ImplItem>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_asyncness(&mut self, a: IsAsync) -> IsAsync`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_block(&mut self, b: P<Block>) -> P<Block>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_stmt(&mut self, s: Stmt) -> OneVector<Stmt>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_arm(&mut self, a: Arm) -> Arm`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_guard(&mut self, g: Guard) -> Guard`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_pat(&mut self, p: P<Pat>) -> P<Pat>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_anon_const(&mut self, c: AnonConst) -> AnonConst`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_expr(&mut self, e: P<Expr>) -> P<Expr>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_range_end(&mut self, re: RangeEnd) -> RangeEnd`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_opt_expr(&mut self, e: P<Expr>) -> Option<P<Expr>>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

ⓘImportant traits for Vec<u8>
Important traits for Vec<u8>
`impl Write for Vec<u8>`
`fn fold_exprs(&mut self, es: Vec<P<Expr>>) -> Vec<P<Expr>>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_generic_arg(&mut self, arg: GenericArg) -> GenericArg`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_lifetime(&mut self, l: Lifetime) -> Lifetime`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_ty_binding(&mut self, t: TypeBinding) -> TypeBinding`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_mod(&mut self, m: Mod) -> Mod`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_foreign_mod(&mut self, nm: ForeignMod) -> ForeignMod`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_global_asm(&mut self, ga: P<GlobalAsm>) -> P<GlobalAsm>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_variant(&mut self, v: Variant) -> Variant`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_ident(&mut self, i: Ident) -> Ident`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_usize(&mut self, i: usize) -> usize`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_path(&mut self, p: Path) -> Path`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_qpath(&mut self, qs: Option<QSelf>, p: Path) -> (Option<QSelf>, Path)`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_generic_args(&mut self, p: GenericArgs) -> GenericArgs`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_angle_bracketed_parameter_data( &mut self, p: AngleBracketedArgs ) -> AngleBracketedArgs`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_parenthesized_parameter_data( &mut self, p: ParenthesisedArgs ) -> ParenthesisedArgs`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_local(&mut self, l: P<Local>) -> P<Local>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_macro_def(&mut self, def: MacroDef) -> MacroDef`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_label(&mut self, label: Label) -> Label`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_attribute(&mut self, at: Attribute) -> Option<Attribute>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_arg(&mut self, a: Arg) -> Arg`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_generics(&mut self, generics: Generics) -> Generics`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_trait_ref(&mut self, p: TraitRef) -> TraitRef`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_poly_trait_ref(&mut self, p: PolyTraitRef) -> PolyTraitRef`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_variant_data(&mut self, vdata: VariantData) -> VariantData`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_generic_param(&mut self, param: GenericParam) -> GenericParam`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

ⓘImportant traits for Vec<u8>
Important traits for Vec<u8>
`impl Write for Vec<u8>`
`fn fold_generic_params( &mut self, params: Vec<GenericParam> ) -> Vec<GenericParam>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_tt(&mut self, tt: TokenTree) -> TokenTree`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_tts(&mut self, tts: TokenStream) -> TokenStream`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_token(&mut self, t: Token) -> Token`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_interpolated(&mut self, nt: Nonterminal) -> Nonterminal`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_opt_bounds(&mut self, b: Option<GenericBounds>) -> Option<GenericBounds>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_bounds(&mut self, b: GenericBounds) -> GenericBounds`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_param_bound(&mut self, tpb: GenericBound) -> GenericBound`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_mt(&mut self, mt: MutTy) -> MutTy`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_field(&mut self, field: Field) -> Field`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_where_clause(&mut self, where_clause: WhereClause) -> WhereClause`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_where_predicate( &mut self, where_predicate: WherePredicate ) -> WherePredicate`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_vis(&mut self, vis: Visibility) -> Visibility`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn new_id(&mut self, i: NodeId) -> NodeId`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`impl<'a> Folder for StripUnconfigured<'a>`
[src]

`fn fold_foreign_mod(&mut self, foreign_mod: ForeignMod) -> ForeignMod`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_item_kind(&mut self, item: ItemKind) -> ItemKind`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_expr(&mut self, expr: P<Expr>) -> P<Expr>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_opt_expr(&mut self, expr: P<Expr>) -> Option<P<Expr>>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_stmt(&mut self, stmt: Stmt) -> OneVector<Stmt>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_item(&mut self, item: P<Item>) -> OneVector<P<Item>>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_impl_item(&mut self, item: ImplItem) -> OneVector<ImplItem>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_trait_item(&mut self, item: TraitItem) -> OneVector<TraitItem>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_mac(&mut self, mac: Mac) -> Mac`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_pat(&mut self, pattern: P<Pat>) -> P<Pat>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_crate(&mut self, c: Crate) -> Crate`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

ⓘImportant traits for Vec<u8>
Important traits for Vec<u8>
`impl Write for Vec<u8>`
`fn fold_meta_items(&mut self, meta_items: Vec<MetaItem>) -> Vec<MetaItem>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_meta_list_item(&mut self, list_item: NestedMetaItem) -> NestedMetaItem`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_meta_item(&mut self, meta_item: MetaItem) -> MetaItem`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_use_tree(&mut self, use_tree: UseTree) -> UseTree`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_foreign_item(&mut self, ni: ForeignItem) -> OneVector<ForeignItem>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_foreign_item_simple(&mut self, ni: ForeignItem) -> ForeignItem`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_item_simple(&mut self, i: Item) -> Item`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_fn_header(&mut self, header: FnHeader) -> FnHeader`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_struct_field(&mut self, sf: StructField) -> StructField`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_asyncness(&mut self, a: IsAsync) -> IsAsync`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_block(&mut self, b: P<Block>) -> P<Block>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_arm(&mut self, a: Arm) -> Arm`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_guard(&mut self, g: Guard) -> Guard`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_anon_const(&mut self, c: AnonConst) -> AnonConst`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_range_end(&mut self, re: RangeEnd) -> RangeEnd`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

ⓘImportant traits for Vec<u8>
Important traits for Vec<u8>
`impl Write for Vec<u8>`
`fn fold_exprs(&mut self, es: Vec<P<Expr>>) -> Vec<P<Expr>>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_generic_arg(&mut self, arg: GenericArg) -> GenericArg`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_lifetime(&mut self, l: Lifetime) -> Lifetime`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_ty_binding(&mut self, t: TypeBinding) -> TypeBinding`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_mod(&mut self, m: Mod) -> Mod`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_global_asm(&mut self, ga: P<GlobalAsm>) -> P<GlobalAsm>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_variant(&mut self, v: Variant) -> Variant`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_ident(&mut self, i: Ident) -> Ident`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_usize(&mut self, i: usize) -> usize`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_path(&mut self, p: Path) -> Path`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_qpath(&mut self, qs: Option<QSelf>, p: Path) -> (Option<QSelf>, Path)`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_generic_args(&mut self, p: GenericArgs) -> GenericArgs`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_angle_bracketed_parameter_data( &mut self, p: AngleBracketedArgs ) -> AngleBracketedArgs`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_parenthesized_parameter_data( &mut self, p: ParenthesisedArgs ) -> ParenthesisedArgs`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_local(&mut self, l: P<Local>) -> P<Local>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_macro_def(&mut self, def: MacroDef) -> MacroDef`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_label(&mut self, label: Label) -> Label`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_attribute(&mut self, at: Attribute) -> Option<Attribute>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_arg(&mut self, a: Arg) -> Arg`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_generics(&mut self, generics: Generics) -> Generics`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_trait_ref(&mut self, p: TraitRef) -> TraitRef`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_poly_trait_ref(&mut self, p: PolyTraitRef) -> PolyTraitRef`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_variant_data(&mut self, vdata: VariantData) -> VariantData`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_generic_param(&mut self, param: GenericParam) -> GenericParam`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

ⓘImportant traits for Vec<u8>
Important traits for Vec<u8>
`impl Write for Vec<u8>`
`fn fold_generic_params( &mut self, params: Vec<GenericParam> ) -> Vec<GenericParam>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_tt(&mut self, tt: TokenTree) -> TokenTree`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_tts(&mut self, tts: TokenStream) -> TokenStream`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_token(&mut self, t: Token) -> Token`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_interpolated(&mut self, nt: Nonterminal) -> Nonterminal`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_opt_bounds(&mut self, b: Option<GenericBounds>) -> Option<GenericBounds>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_bounds(&mut self, b: GenericBounds) -> GenericBounds`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_param_bound(&mut self, tpb: GenericBound) -> GenericBound`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_mt(&mut self, mt: MutTy) -> MutTy`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_field(&mut self, field: Field) -> Field`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_where_clause(&mut self, where_clause: WhereClause) -> WhereClause`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_where_predicate( &mut self, where_predicate: WherePredicate ) -> WherePredicate`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_vis(&mut self, vis: Visibility) -> Visibility`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn new_id(&mut self, i: NodeId) -> NodeId`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`impl<'a> Folder for TestHarnessGenerator<'a>`
[src]

`fn fold_crate(&mut self, c: Crate) -> Crate`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_item(&mut self, i: P<Item>) -> OneVector<P<Item>>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_mac(&mut self, mac: Mac) -> Mac`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

ⓘImportant traits for Vec<u8>
Important traits for Vec<u8>
`impl Write for Vec<u8>`
`fn fold_meta_items(&mut self, meta_items: Vec<MetaItem>) -> Vec<MetaItem>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_meta_list_item(&mut self, list_item: NestedMetaItem) -> NestedMetaItem`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_meta_item(&mut self, meta_item: MetaItem) -> MetaItem`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_use_tree(&mut self, use_tree: UseTree) -> UseTree`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_foreign_item(&mut self, ni: ForeignItem) -> OneVector<ForeignItem>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_foreign_item_simple(&mut self, ni: ForeignItem) -> ForeignItem`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_item_simple(&mut self, i: Item) -> Item`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_fn_header(&mut self, header: FnHeader) -> FnHeader`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_struct_field(&mut self, sf: StructField) -> StructField`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_item_kind(&mut self, i: ItemKind) -> ItemKind`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_trait_item(&mut self, i: TraitItem) -> OneVector<TraitItem>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_impl_item(&mut self, i: ImplItem) -> OneVector<ImplItem>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_asyncness(&mut self, a: IsAsync) -> IsAsync`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_block(&mut self, b: P<Block>) -> P<Block>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_stmt(&mut self, s: Stmt) -> OneVector<Stmt>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_arm(&mut self, a: Arm) -> Arm`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_guard(&mut self, g: Guard) -> Guard`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_pat(&mut self, p: P<Pat>) -> P<Pat>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_anon_const(&mut self, c: AnonConst) -> AnonConst`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_expr(&mut self, e: P<Expr>) -> P<Expr>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_range_end(&mut self, re: RangeEnd) -> RangeEnd`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_opt_expr(&mut self, e: P<Expr>) -> Option<P<Expr>>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

ⓘImportant traits for Vec<u8>
Important traits for Vec<u8>
`impl Write for Vec<u8>`
`fn fold_exprs(&mut self, es: Vec<P<Expr>>) -> Vec<P<Expr>>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_generic_arg(&mut self, arg: GenericArg) -> GenericArg`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_lifetime(&mut self, l: Lifetime) -> Lifetime`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_ty_binding(&mut self, t: TypeBinding) -> TypeBinding`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_mod(&mut self, m: Mod) -> Mod`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_foreign_mod(&mut self, nm: ForeignMod) -> ForeignMod`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_global_asm(&mut self, ga: P<GlobalAsm>) -> P<GlobalAsm>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_variant(&mut self, v: Variant) -> Variant`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_ident(&mut self, i: Ident) -> Ident`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_usize(&mut self, i: usize) -> usize`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_path(&mut self, p: Path) -> Path`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_qpath(&mut self, qs: Option<QSelf>, p: Path) -> (Option<QSelf>, Path)`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_generic_args(&mut self, p: GenericArgs) -> GenericArgs`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_angle_bracketed_parameter_data( &mut self, p: AngleBracketedArgs ) -> AngleBracketedArgs`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_parenthesized_parameter_data( &mut self, p: ParenthesisedArgs ) -> ParenthesisedArgs`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_local(&mut self, l: P<Local>) -> P<Local>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_macro_def(&mut self, def: MacroDef) -> MacroDef`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_label(&mut self, label: Label) -> Label`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_attribute(&mut self, at: Attribute) -> Option<Attribute>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_arg(&mut self, a: Arg) -> Arg`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_generics(&mut self, generics: Generics) -> Generics`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_trait_ref(&mut self, p: TraitRef) -> TraitRef`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_poly_trait_ref(&mut self, p: PolyTraitRef) -> PolyTraitRef`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_variant_data(&mut self, vdata: VariantData) -> VariantData`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_generic_param(&mut self, param: GenericParam) -> GenericParam`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

ⓘImportant traits for Vec<u8>
Important traits for Vec<u8>
`impl Write for Vec<u8>`
`fn fold_generic_params( &mut self, params: Vec<GenericParam> ) -> Vec<GenericParam>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_tt(&mut self, tt: TokenTree) -> TokenTree`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_tts(&mut self, tts: TokenStream) -> TokenStream`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_token(&mut self, t: Token) -> Token`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_interpolated(&mut self, nt: Nonterminal) -> Nonterminal`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_opt_bounds(&mut self, b: Option<GenericBounds>) -> Option<GenericBounds>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_bounds(&mut self, b: GenericBounds) -> GenericBounds`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_param_bound(&mut self, tpb: GenericBound) -> GenericBound`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_mt(&mut self, mt: MutTy) -> MutTy`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_field(&mut self, field: Field) -> Field`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_where_clause(&mut self, where_clause: WhereClause) -> WhereClause`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_where_predicate( &mut self, where_predicate: WherePredicate ) -> WherePredicate`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_vis(&mut self, vis: Visibility) -> Visibility`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn new_id(&mut self, i: NodeId) -> NodeId`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`impl<'a, 'b> Folder for InvocationCollector<'a, 'b>`
[src]

`fn fold_expr(&mut self, expr: P<Expr>) -> P<Expr>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_opt_expr(&mut self, expr: P<Expr>) -> Option<P<Expr>>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_pat(&mut self, pat: P<Pat>) -> P<Pat>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_stmt(&mut self, stmt: Stmt) -> OneVector<Stmt>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_block(&mut self, block: P<Block>) -> P<Block>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_item(&mut self, item: P<Item>) -> OneVector<P<Item>>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_trait_item(&mut self, item: TraitItem) -> OneVector<TraitItem>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_impl_item(&mut self, item: ImplItem) -> OneVector<ImplItem>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_ty(&mut self, ty: P<Ty>) -> P<Ty>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_foreign_mod(&mut self, foreign_mod: ForeignMod) -> ForeignMod`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_foreign_item( &mut self, foreign_item: ForeignItem ) -> OneVector<ForeignItem>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_item_kind(&mut self, item: ItemKind) -> ItemKind`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_generic_param(&mut self, param: GenericParam) -> GenericParam`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_attribute(&mut self, at: Attribute) -> Option<Attribute>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn new_id(&mut self, id: NodeId) -> NodeId`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_crate(&mut self, c: Crate) -> Crate`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

ⓘImportant traits for Vec<u8>
Important traits for Vec<u8>
`impl Write for Vec<u8>`
`fn fold_meta_items(&mut self, meta_items: Vec<MetaItem>) -> Vec<MetaItem>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_meta_list_item(&mut self, list_item: NestedMetaItem) -> NestedMetaItem`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_meta_item(&mut self, meta_item: MetaItem) -> MetaItem`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_use_tree(&mut self, use_tree: UseTree) -> UseTree`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_foreign_item_simple(&mut self, ni: ForeignItem) -> ForeignItem`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_item_simple(&mut self, i: Item) -> Item`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_fn_header(&mut self, header: FnHeader) -> FnHeader`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_struct_field(&mut self, sf: StructField) -> StructField`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_asyncness(&mut self, a: IsAsync) -> IsAsync`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_arm(&mut self, a: Arm) -> Arm`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_guard(&mut self, g: Guard) -> Guard`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_anon_const(&mut self, c: AnonConst) -> AnonConst`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_range_end(&mut self, re: RangeEnd) -> RangeEnd`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

ⓘImportant traits for Vec<u8>
Important traits for Vec<u8>
`impl Write for Vec<u8>`
`fn fold_exprs(&mut self, es: Vec<P<Expr>>) -> Vec<P<Expr>>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_generic_arg(&mut self, arg: GenericArg) -> GenericArg`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_lifetime(&mut self, l: Lifetime) -> Lifetime`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_ty_binding(&mut self, t: TypeBinding) -> TypeBinding`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_mod(&mut self, m: Mod) -> Mod`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_global_asm(&mut self, ga: P<GlobalAsm>) -> P<GlobalAsm>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_variant(&mut self, v: Variant) -> Variant`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_ident(&mut self, i: Ident) -> Ident`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_usize(&mut self, i: usize) -> usize`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_path(&mut self, p: Path) -> Path`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_qpath(&mut self, qs: Option<QSelf>, p: Path) -> (Option<QSelf>, Path)`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_generic_args(&mut self, p: GenericArgs) -> GenericArgs`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_angle_bracketed_parameter_data( &mut self, p: AngleBracketedArgs ) -> AngleBracketedArgs`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_parenthesized_parameter_data( &mut self, p: ParenthesisedArgs ) -> ParenthesisedArgs`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_local(&mut self, l: P<Local>) -> P<Local>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_mac(&mut self, _mac: Mac) -> Mac`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_macro_def(&mut self, def: MacroDef) -> MacroDef`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_label(&mut self, label: Label) -> Label`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_arg(&mut self, a: Arg) -> Arg`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_generics(&mut self, generics: Generics) -> Generics`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_trait_ref(&mut self, p: TraitRef) -> TraitRef`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_poly_trait_ref(&mut self, p: PolyTraitRef) -> PolyTraitRef`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_variant_data(&mut self, vdata: VariantData) -> VariantData`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

ⓘImportant traits for Vec<u8>
Important traits for Vec<u8>
`impl Write for Vec<u8>`
`fn fold_generic_params( &mut self, params: Vec<GenericParam> ) -> Vec<GenericParam>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_tt(&mut self, tt: TokenTree) -> TokenTree`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_tts(&mut self, tts: TokenStream) -> TokenStream`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_token(&mut self, t: Token) -> Token`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_interpolated(&mut self, nt: Nonterminal) -> Nonterminal`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_opt_bounds(&mut self, b: Option<GenericBounds>) -> Option<GenericBounds>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_bounds(&mut self, b: GenericBounds) -> GenericBounds`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_param_bound(&mut self, tpb: GenericBound) -> GenericBound`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_mt(&mut self, mt: MutTy) -> MutTy`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_field(&mut self, field: Field) -> Field`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_where_clause(&mut self, where_clause: WhereClause) -> WhereClause`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_where_predicate( &mut self, where_predicate: WherePredicate ) -> WherePredicate`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_vis(&mut self, vis: Visibility) -> Visibility`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`impl<'a, 'b> Folder for MacroExpander<'a, 'b>`
[src]

`fn fold_opt_expr(&mut self, expr: P<Expr>) -> Option<P<Expr>>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_expr(&mut self, ast: P<Expr>) -> P<Expr>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_pat(&mut self, ast: P<Pat>) -> P<Pat>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_ty(&mut self, ast: P<Ty>) -> P<Ty>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_stmt( &mut self, ast_elt: <OneVector<Stmt> as IntoIterator>::Item ) -> OneVector<Stmt>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_item( &mut self, ast_elt: <OneVector<P<Item>> as IntoIterator>::Item ) -> OneVector<P<Item>>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_trait_item( &mut self, ast_elt: <OneVector<TraitItem> as IntoIterator>::Item ) -> OneVector<TraitItem>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_impl_item( &mut self, ast_elt: <OneVector<ImplItem> as IntoIterator>::Item ) -> OneVector<ImplItem>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_foreign_item( &mut self, ast_elt: <OneVector<ForeignItem> as IntoIterator>::Item ) -> OneVector<ForeignItem>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_crate(&mut self, c: Crate) -> Crate`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

ⓘImportant traits for Vec<u8>
Important traits for Vec<u8>
`impl Write for Vec<u8>`
`fn fold_meta_items(&mut self, meta_items: Vec<MetaItem>) -> Vec<MetaItem>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_meta_list_item(&mut self, list_item: NestedMetaItem) -> NestedMetaItem`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_meta_item(&mut self, meta_item: MetaItem) -> MetaItem`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_use_tree(&mut self, use_tree: UseTree) -> UseTree`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_foreign_item_simple(&mut self, ni: ForeignItem) -> ForeignItem`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_item_simple(&mut self, i: Item) -> Item`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_fn_header(&mut self, header: FnHeader) -> FnHeader`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_struct_field(&mut self, sf: StructField) -> StructField`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_item_kind(&mut self, i: ItemKind) -> ItemKind`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_asyncness(&mut self, a: IsAsync) -> IsAsync`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_block(&mut self, b: P<Block>) -> P<Block>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_arm(&mut self, a: Arm) -> Arm`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_guard(&mut self, g: Guard) -> Guard`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_anon_const(&mut self, c: AnonConst) -> AnonConst`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_range_end(&mut self, re: RangeEnd) -> RangeEnd`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

ⓘImportant traits for Vec<u8>
Important traits for Vec<u8>
`impl Write for Vec<u8>`
`fn fold_exprs(&mut self, es: Vec<P<Expr>>) -> Vec<P<Expr>>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_generic_arg(&mut self, arg: GenericArg) -> GenericArg`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_lifetime(&mut self, l: Lifetime) -> Lifetime`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_ty_binding(&mut self, t: TypeBinding) -> TypeBinding`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_mod(&mut self, m: Mod) -> Mod`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_foreign_mod(&mut self, nm: ForeignMod) -> ForeignMod`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_global_asm(&mut self, ga: P<GlobalAsm>) -> P<GlobalAsm>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_variant(&mut self, v: Variant) -> Variant`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_ident(&mut self, i: Ident) -> Ident`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_usize(&mut self, i: usize) -> usize`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_path(&mut self, p: Path) -> Path`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_qpath(&mut self, qs: Option<QSelf>, p: Path) -> (Option<QSelf>, Path)`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_generic_args(&mut self, p: GenericArgs) -> GenericArgs`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_angle_bracketed_parameter_data( &mut self, p: AngleBracketedArgs ) -> AngleBracketedArgs`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_parenthesized_parameter_data( &mut self, p: ParenthesisedArgs ) -> ParenthesisedArgs`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_local(&mut self, l: P<Local>) -> P<Local>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_mac(&mut self, _mac: Mac) -> Mac`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_macro_def(&mut self, def: MacroDef) -> MacroDef`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_label(&mut self, label: Label) -> Label`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_attribute(&mut self, at: Attribute) -> Option<Attribute>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_arg(&mut self, a: Arg) -> Arg`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_generics(&mut self, generics: Generics) -> Generics`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_trait_ref(&mut self, p: TraitRef) -> TraitRef`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_poly_trait_ref(&mut self, p: PolyTraitRef) -> PolyTraitRef`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_variant_data(&mut self, vdata: VariantData) -> VariantData`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_generic_param(&mut self, param: GenericParam) -> GenericParam`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

ⓘImportant traits for Vec<u8>
Important traits for Vec<u8>
`impl Write for Vec<u8>`
`fn fold_generic_params( &mut self, params: Vec<GenericParam> ) -> Vec<GenericParam>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_tt(&mut self, tt: TokenTree) -> TokenTree`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_tts(&mut self, tts: TokenStream) -> TokenStream`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_token(&mut self, t: Token) -> Token`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_interpolated(&mut self, nt: Nonterminal) -> Nonterminal`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_opt_bounds(&mut self, b: Option<GenericBounds>) -> Option<GenericBounds>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_bounds(&mut self, b: GenericBounds) -> GenericBounds`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_param_bound(&mut self, tpb: GenericBound) -> GenericBound`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_mt(&mut self, mt: MutTy) -> MutTy`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_field(&mut self, field: Field) -> Field`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_where_clause(&mut self, where_clause: WhereClause) -> WhereClause`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_where_predicate( &mut self, where_predicate: WherePredicate ) -> WherePredicate`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_vis(&mut self, vis: Visibility) -> Visibility`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn new_id(&mut self, i: NodeId) -> NodeId`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`impl<'a, 'b> Folder for PlaceholderExpander<'a, 'b>`
[src]

`fn fold_item(&mut self, item: P<Item>) -> OneVector<P<Item>>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_trait_item(&mut self, item: TraitItem) -> OneVector<TraitItem>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_impl_item(&mut self, item: ImplItem) -> OneVector<ImplItem>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_foreign_item(&mut self, item: ForeignItem) -> OneVector<ForeignItem>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_expr(&mut self, expr: P<Expr>) -> P<Expr>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_opt_expr(&mut self, expr: P<Expr>) -> Option<P<Expr>>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_stmt(&mut self, stmt: Stmt) -> OneVector<Stmt>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_pat(&mut self, pat: P<Pat>) -> P<Pat>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_ty(&mut self, ty: P<Ty>) -> P<Ty>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_block(&mut self, block: P<Block>) -> P<Block>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_mod(&mut self, module: Mod) -> Mod`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_mac(&mut self, mac: Mac) -> Mac`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_crate(&mut self, c: Crate) -> Crate`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

ⓘImportant traits for Vec<u8>
Important traits for Vec<u8>
`impl Write for Vec<u8>`
`fn fold_meta_items(&mut self, meta_items: Vec<MetaItem>) -> Vec<MetaItem>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_meta_list_item(&mut self, list_item: NestedMetaItem) -> NestedMetaItem`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_meta_item(&mut self, meta_item: MetaItem) -> MetaItem`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_use_tree(&mut self, use_tree: UseTree) -> UseTree`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_foreign_item_simple(&mut self, ni: ForeignItem) -> ForeignItem`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_item_simple(&mut self, i: Item) -> Item`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_fn_header(&mut self, header: FnHeader) -> FnHeader`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_struct_field(&mut self, sf: StructField) -> StructField`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_item_kind(&mut self, i: ItemKind) -> ItemKind`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_asyncness(&mut self, a: IsAsync) -> IsAsync`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_arm(&mut self, a: Arm) -> Arm`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_guard(&mut self, g: Guard) -> Guard`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_anon_const(&mut self, c: AnonConst) -> AnonConst`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_range_end(&mut self, re: RangeEnd) -> RangeEnd`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

ⓘImportant traits for Vec<u8>
Important traits for Vec<u8>
`impl Write for Vec<u8>`
`fn fold_exprs(&mut self, es: Vec<P<Expr>>) -> Vec<P<Expr>>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_generic_arg(&mut self, arg: GenericArg) -> GenericArg`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_lifetime(&mut self, l: Lifetime) -> Lifetime`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_ty_binding(&mut self, t: TypeBinding) -> TypeBinding`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_foreign_mod(&mut self, nm: ForeignMod) -> ForeignMod`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_global_asm(&mut self, ga: P<GlobalAsm>) -> P<GlobalAsm>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_variant(&mut self, v: Variant) -> Variant`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_ident(&mut self, i: Ident) -> Ident`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_usize(&mut self, i: usize) -> usize`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_path(&mut self, p: Path) -> Path`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_qpath(&mut self, qs: Option<QSelf>, p: Path) -> (Option<QSelf>, Path)`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_generic_args(&mut self, p: GenericArgs) -> GenericArgs`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_angle_bracketed_parameter_data( &mut self, p: AngleBracketedArgs ) -> AngleBracketedArgs`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_parenthesized_parameter_data( &mut self, p: ParenthesisedArgs ) -> ParenthesisedArgs`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_local(&mut self, l: P<Local>) -> P<Local>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_macro_def(&mut self, def: MacroDef) -> MacroDef`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_label(&mut self, label: Label) -> Label`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_attribute(&mut self, at: Attribute) -> Option<Attribute>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_arg(&mut self, a: Arg) -> Arg`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_generics(&mut self, generics: Generics) -> Generics`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_trait_ref(&mut self, p: TraitRef) -> TraitRef`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_poly_trait_ref(&mut self, p: PolyTraitRef) -> PolyTraitRef`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_variant_data(&mut self, vdata: VariantData) -> VariantData`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_generic_param(&mut self, param: GenericParam) -> GenericParam`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

ⓘImportant traits for Vec<u8>
Important traits for Vec<u8>
`impl Write for Vec<u8>`
`fn fold_generic_params( &mut self, params: Vec<GenericParam> ) -> Vec<GenericParam>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_tt(&mut self, tt: TokenTree) -> TokenTree`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_tts(&mut self, tts: TokenStream) -> TokenStream`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_token(&mut self, t: Token) -> Token`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_interpolated(&mut self, nt: Nonterminal) -> Nonterminal`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_opt_bounds(&mut self, b: Option<GenericBounds>) -> Option<GenericBounds>`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_bounds(&mut self, b: GenericBounds) -> GenericBounds`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_param_bound(&mut self, tpb: GenericBound) -> GenericBound`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_mt(&mut self, mt: MutTy) -> MutTy`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_field(&mut self, field: Field) -> Field`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_where_clause(&mut self, where_clause: WhereClause) -> WhereClause`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_where_predicate( &mut self, where_predicate: WherePredicate ) -> WherePredicate`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn fold_vis(&mut self, vis: Visibility) -> Visibility`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

`fn new_id(&mut self, i: NodeId) -> NodeId`
[src]

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

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

🔬 This is a nightly-only experimental API. (rustc_private)

this crate is being loaded from the sysroot, an unstable location; did you mean to load this crate from crates.io via Cargo.toml instead?

[−][src]Trait syntax::fold::Folder

Provided Methods

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

Important traits for Vec<u8>

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

fn fold_meta_list_item(&mut self, list_item: NestedMetaItem) -> NestedMetaItem

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

fn fold_use_tree(&mut self, use_tree: UseTree) -> UseTree

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

fn fold_foreign_item_simple(&mut self, ni: ForeignItem) -> ForeignItem

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

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

fn fold_fn_header(&mut self, header: FnHeader) -> FnHeader

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

fn fold_item_kind(&mut self, i: ItemKind) -> ItemKind

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

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

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

fn fold_asyncness(&mut self, a: IsAsync) -> IsAsync

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

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

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

fn fold_guard(&mut self, g: Guard) -> Guard

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

fn fold_anon_const(&mut self, c: AnonConst) -> AnonConst

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

fn fold_range_end(&mut self, re: RangeEnd) -> RangeEnd

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

Important traits for Vec<u8>

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

fn fold_generic_arg(&mut self, arg: GenericArg) -> GenericArg

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

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

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

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

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

fn fold_global_asm(&mut self, ga: P<GlobalAsm>) -> P<GlobalAsm>

fn fold_variant(&mut self, v: Variant) -> 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_qpath(&mut self, qs: Option<QSelf>, p: Path) -> (Option<QSelf>, Path)

fn fold_generic_args(&mut self, p: GenericArgs) -> GenericArgs

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

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

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

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

fn fold_macro_def(&mut self, def: MacroDef) -> MacroDef

fn fold_label(&mut self, label: Label) -> Label

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_generic_param(&mut self, param: GenericParam) -> GenericParam

Important traits for Vec<u8>

fn fold_generic_params( &mut self, params: Vec<GenericParam>) -> Vec<GenericParam>

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

fn fold_tts(&mut self, tts: TokenStream) -> TokenStream

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

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

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

fn fold_bounds(&mut self, b: GenericBounds) -> GenericBounds

fn fold_param_bound(&mut self, tpb: GenericBound) -> GenericBound

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_vis(&mut self, vis: Visibility) -> Visibility

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

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

Implementors

impl Folder for Marker[src]

fn new_span(&mut self, span: Span) -> Span[src]

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

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

ⓘImportant traits for Vec<u8>Important traits for Vec<u8>impl Write for Vec<u8>fn fold_meta_items(&mut self, meta_items: Vec<MetaItem>) -> Vec<MetaItem>[src]

Important traits for Vec<u8>

fn fold_meta_list_item(&mut self, list_item: NestedMetaItem) -> NestedMetaItem[src]

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

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

`fn fold_meta_list_item(&mut self, list_item: NestedMetaItem) -> NestedMetaItem`

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

`fn fold_use_tree(&mut self, use_tree: UseTree) -> UseTree`

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

`fn fold_foreign_item_simple(&mut self, ni: ForeignItem) -> ForeignItem`

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

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

`fn fold_fn_header(&mut self, header: FnHeader) -> FnHeader`

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

`fn fold_item_kind(&mut self, i: ItemKind) -> ItemKind`

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

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

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

`fn fold_asyncness(&mut self, a: IsAsync) -> IsAsync`

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

`fn fold_stmt(&mut self, s: Stmt) -> OneVector<Stmt>`

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

`fn fold_guard(&mut self, g: Guard) -> Guard`

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

`fn fold_anon_const(&mut self, c: AnonConst) -> AnonConst`

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

`fn fold_range_end(&mut self, re: RangeEnd) -> RangeEnd`

`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_generic_arg(&mut self, arg: GenericArg) -> GenericArg`

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

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

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

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

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

`fn fold_global_asm(&mut self, ga: P<GlobalAsm>) -> P<GlobalAsm>`

`fn fold_variant(&mut self, v: Variant) -> 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_qpath(&mut self, qs: Option<QSelf>, p: Path) -> (Option<QSelf>, Path)`

`fn fold_generic_args(&mut self, p: GenericArgs) -> GenericArgs`

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

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

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

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

`fn fold_macro_def(&mut self, def: MacroDef) -> MacroDef`

`fn fold_label(&mut self, label: Label) -> Label`

`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_generic_param(&mut self, param: GenericParam) -> GenericParam`

`fn fold_generic_params( &mut self, params: Vec<GenericParam> ) -> Vec<GenericParam>`

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

`fn fold_tts(&mut self, tts: TokenStream) -> TokenStream`

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

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

`fn fold_opt_bounds(&mut self, b: Option<GenericBounds>) -> Option<GenericBounds>`

`fn fold_bounds(&mut self, b: GenericBounds) -> GenericBounds`

`fn fold_param_bound(&mut self, tpb: GenericBound) -> GenericBound`

`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_vis(&mut self, vis: Visibility) -> Visibility`

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

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

`impl Folder for Marker`
[src]

`fn new_span(&mut self, span: Span) -> Span`
[src]

`fn fold_mac(&mut self, mac: Mac) -> Mac`
[src]

`fn fold_crate(&mut self, c: Crate) -> Crate`
[src]

ⓘImportant traits for Vec<u8>
Important traits for Vec<u8>
`impl Write for Vec<u8>`
`fn fold_meta_items(&mut self, meta_items: Vec<MetaItem>) -> Vec<MetaItem>`
[src]

`fn fold_meta_list_item(&mut self, list_item: NestedMetaItem) -> NestedMetaItem`
[src]

`fn fold_meta_item(&mut self, meta_item: MetaItem) -> MetaItem`
[src]

`fn fold_use_tree(&mut self, use_tree: UseTree) -> UseTree`
[src]

`fn fold_foreign_item(&mut self, ni: ForeignItem) -> OneVector<ForeignItem>`
[src]

`fn fold_foreign_item_simple(&mut self, ni: ForeignItem) -> ForeignItem`
[src]

`fn fold_item(&mut self, i: P<Item>) -> OneVector<P<Item>>`
[src]

`fn fold_item_simple(&mut self, i: Item) -> Item`
[src]

`fn fold_fn_header(&mut self, header: FnHeader) -> FnHeader`
[src]