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 { ... }
}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.