Trait syn::fold::Fold[−][src]

pub trait Fold {

Show 187 methods    fn fold_abi(&mut self, i: Abi) -> Abi { ... }

    fn fold_angle_bracketed_generic_arguments(
        &mut self, 
        i: AngleBracketedGenericArguments
    ) -> AngleBracketedGenericArguments { ... }

    fn fold_arm(&mut self, i: Arm) -> Arm { ... }

    fn fold_attr_style(&mut self, i: AttrStyle) -> AttrStyle { ... }

    fn fold_attribute(&mut self, i: Attribute) -> Attribute { ... }

    fn fold_bare_fn_arg(&mut self, i: BareFnArg) -> BareFnArg { ... }

    fn fold_bin_op(&mut self, i: BinOp) -> BinOp { ... }

    fn fold_binding(&mut self, i: Binding) -> Binding { ... }

    fn fold_block(&mut self, i: Block) -> Block { ... }

    fn fold_bound_lifetimes(&mut self, i: BoundLifetimes) -> BoundLifetimes { ... }

    fn fold_const_param(&mut self, i: ConstParam) -> ConstParam { ... }

    fn fold_constraint(&mut self, i: Constraint) -> Constraint { ... }

    fn fold_data(&mut self, i: Data) -> Data { ... }

    fn fold_data_enum(&mut self, i: DataEnum) -> DataEnum { ... }

    fn fold_data_struct(&mut self, i: DataStruct) -> DataStruct { ... }

    fn fold_data_union(&mut self, i: DataUnion) -> DataUnion { ... }

    fn fold_derive_input(&mut self, i: DeriveInput) -> DeriveInput { ... }

    fn fold_expr(&mut self, i: Expr) -> Expr { ... }

    fn fold_expr_array(&mut self, i: ExprArray) -> ExprArray { ... }

    fn fold_expr_assign(&mut self, i: ExprAssign) -> ExprAssign { ... }

    fn fold_expr_assign_op(&mut self, i: ExprAssignOp) -> ExprAssignOp { ... }

    fn fold_expr_async(&mut self, i: ExprAsync) -> ExprAsync { ... }

    fn fold_expr_await(&mut self, i: ExprAwait) -> ExprAwait { ... }

    fn fold_expr_binary(&mut self, i: ExprBinary) -> ExprBinary { ... }

    fn fold_expr_block(&mut self, i: ExprBlock) -> ExprBlock { ... }

    fn fold_expr_box(&mut self, i: ExprBox) -> ExprBox { ... }

    fn fold_expr_break(&mut self, i: ExprBreak) -> ExprBreak { ... }

    fn fold_expr_call(&mut self, i: ExprCall) -> ExprCall { ... }

    fn fold_expr_cast(&mut self, i: ExprCast) -> ExprCast { ... }

    fn fold_expr_closure(&mut self, i: ExprClosure) -> ExprClosure { ... }

    fn fold_expr_continue(&mut self, i: ExprContinue) -> ExprContinue { ... }

    fn fold_expr_field(&mut self, i: ExprField) -> ExprField { ... }

    fn fold_expr_for_loop(&mut self, i: ExprForLoop) -> ExprForLoop { ... }

    fn fold_expr_group(&mut self, i: ExprGroup) -> ExprGroup { ... }

    fn fold_expr_if(&mut self, i: ExprIf) -> ExprIf { ... }

    fn fold_expr_index(&mut self, i: ExprIndex) -> ExprIndex { ... }

    fn fold_expr_let(&mut self, i: ExprLet) -> ExprLet { ... }

    fn fold_expr_lit(&mut self, i: ExprLit) -> ExprLit { ... }

    fn fold_expr_loop(&mut self, i: ExprLoop) -> ExprLoop { ... }

    fn fold_expr_macro(&mut self, i: ExprMacro) -> ExprMacro { ... }

    fn fold_expr_match(&mut self, i: ExprMatch) -> ExprMatch { ... }

    fn fold_expr_method_call(&mut self, i: ExprMethodCall) -> ExprMethodCall { ... }

    fn fold_expr_paren(&mut self, i: ExprParen) -> ExprParen { ... }

    fn fold_expr_path(&mut self, i: ExprPath) -> ExprPath { ... }

    fn fold_expr_range(&mut self, i: ExprRange) -> ExprRange { ... }

    fn fold_expr_reference(&mut self, i: ExprReference) -> ExprReference { ... }

    fn fold_expr_repeat(&mut self, i: ExprRepeat) -> ExprRepeat { ... }

    fn fold_expr_return(&mut self, i: ExprReturn) -> ExprReturn { ... }

    fn fold_expr_struct(&mut self, i: ExprStruct) -> ExprStruct { ... }

    fn fold_expr_try(&mut self, i: ExprTry) -> ExprTry { ... }

    fn fold_expr_try_block(&mut self, i: ExprTryBlock) -> ExprTryBlock { ... }

    fn fold_expr_tuple(&mut self, i: ExprTuple) -> ExprTuple { ... }

    fn fold_expr_type(&mut self, i: ExprType) -> ExprType { ... }

    fn fold_expr_unary(&mut self, i: ExprUnary) -> ExprUnary { ... }

    fn fold_expr_unsafe(&mut self, i: ExprUnsafe) -> ExprUnsafe { ... }

    fn fold_expr_while(&mut self, i: ExprWhile) -> ExprWhile { ... }

    fn fold_expr_yield(&mut self, i: ExprYield) -> ExprYield { ... }

    fn fold_field(&mut self, i: Field) -> Field { ... }

    fn fold_field_pat(&mut self, i: FieldPat) -> FieldPat { ... }

    fn fold_field_value(&mut self, i: FieldValue) -> FieldValue { ... }

    fn fold_fields(&mut self, i: Fields) -> Fields { ... }

    fn fold_fields_named(&mut self, i: FieldsNamed) -> FieldsNamed { ... }

    fn fold_fields_unnamed(&mut self, i: FieldsUnnamed) -> FieldsUnnamed { ... }

    fn fold_file(&mut self, i: File) -> File { ... }

    fn fold_fn_arg(&mut self, i: FnArg) -> FnArg { ... }

    fn fold_foreign_item(&mut self, i: ForeignItem) -> ForeignItem { ... }

    fn fold_foreign_item_fn(&mut self, i: ForeignItemFn) -> ForeignItemFn { ... }

    fn fold_foreign_item_macro(
        &mut self, 
        i: ForeignItemMacro
    ) -> ForeignItemMacro { ... }

    fn fold_foreign_item_static(
        &mut self, 
        i: ForeignItemStatic
    ) -> ForeignItemStatic { ... }

    fn fold_foreign_item_type(&mut self, i: ForeignItemType) -> ForeignItemType { ... }

    fn fold_generic_argument(&mut self, i: GenericArgument) -> GenericArgument { ... }

    fn fold_generic_method_argument(
        &mut self, 
        i: GenericMethodArgument
    ) -> GenericMethodArgument { ... }

    fn fold_generic_param(&mut self, i: GenericParam) -> GenericParam { ... }

    fn fold_generics(&mut self, i: Generics) -> Generics { ... }

    fn fold_ident(&mut self, i: Ident) -> Ident { ... }

    fn fold_impl_item(&mut self, i: ImplItem) -> ImplItem { ... }

    fn fold_impl_item_const(&mut self, i: ImplItemConst) -> ImplItemConst { ... }

    fn fold_impl_item_macro(&mut self, i: ImplItemMacro) -> ImplItemMacro { ... }

    fn fold_impl_item_method(&mut self, i: ImplItemMethod) -> ImplItemMethod { ... }

    fn fold_impl_item_type(&mut self, i: ImplItemType) -> ImplItemType { ... }

    fn fold_index(&mut self, i: Index) -> Index { ... }

    fn fold_item(&mut self, i: Item) -> Item { ... }

    fn fold_item_const(&mut self, i: ItemConst) -> ItemConst { ... }

    fn fold_item_enum(&mut self, i: ItemEnum) -> ItemEnum { ... }

    fn fold_item_extern_crate(&mut self, i: ItemExternCrate) -> ItemExternCrate { ... }

    fn fold_item_fn(&mut self, i: ItemFn) -> ItemFn { ... }

    fn fold_item_foreign_mod(&mut self, i: ItemForeignMod) -> ItemForeignMod { ... }

    fn fold_item_impl(&mut self, i: ItemImpl) -> ItemImpl { ... }

    fn fold_item_macro(&mut self, i: ItemMacro) -> ItemMacro { ... }

    fn fold_item_macro2(&mut self, i: ItemMacro2) -> ItemMacro2 { ... }

    fn fold_item_mod(&mut self, i: ItemMod) -> ItemMod { ... }

    fn fold_item_static(&mut self, i: ItemStatic) -> ItemStatic { ... }

    fn fold_item_struct(&mut self, i: ItemStruct) -> ItemStruct { ... }

    fn fold_item_trait(&mut self, i: ItemTrait) -> ItemTrait { ... }

    fn fold_item_trait_alias(&mut self, i: ItemTraitAlias) -> ItemTraitAlias { ... }

    fn fold_item_type(&mut self, i: ItemType) -> ItemType { ... }

    fn fold_item_union(&mut self, i: ItemUnion) -> ItemUnion { ... }

    fn fold_item_use(&mut self, i: ItemUse) -> ItemUse { ... }

    fn fold_label(&mut self, i: Label) -> Label { ... }

    fn fold_lifetime(&mut self, i: Lifetime) -> Lifetime { ... }

    fn fold_lifetime_def(&mut self, i: LifetimeDef) -> LifetimeDef { ... }

    fn fold_lit(&mut self, i: Lit) -> Lit { ... }

    fn fold_lit_bool(&mut self, i: LitBool) -> LitBool { ... }

    fn fold_lit_byte(&mut self, i: LitByte) -> LitByte { ... }

    fn fold_lit_byte_str(&mut self, i: LitByteStr) -> LitByteStr { ... }

    fn fold_lit_char(&mut self, i: LitChar) -> LitChar { ... }

    fn fold_lit_float(&mut self, i: LitFloat) -> LitFloat { ... }

    fn fold_lit_int(&mut self, i: LitInt) -> LitInt { ... }

    fn fold_lit_str(&mut self, i: LitStr) -> LitStr { ... }

    fn fold_local(&mut self, i: Local) -> Local { ... }

    fn fold_macro(&mut self, i: Macro) -> Macro { ... }

    fn fold_macro_delimiter(&mut self, i: MacroDelimiter) -> MacroDelimiter { ... }

    fn fold_member(&mut self, i: Member) -> Member { ... }

    fn fold_meta(&mut self, i: Meta) -> Meta { ... }

    fn fold_meta_list(&mut self, i: MetaList) -> MetaList { ... }

    fn fold_meta_name_value(&mut self, i: MetaNameValue) -> MetaNameValue { ... }

    fn fold_method_turbofish(&mut self, i: MethodTurbofish) -> MethodTurbofish { ... }

    fn fold_nested_meta(&mut self, i: NestedMeta) -> NestedMeta { ... }

    fn fold_parenthesized_generic_arguments(
        &mut self, 
        i: ParenthesizedGenericArguments
    ) -> ParenthesizedGenericArguments { ... }

    fn fold_pat(&mut self, i: Pat) -> Pat { ... }

    fn fold_pat_box(&mut self, i: PatBox) -> PatBox { ... }

    fn fold_pat_ident(&mut self, i: PatIdent) -> PatIdent { ... }

    fn fold_pat_lit(&mut self, i: PatLit) -> PatLit { ... }

    fn fold_pat_macro(&mut self, i: PatMacro) -> PatMacro { ... }

    fn fold_pat_or(&mut self, i: PatOr) -> PatOr { ... }

    fn fold_pat_path(&mut self, i: PatPath) -> PatPath { ... }

    fn fold_pat_range(&mut self, i: PatRange) -> PatRange { ... }

    fn fold_pat_reference(&mut self, i: PatReference) -> PatReference { ... }

    fn fold_pat_rest(&mut self, i: PatRest) -> PatRest { ... }

    fn fold_pat_slice(&mut self, i: PatSlice) -> PatSlice { ... }

    fn fold_pat_struct(&mut self, i: PatStruct) -> PatStruct { ... }

    fn fold_pat_tuple(&mut self, i: PatTuple) -> PatTuple { ... }

    fn fold_pat_tuple_struct(&mut self, i: PatTupleStruct) -> PatTupleStruct { ... }

    fn fold_pat_type(&mut self, i: PatType) -> PatType { ... }

    fn fold_pat_wild(&mut self, i: PatWild) -> PatWild { ... }

    fn fold_path(&mut self, i: Path) -> Path { ... }

    fn fold_path_arguments(&mut self, i: PathArguments) -> PathArguments { ... }

    fn fold_path_segment(&mut self, i: PathSegment) -> PathSegment { ... }

    fn fold_predicate_eq(&mut self, i: PredicateEq) -> PredicateEq { ... }

    fn fold_predicate_lifetime(
        &mut self, 
        i: PredicateLifetime
    ) -> PredicateLifetime { ... }

    fn fold_predicate_type(&mut self, i: PredicateType) -> PredicateType { ... }

    fn fold_qself(&mut self, i: QSelf) -> QSelf { ... }

    fn fold_range_limits(&mut self, i: RangeLimits) -> RangeLimits { ... }

    fn fold_receiver(&mut self, i: Receiver) -> Receiver { ... }

    fn fold_return_type(&mut self, i: ReturnType) -> ReturnType { ... }

    fn fold_signature(&mut self, i: Signature) -> Signature { ... }

    fn fold_span(&mut self, i: Span) -> Span { ... }

    fn fold_stmt(&mut self, i: Stmt) -> Stmt { ... }

    fn fold_trait_bound(&mut self, i: TraitBound) -> TraitBound { ... }

    fn fold_trait_bound_modifier(
        &mut self, 
        i: TraitBoundModifier
    ) -> TraitBoundModifier { ... }

    fn fold_trait_item(&mut self, i: TraitItem) -> TraitItem { ... }

    fn fold_trait_item_const(&mut self, i: TraitItemConst) -> TraitItemConst { ... }

    fn fold_trait_item_macro(&mut self, i: TraitItemMacro) -> TraitItemMacro { ... }

    fn fold_trait_item_method(&mut self, i: TraitItemMethod) -> TraitItemMethod { ... }

    fn fold_trait_item_type(&mut self, i: TraitItemType) -> TraitItemType { ... }

    fn fold_type(&mut self, i: Type) -> Type { ... }

    fn fold_type_array(&mut self, i: TypeArray) -> TypeArray { ... }

    fn fold_type_bare_fn(&mut self, i: TypeBareFn) -> TypeBareFn { ... }

    fn fold_type_group(&mut self, i: TypeGroup) -> TypeGroup { ... }

    fn fold_type_impl_trait(&mut self, i: TypeImplTrait) -> TypeImplTrait { ... }

    fn fold_type_infer(&mut self, i: TypeInfer) -> TypeInfer { ... }

    fn fold_type_macro(&mut self, i: TypeMacro) -> TypeMacro { ... }

    fn fold_type_never(&mut self, i: TypeNever) -> TypeNever { ... }

    fn fold_type_param(&mut self, i: TypeParam) -> TypeParam { ... }

    fn fold_type_param_bound(&mut self, i: TypeParamBound) -> TypeParamBound { ... }

    fn fold_type_paren(&mut self, i: TypeParen) -> TypeParen { ... }

    fn fold_type_path(&mut self, i: TypePath) -> TypePath { ... }

    fn fold_type_ptr(&mut self, i: TypePtr) -> TypePtr { ... }

    fn fold_type_reference(&mut self, i: TypeReference) -> TypeReference { ... }

    fn fold_type_slice(&mut self, i: TypeSlice) -> TypeSlice { ... }

    fn fold_type_trait_object(&mut self, i: TypeTraitObject) -> TypeTraitObject { ... }

    fn fold_type_tuple(&mut self, i: TypeTuple) -> TypeTuple { ... }

    fn fold_un_op(&mut self, i: UnOp) -> UnOp { ... }

    fn fold_use_glob(&mut self, i: UseGlob) -> UseGlob { ... }

    fn fold_use_group(&mut self, i: UseGroup) -> UseGroup { ... }

    fn fold_use_name(&mut self, i: UseName) -> UseName { ... }

    fn fold_use_path(&mut self, i: UsePath) -> UsePath { ... }

    fn fold_use_rename(&mut self, i: UseRename) -> UseRename { ... }

    fn fold_use_tree(&mut self, i: UseTree) -> UseTree { ... }

    fn fold_variadic(&mut self, i: Variadic) -> Variadic { ... }

    fn fold_variant(&mut self, i: Variant) -> Variant { ... }

    fn fold_vis_crate(&mut self, i: VisCrate) -> VisCrate { ... }

    fn fold_vis_public(&mut self, i: VisPublic) -> VisPublic { ... }

    fn fold_vis_restricted(&mut self, i: VisRestricted) -> VisRestricted { ... }

    fn fold_visibility(&mut self, i: Visibility) -> Visibility { ... }

    fn fold_where_clause(&mut self, i: WhereClause) -> WhereClause { ... }

    fn fold_where_predicate(&mut self, i: WherePredicate) -> WherePredicate { ... }

}
This is supported on crate feature fold only.
Expand description

Syntax tree traversal to transform the nodes of an owned syntax tree.

See the module documentation for details.

This trait is available only if Syn is built with the "fold" feature.

Provided methods

Implementors