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.