pub trait Fold {
Show 197 methods
fn fold_abi(&mut self, i: Abi) -> Abi { ... }
fn fold_angle_bracketed_generic_arguments(
&mut self,
i: AngleBracketedGenericArguments
) -> AngleBracketedGenericArguments { ... }
fn fold_arg_captured(&mut self, i: ArgCaptured) -> ArgCaptured { ... }
fn fold_arg_self(&mut self, i: ArgSelf) -> ArgSelf { ... }
fn fold_arg_self_ref(&mut self, i: ArgSelfRef) -> ArgSelfRef { ... }
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_bare_fn_arg_name(&mut self, i: BareFnArgName) -> BareFnArgName { ... }
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_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_in_place(&mut self, i: ExprInPlace) -> ExprInPlace { ... }
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_verbatim(&mut self, i: ExprVerbatim) -> ExprVerbatim { ... }
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_fn_decl(&mut self, i: FnDecl) -> FnDecl { ... }
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_foreign_item_verbatim(
&mut self,
i: ForeignItemVerbatim
) -> ForeignItemVerbatim { ... }
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_existential(
&mut self,
i: ImplItemExistential
) -> ImplItemExistential { ... }
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_impl_item_verbatim(
&mut self,
i: ImplItemVerbatim
) -> ImplItemVerbatim { ... }
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_existential(&mut self, i: ItemExistential) -> ItemExistential { ... }
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_item_verbatim(&mut self, i: ItemVerbatim) -> ItemVerbatim { ... }
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_lit_verbatim(&mut self, i: LitVerbatim) -> LitVerbatim { ... }
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_sig(&mut self, i: MethodSig) -> MethodSig { ... }
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_path(&mut self, i: PatPath) -> PatPath { ... }
fn fold_pat_range(&mut self, i: PatRange) -> PatRange { ... }
fn fold_pat_ref(&mut self, i: PatRef) -> PatRef { ... }
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_verbatim(&mut self, i: PatVerbatim) -> PatVerbatim { ... }
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_return_type(&mut self, i: ReturnType) -> ReturnType { ... }
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_trait_item_verbatim(
&mut self,
i: TraitItemVerbatim
) -> TraitItemVerbatim { ... }
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_type_verbatim(&mut self, i: TypeVerbatim) -> TypeVerbatim { ... }
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_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 if Syn is built with the "fold" feature.