1 // This file is @generated by syn-internal-codegen.
2 // It is not intended for manual editing.
3
4 #![allow(unreachable_code, unused_variables)]
5 #[cfg(any(feature = "full", feature = "derive"))]
6 use crate::gen::helper::fold::*;
7 #[cfg(any(feature = "full", feature = "derive"))]
8 use crate::token::{Brace, Bracket, Group, Paren};
9 use crate::*;
10 use proc_macro2::Span;
11 #[cfg(feature = "full")]
12 macro_rules! full {
13 ($e:expr) => {
14 $e
15 };
16 }
17 #[cfg(all(feature = "derive", not(feature = "full")))]
18 macro_rules! full {
19 ($e:expr) => {
20 unreachable!()
21 };
22 }
23 /// Syntax tree traversal to transform the nodes of an owned syntax tree.
24 ///
25 /// See the [module documentation] for details.
26 ///
27 /// [module documentation]: self
28 ///
29 /// *This trait is available if Syn is built with the `"fold"` feature.*
30 pub trait Fold {
31 #[cfg(any(feature = "derive", feature = "full"))]
fold_abi(&mut self, i: Abi) -> Abi32 fn fold_abi(&mut self, i: Abi) -> Abi {
33 fold_abi(self, i)
34 }
35 #[cfg(any(feature = "derive", feature = "full"))]
fold_angle_bracketed_generic_arguments( &mut self, i: AngleBracketedGenericArguments, ) -> AngleBracketedGenericArguments36 fn fold_angle_bracketed_generic_arguments(
37 &mut self,
38 i: AngleBracketedGenericArguments,
39 ) -> AngleBracketedGenericArguments {
40 fold_angle_bracketed_generic_arguments(self, i)
41 }
42 #[cfg(feature = "full")]
fold_arm(&mut self, i: Arm) -> Arm43 fn fold_arm(&mut self, i: Arm) -> Arm {
44 fold_arm(self, i)
45 }
46 #[cfg(any(feature = "derive", feature = "full"))]
fold_attr_style(&mut self, i: AttrStyle) -> AttrStyle47 fn fold_attr_style(&mut self, i: AttrStyle) -> AttrStyle {
48 fold_attr_style(self, i)
49 }
50 #[cfg(any(feature = "derive", feature = "full"))]
fold_attribute(&mut self, i: Attribute) -> Attribute51 fn fold_attribute(&mut self, i: Attribute) -> Attribute {
52 fold_attribute(self, i)
53 }
54 #[cfg(any(feature = "derive", feature = "full"))]
fold_bare_fn_arg(&mut self, i: BareFnArg) -> BareFnArg55 fn fold_bare_fn_arg(&mut self, i: BareFnArg) -> BareFnArg {
56 fold_bare_fn_arg(self, i)
57 }
58 #[cfg(any(feature = "derive", feature = "full"))]
fold_bin_op(&mut self, i: BinOp) -> BinOp59 fn fold_bin_op(&mut self, i: BinOp) -> BinOp {
60 fold_bin_op(self, i)
61 }
62 #[cfg(any(feature = "derive", feature = "full"))]
fold_binding(&mut self, i: Binding) -> Binding63 fn fold_binding(&mut self, i: Binding) -> Binding {
64 fold_binding(self, i)
65 }
66 #[cfg(feature = "full")]
fold_block(&mut self, i: Block) -> Block67 fn fold_block(&mut self, i: Block) -> Block {
68 fold_block(self, i)
69 }
70 #[cfg(any(feature = "derive", feature = "full"))]
fold_bound_lifetimes(&mut self, i: BoundLifetimes) -> BoundLifetimes71 fn fold_bound_lifetimes(&mut self, i: BoundLifetimes) -> BoundLifetimes {
72 fold_bound_lifetimes(self, i)
73 }
74 #[cfg(any(feature = "derive", feature = "full"))]
fold_const_param(&mut self, i: ConstParam) -> ConstParam75 fn fold_const_param(&mut self, i: ConstParam) -> ConstParam {
76 fold_const_param(self, i)
77 }
78 #[cfg(any(feature = "derive", feature = "full"))]
fold_constraint(&mut self, i: Constraint) -> Constraint79 fn fold_constraint(&mut self, i: Constraint) -> Constraint {
80 fold_constraint(self, i)
81 }
82 #[cfg(feature = "derive")]
fold_data(&mut self, i: Data) -> Data83 fn fold_data(&mut self, i: Data) -> Data {
84 fold_data(self, i)
85 }
86 #[cfg(feature = "derive")]
fold_data_enum(&mut self, i: DataEnum) -> DataEnum87 fn fold_data_enum(&mut self, i: DataEnum) -> DataEnum {
88 fold_data_enum(self, i)
89 }
90 #[cfg(feature = "derive")]
fold_data_struct(&mut self, i: DataStruct) -> DataStruct91 fn fold_data_struct(&mut self, i: DataStruct) -> DataStruct {
92 fold_data_struct(self, i)
93 }
94 #[cfg(feature = "derive")]
fold_data_union(&mut self, i: DataUnion) -> DataUnion95 fn fold_data_union(&mut self, i: DataUnion) -> DataUnion {
96 fold_data_union(self, i)
97 }
98 #[cfg(feature = "derive")]
fold_derive_input(&mut self, i: DeriveInput) -> DeriveInput99 fn fold_derive_input(&mut self, i: DeriveInput) -> DeriveInput {
100 fold_derive_input(self, i)
101 }
102 #[cfg(any(feature = "derive", feature = "full"))]
fold_expr(&mut self, i: Expr) -> Expr103 fn fold_expr(&mut self, i: Expr) -> Expr {
104 fold_expr(self, i)
105 }
106 #[cfg(feature = "full")]
fold_expr_array(&mut self, i: ExprArray) -> ExprArray107 fn fold_expr_array(&mut self, i: ExprArray) -> ExprArray {
108 fold_expr_array(self, i)
109 }
110 #[cfg(feature = "full")]
fold_expr_assign(&mut self, i: ExprAssign) -> ExprAssign111 fn fold_expr_assign(&mut self, i: ExprAssign) -> ExprAssign {
112 fold_expr_assign(self, i)
113 }
114 #[cfg(feature = "full")]
fold_expr_assign_op(&mut self, i: ExprAssignOp) -> ExprAssignOp115 fn fold_expr_assign_op(&mut self, i: ExprAssignOp) -> ExprAssignOp {
116 fold_expr_assign_op(self, i)
117 }
118 #[cfg(feature = "full")]
fold_expr_async(&mut self, i: ExprAsync) -> ExprAsync119 fn fold_expr_async(&mut self, i: ExprAsync) -> ExprAsync {
120 fold_expr_async(self, i)
121 }
122 #[cfg(feature = "full")]
fold_expr_await(&mut self, i: ExprAwait) -> ExprAwait123 fn fold_expr_await(&mut self, i: ExprAwait) -> ExprAwait {
124 fold_expr_await(self, i)
125 }
126 #[cfg(any(feature = "derive", feature = "full"))]
fold_expr_binary(&mut self, i: ExprBinary) -> ExprBinary127 fn fold_expr_binary(&mut self, i: ExprBinary) -> ExprBinary {
128 fold_expr_binary(self, i)
129 }
130 #[cfg(feature = "full")]
fold_expr_block(&mut self, i: ExprBlock) -> ExprBlock131 fn fold_expr_block(&mut self, i: ExprBlock) -> ExprBlock {
132 fold_expr_block(self, i)
133 }
134 #[cfg(feature = "full")]
fold_expr_box(&mut self, i: ExprBox) -> ExprBox135 fn fold_expr_box(&mut self, i: ExprBox) -> ExprBox {
136 fold_expr_box(self, i)
137 }
138 #[cfg(feature = "full")]
fold_expr_break(&mut self, i: ExprBreak) -> ExprBreak139 fn fold_expr_break(&mut self, i: ExprBreak) -> ExprBreak {
140 fold_expr_break(self, i)
141 }
142 #[cfg(any(feature = "derive", feature = "full"))]
fold_expr_call(&mut self, i: ExprCall) -> ExprCall143 fn fold_expr_call(&mut self, i: ExprCall) -> ExprCall {
144 fold_expr_call(self, i)
145 }
146 #[cfg(any(feature = "derive", feature = "full"))]
fold_expr_cast(&mut self, i: ExprCast) -> ExprCast147 fn fold_expr_cast(&mut self, i: ExprCast) -> ExprCast {
148 fold_expr_cast(self, i)
149 }
150 #[cfg(feature = "full")]
fold_expr_closure(&mut self, i: ExprClosure) -> ExprClosure151 fn fold_expr_closure(&mut self, i: ExprClosure) -> ExprClosure {
152 fold_expr_closure(self, i)
153 }
154 #[cfg(feature = "full")]
fold_expr_continue(&mut self, i: ExprContinue) -> ExprContinue155 fn fold_expr_continue(&mut self, i: ExprContinue) -> ExprContinue {
156 fold_expr_continue(self, i)
157 }
158 #[cfg(any(feature = "derive", feature = "full"))]
fold_expr_field(&mut self, i: ExprField) -> ExprField159 fn fold_expr_field(&mut self, i: ExprField) -> ExprField {
160 fold_expr_field(self, i)
161 }
162 #[cfg(feature = "full")]
fold_expr_for_loop(&mut self, i: ExprForLoop) -> ExprForLoop163 fn fold_expr_for_loop(&mut self, i: ExprForLoop) -> ExprForLoop {
164 fold_expr_for_loop(self, i)
165 }
166 #[cfg(feature = "full")]
fold_expr_group(&mut self, i: ExprGroup) -> ExprGroup167 fn fold_expr_group(&mut self, i: ExprGroup) -> ExprGroup {
168 fold_expr_group(self, i)
169 }
170 #[cfg(feature = "full")]
fold_expr_if(&mut self, i: ExprIf) -> ExprIf171 fn fold_expr_if(&mut self, i: ExprIf) -> ExprIf {
172 fold_expr_if(self, i)
173 }
174 #[cfg(any(feature = "derive", feature = "full"))]
fold_expr_index(&mut self, i: ExprIndex) -> ExprIndex175 fn fold_expr_index(&mut self, i: ExprIndex) -> ExprIndex {
176 fold_expr_index(self, i)
177 }
178 #[cfg(feature = "full")]
fold_expr_let(&mut self, i: ExprLet) -> ExprLet179 fn fold_expr_let(&mut self, i: ExprLet) -> ExprLet {
180 fold_expr_let(self, i)
181 }
182 #[cfg(any(feature = "derive", feature = "full"))]
fold_expr_lit(&mut self, i: ExprLit) -> ExprLit183 fn fold_expr_lit(&mut self, i: ExprLit) -> ExprLit {
184 fold_expr_lit(self, i)
185 }
186 #[cfg(feature = "full")]
fold_expr_loop(&mut self, i: ExprLoop) -> ExprLoop187 fn fold_expr_loop(&mut self, i: ExprLoop) -> ExprLoop {
188 fold_expr_loop(self, i)
189 }
190 #[cfg(feature = "full")]
fold_expr_macro(&mut self, i: ExprMacro) -> ExprMacro191 fn fold_expr_macro(&mut self, i: ExprMacro) -> ExprMacro {
192 fold_expr_macro(self, i)
193 }
194 #[cfg(feature = "full")]
fold_expr_match(&mut self, i: ExprMatch) -> ExprMatch195 fn fold_expr_match(&mut self, i: ExprMatch) -> ExprMatch {
196 fold_expr_match(self, i)
197 }
198 #[cfg(feature = "full")]
fold_expr_method_call(&mut self, i: ExprMethodCall) -> ExprMethodCall199 fn fold_expr_method_call(&mut self, i: ExprMethodCall) -> ExprMethodCall {
200 fold_expr_method_call(self, i)
201 }
202 #[cfg(any(feature = "derive", feature = "full"))]
fold_expr_paren(&mut self, i: ExprParen) -> ExprParen203 fn fold_expr_paren(&mut self, i: ExprParen) -> ExprParen {
204 fold_expr_paren(self, i)
205 }
206 #[cfg(any(feature = "derive", feature = "full"))]
fold_expr_path(&mut self, i: ExprPath) -> ExprPath207 fn fold_expr_path(&mut self, i: ExprPath) -> ExprPath {
208 fold_expr_path(self, i)
209 }
210 #[cfg(feature = "full")]
fold_expr_range(&mut self, i: ExprRange) -> ExprRange211 fn fold_expr_range(&mut self, i: ExprRange) -> ExprRange {
212 fold_expr_range(self, i)
213 }
214 #[cfg(feature = "full")]
fold_expr_reference(&mut self, i: ExprReference) -> ExprReference215 fn fold_expr_reference(&mut self, i: ExprReference) -> ExprReference {
216 fold_expr_reference(self, i)
217 }
218 #[cfg(feature = "full")]
fold_expr_repeat(&mut self, i: ExprRepeat) -> ExprRepeat219 fn fold_expr_repeat(&mut self, i: ExprRepeat) -> ExprRepeat {
220 fold_expr_repeat(self, i)
221 }
222 #[cfg(feature = "full")]
fold_expr_return(&mut self, i: ExprReturn) -> ExprReturn223 fn fold_expr_return(&mut self, i: ExprReturn) -> ExprReturn {
224 fold_expr_return(self, i)
225 }
226 #[cfg(feature = "full")]
fold_expr_struct(&mut self, i: ExprStruct) -> ExprStruct227 fn fold_expr_struct(&mut self, i: ExprStruct) -> ExprStruct {
228 fold_expr_struct(self, i)
229 }
230 #[cfg(feature = "full")]
fold_expr_try(&mut self, i: ExprTry) -> ExprTry231 fn fold_expr_try(&mut self, i: ExprTry) -> ExprTry {
232 fold_expr_try(self, i)
233 }
234 #[cfg(feature = "full")]
fold_expr_try_block(&mut self, i: ExprTryBlock) -> ExprTryBlock235 fn fold_expr_try_block(&mut self, i: ExprTryBlock) -> ExprTryBlock {
236 fold_expr_try_block(self, i)
237 }
238 #[cfg(feature = "full")]
fold_expr_tuple(&mut self, i: ExprTuple) -> ExprTuple239 fn fold_expr_tuple(&mut self, i: ExprTuple) -> ExprTuple {
240 fold_expr_tuple(self, i)
241 }
242 #[cfg(feature = "full")]
fold_expr_type(&mut self, i: ExprType) -> ExprType243 fn fold_expr_type(&mut self, i: ExprType) -> ExprType {
244 fold_expr_type(self, i)
245 }
246 #[cfg(any(feature = "derive", feature = "full"))]
fold_expr_unary(&mut self, i: ExprUnary) -> ExprUnary247 fn fold_expr_unary(&mut self, i: ExprUnary) -> ExprUnary {
248 fold_expr_unary(self, i)
249 }
250 #[cfg(feature = "full")]
fold_expr_unsafe(&mut self, i: ExprUnsafe) -> ExprUnsafe251 fn fold_expr_unsafe(&mut self, i: ExprUnsafe) -> ExprUnsafe {
252 fold_expr_unsafe(self, i)
253 }
254 #[cfg(feature = "full")]
fold_expr_while(&mut self, i: ExprWhile) -> ExprWhile255 fn fold_expr_while(&mut self, i: ExprWhile) -> ExprWhile {
256 fold_expr_while(self, i)
257 }
258 #[cfg(feature = "full")]
fold_expr_yield(&mut self, i: ExprYield) -> ExprYield259 fn fold_expr_yield(&mut self, i: ExprYield) -> ExprYield {
260 fold_expr_yield(self, i)
261 }
262 #[cfg(any(feature = "derive", feature = "full"))]
fold_field(&mut self, i: Field) -> Field263 fn fold_field(&mut self, i: Field) -> Field {
264 fold_field(self, i)
265 }
266 #[cfg(feature = "full")]
fold_field_pat(&mut self, i: FieldPat) -> FieldPat267 fn fold_field_pat(&mut self, i: FieldPat) -> FieldPat {
268 fold_field_pat(self, i)
269 }
270 #[cfg(feature = "full")]
fold_field_value(&mut self, i: FieldValue) -> FieldValue271 fn fold_field_value(&mut self, i: FieldValue) -> FieldValue {
272 fold_field_value(self, i)
273 }
274 #[cfg(any(feature = "derive", feature = "full"))]
fold_fields(&mut self, i: Fields) -> Fields275 fn fold_fields(&mut self, i: Fields) -> Fields {
276 fold_fields(self, i)
277 }
278 #[cfg(any(feature = "derive", feature = "full"))]
fold_fields_named(&mut self, i: FieldsNamed) -> FieldsNamed279 fn fold_fields_named(&mut self, i: FieldsNamed) -> FieldsNamed {
280 fold_fields_named(self, i)
281 }
282 #[cfg(any(feature = "derive", feature = "full"))]
fold_fields_unnamed(&mut self, i: FieldsUnnamed) -> FieldsUnnamed283 fn fold_fields_unnamed(&mut self, i: FieldsUnnamed) -> FieldsUnnamed {
284 fold_fields_unnamed(self, i)
285 }
286 #[cfg(feature = "full")]
fold_file(&mut self, i: File) -> File287 fn fold_file(&mut self, i: File) -> File {
288 fold_file(self, i)
289 }
290 #[cfg(feature = "full")]
fold_fn_arg(&mut self, i: FnArg) -> FnArg291 fn fold_fn_arg(&mut self, i: FnArg) -> FnArg {
292 fold_fn_arg(self, i)
293 }
294 #[cfg(feature = "full")]
fold_foreign_item(&mut self, i: ForeignItem) -> ForeignItem295 fn fold_foreign_item(&mut self, i: ForeignItem) -> ForeignItem {
296 fold_foreign_item(self, i)
297 }
298 #[cfg(feature = "full")]
fold_foreign_item_fn(&mut self, i: ForeignItemFn) -> ForeignItemFn299 fn fold_foreign_item_fn(&mut self, i: ForeignItemFn) -> ForeignItemFn {
300 fold_foreign_item_fn(self, i)
301 }
302 #[cfg(feature = "full")]
fold_foreign_item_macro(&mut self, i: ForeignItemMacro) -> ForeignItemMacro303 fn fold_foreign_item_macro(&mut self, i: ForeignItemMacro) -> ForeignItemMacro {
304 fold_foreign_item_macro(self, i)
305 }
306 #[cfg(feature = "full")]
fold_foreign_item_static(&mut self, i: ForeignItemStatic) -> ForeignItemStatic307 fn fold_foreign_item_static(&mut self, i: ForeignItemStatic) -> ForeignItemStatic {
308 fold_foreign_item_static(self, i)
309 }
310 #[cfg(feature = "full")]
fold_foreign_item_type(&mut self, i: ForeignItemType) -> ForeignItemType311 fn fold_foreign_item_type(&mut self, i: ForeignItemType) -> ForeignItemType {
312 fold_foreign_item_type(self, i)
313 }
314 #[cfg(any(feature = "derive", feature = "full"))]
fold_generic_argument(&mut self, i: GenericArgument) -> GenericArgument315 fn fold_generic_argument(&mut self, i: GenericArgument) -> GenericArgument {
316 fold_generic_argument(self, i)
317 }
318 #[cfg(feature = "full")]
fold_generic_method_argument(&mut self, i: GenericMethodArgument) -> GenericMethodArgument319 fn fold_generic_method_argument(&mut self, i: GenericMethodArgument) -> GenericMethodArgument {
320 fold_generic_method_argument(self, i)
321 }
322 #[cfg(any(feature = "derive", feature = "full"))]
fold_generic_param(&mut self, i: GenericParam) -> GenericParam323 fn fold_generic_param(&mut self, i: GenericParam) -> GenericParam {
324 fold_generic_param(self, i)
325 }
326 #[cfg(any(feature = "derive", feature = "full"))]
fold_generics(&mut self, i: Generics) -> Generics327 fn fold_generics(&mut self, i: Generics) -> Generics {
328 fold_generics(self, i)
329 }
fold_ident(&mut self, i: Ident) -> Ident330 fn fold_ident(&mut self, i: Ident) -> Ident {
331 fold_ident(self, i)
332 }
333 #[cfg(feature = "full")]
fold_impl_item(&mut self, i: ImplItem) -> ImplItem334 fn fold_impl_item(&mut self, i: ImplItem) -> ImplItem {
335 fold_impl_item(self, i)
336 }
337 #[cfg(feature = "full")]
fold_impl_item_const(&mut self, i: ImplItemConst) -> ImplItemConst338 fn fold_impl_item_const(&mut self, i: ImplItemConst) -> ImplItemConst {
339 fold_impl_item_const(self, i)
340 }
341 #[cfg(feature = "full")]
fold_impl_item_macro(&mut self, i: ImplItemMacro) -> ImplItemMacro342 fn fold_impl_item_macro(&mut self, i: ImplItemMacro) -> ImplItemMacro {
343 fold_impl_item_macro(self, i)
344 }
345 #[cfg(feature = "full")]
fold_impl_item_method(&mut self, i: ImplItemMethod) -> ImplItemMethod346 fn fold_impl_item_method(&mut self, i: ImplItemMethod) -> ImplItemMethod {
347 fold_impl_item_method(self, i)
348 }
349 #[cfg(feature = "full")]
fold_impl_item_type(&mut self, i: ImplItemType) -> ImplItemType350 fn fold_impl_item_type(&mut self, i: ImplItemType) -> ImplItemType {
351 fold_impl_item_type(self, i)
352 }
353 #[cfg(any(feature = "derive", feature = "full"))]
fold_index(&mut self, i: Index) -> Index354 fn fold_index(&mut self, i: Index) -> Index {
355 fold_index(self, i)
356 }
357 #[cfg(feature = "full")]
fold_item(&mut self, i: Item) -> Item358 fn fold_item(&mut self, i: Item) -> Item {
359 fold_item(self, i)
360 }
361 #[cfg(feature = "full")]
fold_item_const(&mut self, i: ItemConst) -> ItemConst362 fn fold_item_const(&mut self, i: ItemConst) -> ItemConst {
363 fold_item_const(self, i)
364 }
365 #[cfg(feature = "full")]
fold_item_enum(&mut self, i: ItemEnum) -> ItemEnum366 fn fold_item_enum(&mut self, i: ItemEnum) -> ItemEnum {
367 fold_item_enum(self, i)
368 }
369 #[cfg(feature = "full")]
fold_item_extern_crate(&mut self, i: ItemExternCrate) -> ItemExternCrate370 fn fold_item_extern_crate(&mut self, i: ItemExternCrate) -> ItemExternCrate {
371 fold_item_extern_crate(self, i)
372 }
373 #[cfg(feature = "full")]
fold_item_fn(&mut self, i: ItemFn) -> ItemFn374 fn fold_item_fn(&mut self, i: ItemFn) -> ItemFn {
375 fold_item_fn(self, i)
376 }
377 #[cfg(feature = "full")]
fold_item_foreign_mod(&mut self, i: ItemForeignMod) -> ItemForeignMod378 fn fold_item_foreign_mod(&mut self, i: ItemForeignMod) -> ItemForeignMod {
379 fold_item_foreign_mod(self, i)
380 }
381 #[cfg(feature = "full")]
fold_item_impl(&mut self, i: ItemImpl) -> ItemImpl382 fn fold_item_impl(&mut self, i: ItemImpl) -> ItemImpl {
383 fold_item_impl(self, i)
384 }
385 #[cfg(feature = "full")]
fold_item_macro(&mut self, i: ItemMacro) -> ItemMacro386 fn fold_item_macro(&mut self, i: ItemMacro) -> ItemMacro {
387 fold_item_macro(self, i)
388 }
389 #[cfg(feature = "full")]
fold_item_macro2(&mut self, i: ItemMacro2) -> ItemMacro2390 fn fold_item_macro2(&mut self, i: ItemMacro2) -> ItemMacro2 {
391 fold_item_macro2(self, i)
392 }
393 #[cfg(feature = "full")]
fold_item_mod(&mut self, i: ItemMod) -> ItemMod394 fn fold_item_mod(&mut self, i: ItemMod) -> ItemMod {
395 fold_item_mod(self, i)
396 }
397 #[cfg(feature = "full")]
fold_item_static(&mut self, i: ItemStatic) -> ItemStatic398 fn fold_item_static(&mut self, i: ItemStatic) -> ItemStatic {
399 fold_item_static(self, i)
400 }
401 #[cfg(feature = "full")]
fold_item_struct(&mut self, i: ItemStruct) -> ItemStruct402 fn fold_item_struct(&mut self, i: ItemStruct) -> ItemStruct {
403 fold_item_struct(self, i)
404 }
405 #[cfg(feature = "full")]
fold_item_trait(&mut self, i: ItemTrait) -> ItemTrait406 fn fold_item_trait(&mut self, i: ItemTrait) -> ItemTrait {
407 fold_item_trait(self, i)
408 }
409 #[cfg(feature = "full")]
fold_item_trait_alias(&mut self, i: ItemTraitAlias) -> ItemTraitAlias410 fn fold_item_trait_alias(&mut self, i: ItemTraitAlias) -> ItemTraitAlias {
411 fold_item_trait_alias(self, i)
412 }
413 #[cfg(feature = "full")]
fold_item_type(&mut self, i: ItemType) -> ItemType414 fn fold_item_type(&mut self, i: ItemType) -> ItemType {
415 fold_item_type(self, i)
416 }
417 #[cfg(feature = "full")]
fold_item_union(&mut self, i: ItemUnion) -> ItemUnion418 fn fold_item_union(&mut self, i: ItemUnion) -> ItemUnion {
419 fold_item_union(self, i)
420 }
421 #[cfg(feature = "full")]
fold_item_use(&mut self, i: ItemUse) -> ItemUse422 fn fold_item_use(&mut self, i: ItemUse) -> ItemUse {
423 fold_item_use(self, i)
424 }
425 #[cfg(feature = "full")]
fold_label(&mut self, i: Label) -> Label426 fn fold_label(&mut self, i: Label) -> Label {
427 fold_label(self, i)
428 }
fold_lifetime(&mut self, i: Lifetime) -> Lifetime429 fn fold_lifetime(&mut self, i: Lifetime) -> Lifetime {
430 fold_lifetime(self, i)
431 }
432 #[cfg(any(feature = "derive", feature = "full"))]
fold_lifetime_def(&mut self, i: LifetimeDef) -> LifetimeDef433 fn fold_lifetime_def(&mut self, i: LifetimeDef) -> LifetimeDef {
434 fold_lifetime_def(self, i)
435 }
fold_lit(&mut self, i: Lit) -> Lit436 fn fold_lit(&mut self, i: Lit) -> Lit {
437 fold_lit(self, i)
438 }
fold_lit_bool(&mut self, i: LitBool) -> LitBool439 fn fold_lit_bool(&mut self, i: LitBool) -> LitBool {
440 fold_lit_bool(self, i)
441 }
fold_lit_byte(&mut self, i: LitByte) -> LitByte442 fn fold_lit_byte(&mut self, i: LitByte) -> LitByte {
443 fold_lit_byte(self, i)
444 }
fold_lit_byte_str(&mut self, i: LitByteStr) -> LitByteStr445 fn fold_lit_byte_str(&mut self, i: LitByteStr) -> LitByteStr {
446 fold_lit_byte_str(self, i)
447 }
fold_lit_char(&mut self, i: LitChar) -> LitChar448 fn fold_lit_char(&mut self, i: LitChar) -> LitChar {
449 fold_lit_char(self, i)
450 }
fold_lit_float(&mut self, i: LitFloat) -> LitFloat451 fn fold_lit_float(&mut self, i: LitFloat) -> LitFloat {
452 fold_lit_float(self, i)
453 }
fold_lit_int(&mut self, i: LitInt) -> LitInt454 fn fold_lit_int(&mut self, i: LitInt) -> LitInt {
455 fold_lit_int(self, i)
456 }
fold_lit_str(&mut self, i: LitStr) -> LitStr457 fn fold_lit_str(&mut self, i: LitStr) -> LitStr {
458 fold_lit_str(self, i)
459 }
460 #[cfg(feature = "full")]
fold_local(&mut self, i: Local) -> Local461 fn fold_local(&mut self, i: Local) -> Local {
462 fold_local(self, i)
463 }
464 #[cfg(any(feature = "derive", feature = "full"))]
fold_macro(&mut self, i: Macro) -> Macro465 fn fold_macro(&mut self, i: Macro) -> Macro {
466 fold_macro(self, i)
467 }
468 #[cfg(any(feature = "derive", feature = "full"))]
fold_macro_delimiter(&mut self, i: MacroDelimiter) -> MacroDelimiter469 fn fold_macro_delimiter(&mut self, i: MacroDelimiter) -> MacroDelimiter {
470 fold_macro_delimiter(self, i)
471 }
472 #[cfg(any(feature = "derive", feature = "full"))]
fold_member(&mut self, i: Member) -> Member473 fn fold_member(&mut self, i: Member) -> Member {
474 fold_member(self, i)
475 }
476 #[cfg(any(feature = "derive", feature = "full"))]
fold_meta(&mut self, i: Meta) -> Meta477 fn fold_meta(&mut self, i: Meta) -> Meta {
478 fold_meta(self, i)
479 }
480 #[cfg(any(feature = "derive", feature = "full"))]
fold_meta_list(&mut self, i: MetaList) -> MetaList481 fn fold_meta_list(&mut self, i: MetaList) -> MetaList {
482 fold_meta_list(self, i)
483 }
484 #[cfg(any(feature = "derive", feature = "full"))]
fold_meta_name_value(&mut self, i: MetaNameValue) -> MetaNameValue485 fn fold_meta_name_value(&mut self, i: MetaNameValue) -> MetaNameValue {
486 fold_meta_name_value(self, i)
487 }
488 #[cfg(feature = "full")]
fold_method_turbofish(&mut self, i: MethodTurbofish) -> MethodTurbofish489 fn fold_method_turbofish(&mut self, i: MethodTurbofish) -> MethodTurbofish {
490 fold_method_turbofish(self, i)
491 }
492 #[cfg(any(feature = "derive", feature = "full"))]
fold_nested_meta(&mut self, i: NestedMeta) -> NestedMeta493 fn fold_nested_meta(&mut self, i: NestedMeta) -> NestedMeta {
494 fold_nested_meta(self, i)
495 }
496 #[cfg(any(feature = "derive", feature = "full"))]
fold_parenthesized_generic_arguments( &mut self, i: ParenthesizedGenericArguments, ) -> ParenthesizedGenericArguments497 fn fold_parenthesized_generic_arguments(
498 &mut self,
499 i: ParenthesizedGenericArguments,
500 ) -> ParenthesizedGenericArguments {
501 fold_parenthesized_generic_arguments(self, i)
502 }
503 #[cfg(feature = "full")]
fold_pat(&mut self, i: Pat) -> Pat504 fn fold_pat(&mut self, i: Pat) -> Pat {
505 fold_pat(self, i)
506 }
507 #[cfg(feature = "full")]
fold_pat_box(&mut self, i: PatBox) -> PatBox508 fn fold_pat_box(&mut self, i: PatBox) -> PatBox {
509 fold_pat_box(self, i)
510 }
511 #[cfg(feature = "full")]
fold_pat_ident(&mut self, i: PatIdent) -> PatIdent512 fn fold_pat_ident(&mut self, i: PatIdent) -> PatIdent {
513 fold_pat_ident(self, i)
514 }
515 #[cfg(feature = "full")]
fold_pat_lit(&mut self, i: PatLit) -> PatLit516 fn fold_pat_lit(&mut self, i: PatLit) -> PatLit {
517 fold_pat_lit(self, i)
518 }
519 #[cfg(feature = "full")]
fold_pat_macro(&mut self, i: PatMacro) -> PatMacro520 fn fold_pat_macro(&mut self, i: PatMacro) -> PatMacro {
521 fold_pat_macro(self, i)
522 }
523 #[cfg(feature = "full")]
fold_pat_or(&mut self, i: PatOr) -> PatOr524 fn fold_pat_or(&mut self, i: PatOr) -> PatOr {
525 fold_pat_or(self, i)
526 }
527 #[cfg(feature = "full")]
fold_pat_path(&mut self, i: PatPath) -> PatPath528 fn fold_pat_path(&mut self, i: PatPath) -> PatPath {
529 fold_pat_path(self, i)
530 }
531 #[cfg(feature = "full")]
fold_pat_range(&mut self, i: PatRange) -> PatRange532 fn fold_pat_range(&mut self, i: PatRange) -> PatRange {
533 fold_pat_range(self, i)
534 }
535 #[cfg(feature = "full")]
fold_pat_reference(&mut self, i: PatReference) -> PatReference536 fn fold_pat_reference(&mut self, i: PatReference) -> PatReference {
537 fold_pat_reference(self, i)
538 }
539 #[cfg(feature = "full")]
fold_pat_rest(&mut self, i: PatRest) -> PatRest540 fn fold_pat_rest(&mut self, i: PatRest) -> PatRest {
541 fold_pat_rest(self, i)
542 }
543 #[cfg(feature = "full")]
fold_pat_slice(&mut self, i: PatSlice) -> PatSlice544 fn fold_pat_slice(&mut self, i: PatSlice) -> PatSlice {
545 fold_pat_slice(self, i)
546 }
547 #[cfg(feature = "full")]
fold_pat_struct(&mut self, i: PatStruct) -> PatStruct548 fn fold_pat_struct(&mut self, i: PatStruct) -> PatStruct {
549 fold_pat_struct(self, i)
550 }
551 #[cfg(feature = "full")]
fold_pat_tuple(&mut self, i: PatTuple) -> PatTuple552 fn fold_pat_tuple(&mut self, i: PatTuple) -> PatTuple {
553 fold_pat_tuple(self, i)
554 }
555 #[cfg(feature = "full")]
fold_pat_tuple_struct(&mut self, i: PatTupleStruct) -> PatTupleStruct556 fn fold_pat_tuple_struct(&mut self, i: PatTupleStruct) -> PatTupleStruct {
557 fold_pat_tuple_struct(self, i)
558 }
559 #[cfg(feature = "full")]
fold_pat_type(&mut self, i: PatType) -> PatType560 fn fold_pat_type(&mut self, i: PatType) -> PatType {
561 fold_pat_type(self, i)
562 }
563 #[cfg(feature = "full")]
fold_pat_wild(&mut self, i: PatWild) -> PatWild564 fn fold_pat_wild(&mut self, i: PatWild) -> PatWild {
565 fold_pat_wild(self, i)
566 }
567 #[cfg(any(feature = "derive", feature = "full"))]
fold_path(&mut self, i: Path) -> Path568 fn fold_path(&mut self, i: Path) -> Path {
569 fold_path(self, i)
570 }
571 #[cfg(any(feature = "derive", feature = "full"))]
fold_path_arguments(&mut self, i: PathArguments) -> PathArguments572 fn fold_path_arguments(&mut self, i: PathArguments) -> PathArguments {
573 fold_path_arguments(self, i)
574 }
575 #[cfg(any(feature = "derive", feature = "full"))]
fold_path_segment(&mut self, i: PathSegment) -> PathSegment576 fn fold_path_segment(&mut self, i: PathSegment) -> PathSegment {
577 fold_path_segment(self, i)
578 }
579 #[cfg(any(feature = "derive", feature = "full"))]
fold_predicate_eq(&mut self, i: PredicateEq) -> PredicateEq580 fn fold_predicate_eq(&mut self, i: PredicateEq) -> PredicateEq {
581 fold_predicate_eq(self, i)
582 }
583 #[cfg(any(feature = "derive", feature = "full"))]
fold_predicate_lifetime(&mut self, i: PredicateLifetime) -> PredicateLifetime584 fn fold_predicate_lifetime(&mut self, i: PredicateLifetime) -> PredicateLifetime {
585 fold_predicate_lifetime(self, i)
586 }
587 #[cfg(any(feature = "derive", feature = "full"))]
fold_predicate_type(&mut self, i: PredicateType) -> PredicateType588 fn fold_predicate_type(&mut self, i: PredicateType) -> PredicateType {
589 fold_predicate_type(self, i)
590 }
591 #[cfg(any(feature = "derive", feature = "full"))]
fold_qself(&mut self, i: QSelf) -> QSelf592 fn fold_qself(&mut self, i: QSelf) -> QSelf {
593 fold_qself(self, i)
594 }
595 #[cfg(feature = "full")]
fold_range_limits(&mut self, i: RangeLimits) -> RangeLimits596 fn fold_range_limits(&mut self, i: RangeLimits) -> RangeLimits {
597 fold_range_limits(self, i)
598 }
599 #[cfg(feature = "full")]
fold_receiver(&mut self, i: Receiver) -> Receiver600 fn fold_receiver(&mut self, i: Receiver) -> Receiver {
601 fold_receiver(self, i)
602 }
603 #[cfg(any(feature = "derive", feature = "full"))]
fold_return_type(&mut self, i: ReturnType) -> ReturnType604 fn fold_return_type(&mut self, i: ReturnType) -> ReturnType {
605 fold_return_type(self, i)
606 }
607 #[cfg(feature = "full")]
fold_signature(&mut self, i: Signature) -> Signature608 fn fold_signature(&mut self, i: Signature) -> Signature {
609 fold_signature(self, i)
610 }
fold_span(&mut self, i: Span) -> Span611 fn fold_span(&mut self, i: Span) -> Span {
612 fold_span(self, i)
613 }
614 #[cfg(feature = "full")]
fold_stmt(&mut self, i: Stmt) -> Stmt615 fn fold_stmt(&mut self, i: Stmt) -> Stmt {
616 fold_stmt(self, i)
617 }
618 #[cfg(any(feature = "derive", feature = "full"))]
fold_trait_bound(&mut self, i: TraitBound) -> TraitBound619 fn fold_trait_bound(&mut self, i: TraitBound) -> TraitBound {
620 fold_trait_bound(self, i)
621 }
622 #[cfg(any(feature = "derive", feature = "full"))]
fold_trait_bound_modifier(&mut self, i: TraitBoundModifier) -> TraitBoundModifier623 fn fold_trait_bound_modifier(&mut self, i: TraitBoundModifier) -> TraitBoundModifier {
624 fold_trait_bound_modifier(self, i)
625 }
626 #[cfg(feature = "full")]
fold_trait_item(&mut self, i: TraitItem) -> TraitItem627 fn fold_trait_item(&mut self, i: TraitItem) -> TraitItem {
628 fold_trait_item(self, i)
629 }
630 #[cfg(feature = "full")]
fold_trait_item_const(&mut self, i: TraitItemConst) -> TraitItemConst631 fn fold_trait_item_const(&mut self, i: TraitItemConst) -> TraitItemConst {
632 fold_trait_item_const(self, i)
633 }
634 #[cfg(feature = "full")]
fold_trait_item_macro(&mut self, i: TraitItemMacro) -> TraitItemMacro635 fn fold_trait_item_macro(&mut self, i: TraitItemMacro) -> TraitItemMacro {
636 fold_trait_item_macro(self, i)
637 }
638 #[cfg(feature = "full")]
fold_trait_item_method(&mut self, i: TraitItemMethod) -> TraitItemMethod639 fn fold_trait_item_method(&mut self, i: TraitItemMethod) -> TraitItemMethod {
640 fold_trait_item_method(self, i)
641 }
642 #[cfg(feature = "full")]
fold_trait_item_type(&mut self, i: TraitItemType) -> TraitItemType643 fn fold_trait_item_type(&mut self, i: TraitItemType) -> TraitItemType {
644 fold_trait_item_type(self, i)
645 }
646 #[cfg(any(feature = "derive", feature = "full"))]
fold_type(&mut self, i: Type) -> Type647 fn fold_type(&mut self, i: Type) -> Type {
648 fold_type(self, i)
649 }
650 #[cfg(any(feature = "derive", feature = "full"))]
fold_type_array(&mut self, i: TypeArray) -> TypeArray651 fn fold_type_array(&mut self, i: TypeArray) -> TypeArray {
652 fold_type_array(self, i)
653 }
654 #[cfg(any(feature = "derive", feature = "full"))]
fold_type_bare_fn(&mut self, i: TypeBareFn) -> TypeBareFn655 fn fold_type_bare_fn(&mut self, i: TypeBareFn) -> TypeBareFn {
656 fold_type_bare_fn(self, i)
657 }
658 #[cfg(any(feature = "derive", feature = "full"))]
fold_type_group(&mut self, i: TypeGroup) -> TypeGroup659 fn fold_type_group(&mut self, i: TypeGroup) -> TypeGroup {
660 fold_type_group(self, i)
661 }
662 #[cfg(any(feature = "derive", feature = "full"))]
fold_type_impl_trait(&mut self, i: TypeImplTrait) -> TypeImplTrait663 fn fold_type_impl_trait(&mut self, i: TypeImplTrait) -> TypeImplTrait {
664 fold_type_impl_trait(self, i)
665 }
666 #[cfg(any(feature = "derive", feature = "full"))]
fold_type_infer(&mut self, i: TypeInfer) -> TypeInfer667 fn fold_type_infer(&mut self, i: TypeInfer) -> TypeInfer {
668 fold_type_infer(self, i)
669 }
670 #[cfg(any(feature = "derive", feature = "full"))]
fold_type_macro(&mut self, i: TypeMacro) -> TypeMacro671 fn fold_type_macro(&mut self, i: TypeMacro) -> TypeMacro {
672 fold_type_macro(self, i)
673 }
674 #[cfg(any(feature = "derive", feature = "full"))]
fold_type_never(&mut self, i: TypeNever) -> TypeNever675 fn fold_type_never(&mut self, i: TypeNever) -> TypeNever {
676 fold_type_never(self, i)
677 }
678 #[cfg(any(feature = "derive", feature = "full"))]
fold_type_param(&mut self, i: TypeParam) -> TypeParam679 fn fold_type_param(&mut self, i: TypeParam) -> TypeParam {
680 fold_type_param(self, i)
681 }
682 #[cfg(any(feature = "derive", feature = "full"))]
fold_type_param_bound(&mut self, i: TypeParamBound) -> TypeParamBound683 fn fold_type_param_bound(&mut self, i: TypeParamBound) -> TypeParamBound {
684 fold_type_param_bound(self, i)
685 }
686 #[cfg(any(feature = "derive", feature = "full"))]
fold_type_paren(&mut self, i: TypeParen) -> TypeParen687 fn fold_type_paren(&mut self, i: TypeParen) -> TypeParen {
688 fold_type_paren(self, i)
689 }
690 #[cfg(any(feature = "derive", feature = "full"))]
fold_type_path(&mut self, i: TypePath) -> TypePath691 fn fold_type_path(&mut self, i: TypePath) -> TypePath {
692 fold_type_path(self, i)
693 }
694 #[cfg(any(feature = "derive", feature = "full"))]
fold_type_ptr(&mut self, i: TypePtr) -> TypePtr695 fn fold_type_ptr(&mut self, i: TypePtr) -> TypePtr {
696 fold_type_ptr(self, i)
697 }
698 #[cfg(any(feature = "derive", feature = "full"))]
fold_type_reference(&mut self, i: TypeReference) -> TypeReference699 fn fold_type_reference(&mut self, i: TypeReference) -> TypeReference {
700 fold_type_reference(self, i)
701 }
702 #[cfg(any(feature = "derive", feature = "full"))]
fold_type_slice(&mut self, i: TypeSlice) -> TypeSlice703 fn fold_type_slice(&mut self, i: TypeSlice) -> TypeSlice {
704 fold_type_slice(self, i)
705 }
706 #[cfg(any(feature = "derive", feature = "full"))]
fold_type_trait_object(&mut self, i: TypeTraitObject) -> TypeTraitObject707 fn fold_type_trait_object(&mut self, i: TypeTraitObject) -> TypeTraitObject {
708 fold_type_trait_object(self, i)
709 }
710 #[cfg(any(feature = "derive", feature = "full"))]
fold_type_tuple(&mut self, i: TypeTuple) -> TypeTuple711 fn fold_type_tuple(&mut self, i: TypeTuple) -> TypeTuple {
712 fold_type_tuple(self, i)
713 }
714 #[cfg(any(feature = "derive", feature = "full"))]
fold_un_op(&mut self, i: UnOp) -> UnOp715 fn fold_un_op(&mut self, i: UnOp) -> UnOp {
716 fold_un_op(self, i)
717 }
718 #[cfg(feature = "full")]
fold_use_glob(&mut self, i: UseGlob) -> UseGlob719 fn fold_use_glob(&mut self, i: UseGlob) -> UseGlob {
720 fold_use_glob(self, i)
721 }
722 #[cfg(feature = "full")]
fold_use_group(&mut self, i: UseGroup) -> UseGroup723 fn fold_use_group(&mut self, i: UseGroup) -> UseGroup {
724 fold_use_group(self, i)
725 }
726 #[cfg(feature = "full")]
fold_use_name(&mut self, i: UseName) -> UseName727 fn fold_use_name(&mut self, i: UseName) -> UseName {
728 fold_use_name(self, i)
729 }
730 #[cfg(feature = "full")]
fold_use_path(&mut self, i: UsePath) -> UsePath731 fn fold_use_path(&mut self, i: UsePath) -> UsePath {
732 fold_use_path(self, i)
733 }
734 #[cfg(feature = "full")]
fold_use_rename(&mut self, i: UseRename) -> UseRename735 fn fold_use_rename(&mut self, i: UseRename) -> UseRename {
736 fold_use_rename(self, i)
737 }
738 #[cfg(feature = "full")]
fold_use_tree(&mut self, i: UseTree) -> UseTree739 fn fold_use_tree(&mut self, i: UseTree) -> UseTree {
740 fold_use_tree(self, i)
741 }
742 #[cfg(any(feature = "derive", feature = "full"))]
fold_variadic(&mut self, i: Variadic) -> Variadic743 fn fold_variadic(&mut self, i: Variadic) -> Variadic {
744 fold_variadic(self, i)
745 }
746 #[cfg(any(feature = "derive", feature = "full"))]
fold_variant(&mut self, i: Variant) -> Variant747 fn fold_variant(&mut self, i: Variant) -> Variant {
748 fold_variant(self, i)
749 }
750 #[cfg(any(feature = "derive", feature = "full"))]
fold_vis_crate(&mut self, i: VisCrate) -> VisCrate751 fn fold_vis_crate(&mut self, i: VisCrate) -> VisCrate {
752 fold_vis_crate(self, i)
753 }
754 #[cfg(any(feature = "derive", feature = "full"))]
fold_vis_public(&mut self, i: VisPublic) -> VisPublic755 fn fold_vis_public(&mut self, i: VisPublic) -> VisPublic {
756 fold_vis_public(self, i)
757 }
758 #[cfg(any(feature = "derive", feature = "full"))]
fold_vis_restricted(&mut self, i: VisRestricted) -> VisRestricted759 fn fold_vis_restricted(&mut self, i: VisRestricted) -> VisRestricted {
760 fold_vis_restricted(self, i)
761 }
762 #[cfg(any(feature = "derive", feature = "full"))]
fold_visibility(&mut self, i: Visibility) -> Visibility763 fn fold_visibility(&mut self, i: Visibility) -> Visibility {
764 fold_visibility(self, i)
765 }
766 #[cfg(any(feature = "derive", feature = "full"))]
fold_where_clause(&mut self, i: WhereClause) -> WhereClause767 fn fold_where_clause(&mut self, i: WhereClause) -> WhereClause {
768 fold_where_clause(self, i)
769 }
770 #[cfg(any(feature = "derive", feature = "full"))]
fold_where_predicate(&mut self, i: WherePredicate) -> WherePredicate771 fn fold_where_predicate(&mut self, i: WherePredicate) -> WherePredicate {
772 fold_where_predicate(self, i)
773 }
774 }
775 #[cfg(any(feature = "derive", feature = "full"))]
fold_abi<F>(f: &mut F, node: Abi) -> Abi where F: Fold + ?Sized,776 pub fn fold_abi<F>(f: &mut F, node: Abi) -> Abi
777 where
778 F: Fold + ?Sized,
779 {
780 Abi {
781 extern_token: Token![extern](tokens_helper(f, &node.extern_token.span)),
782 name: (node.name).map(|it| f.fold_lit_str(it)),
783 }
784 }
785 #[cfg(any(feature = "derive", feature = "full"))]
fold_angle_bracketed_generic_arguments<F>( f: &mut F, node: AngleBracketedGenericArguments, ) -> AngleBracketedGenericArguments where F: Fold + ?Sized,786 pub fn fold_angle_bracketed_generic_arguments<F>(
787 f: &mut F,
788 node: AngleBracketedGenericArguments,
789 ) -> AngleBracketedGenericArguments
790 where
791 F: Fold + ?Sized,
792 {
793 AngleBracketedGenericArguments {
794 colon2_token: (node.colon2_token).map(|it| Token ! [ :: ](tokens_helper(f, &it.spans))),
795 lt_token: Token ! [ < ](tokens_helper(f, &node.lt_token.spans)),
796 args: FoldHelper::lift(node.args, |it| f.fold_generic_argument(it)),
797 gt_token: Token ! [ > ](tokens_helper(f, &node.gt_token.spans)),
798 }
799 }
800 #[cfg(feature = "full")]
fold_arm<F>(f: &mut F, node: Arm) -> Arm where F: Fold + ?Sized,801 pub fn fold_arm<F>(f: &mut F, node: Arm) -> Arm
802 where
803 F: Fold + ?Sized,
804 {
805 Arm {
806 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
807 pat: f.fold_pat(node.pat),
808 guard: (node.guard).map(|it| {
809 (
810 Token![if](tokens_helper(f, &(it).0.span)),
811 Box::new(f.fold_expr(*(it).1)),
812 )
813 }),
814 fat_arrow_token: Token ! [ => ](tokens_helper(f, &node.fat_arrow_token.spans)),
815 body: Box::new(f.fold_expr(*node.body)),
816 comma: (node.comma).map(|it| Token ! [ , ](tokens_helper(f, &it.spans))),
817 }
818 }
819 #[cfg(any(feature = "derive", feature = "full"))]
fold_attr_style<F>(f: &mut F, node: AttrStyle) -> AttrStyle where F: Fold + ?Sized,820 pub fn fold_attr_style<F>(f: &mut F, node: AttrStyle) -> AttrStyle
821 where
822 F: Fold + ?Sized,
823 {
824 match node {
825 AttrStyle::Outer => AttrStyle::Outer,
826 AttrStyle::Inner(_binding_0) => {
827 AttrStyle::Inner(Token![!](tokens_helper(f, &_binding_0.spans)))
828 }
829 }
830 }
831 #[cfg(any(feature = "derive", feature = "full"))]
fold_attribute<F>(f: &mut F, node: Attribute) -> Attribute where F: Fold + ?Sized,832 pub fn fold_attribute<F>(f: &mut F, node: Attribute) -> Attribute
833 where
834 F: Fold + ?Sized,
835 {
836 Attribute {
837 pound_token: Token ! [ # ](tokens_helper(f, &node.pound_token.spans)),
838 style: f.fold_attr_style(node.style),
839 bracket_token: Bracket(tokens_helper(f, &node.bracket_token.span)),
840 path: f.fold_path(node.path),
841 tokens: node.tokens,
842 }
843 }
844 #[cfg(any(feature = "derive", feature = "full"))]
fold_bare_fn_arg<F>(f: &mut F, node: BareFnArg) -> BareFnArg where F: Fold + ?Sized,845 pub fn fold_bare_fn_arg<F>(f: &mut F, node: BareFnArg) -> BareFnArg
846 where
847 F: Fold + ?Sized,
848 {
849 BareFnArg {
850 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
851 name: (node.name).map(|it| {
852 (
853 f.fold_ident((it).0),
854 Token ! [ : ](tokens_helper(f, &(it).1.spans)),
855 )
856 }),
857 ty: f.fold_type(node.ty),
858 }
859 }
860 #[cfg(any(feature = "derive", feature = "full"))]
fold_bin_op<F>(f: &mut F, node: BinOp) -> BinOp where F: Fold + ?Sized,861 pub fn fold_bin_op<F>(f: &mut F, node: BinOp) -> BinOp
862 where
863 F: Fold + ?Sized,
864 {
865 match node {
866 BinOp::Add(_binding_0) => BinOp::Add(Token ! [ + ](tokens_helper(f, &_binding_0.spans))),
867 BinOp::Sub(_binding_0) => BinOp::Sub(Token ! [ - ](tokens_helper(f, &_binding_0.spans))),
868 BinOp::Mul(_binding_0) => BinOp::Mul(Token ! [ * ](tokens_helper(f, &_binding_0.spans))),
869 BinOp::Div(_binding_0) => BinOp::Div(Token ! [ / ](tokens_helper(f, &_binding_0.spans))),
870 BinOp::Rem(_binding_0) => BinOp::Rem(Token ! [ % ](tokens_helper(f, &_binding_0.spans))),
871 BinOp::And(_binding_0) => BinOp::And(Token ! [ && ](tokens_helper(f, &_binding_0.spans))),
872 BinOp::Or(_binding_0) => BinOp::Or(Token ! [ || ](tokens_helper(f, &_binding_0.spans))),
873 BinOp::BitXor(_binding_0) => {
874 BinOp::BitXor(Token ! [ ^ ](tokens_helper(f, &_binding_0.spans)))
875 }
876 BinOp::BitAnd(_binding_0) => {
877 BinOp::BitAnd(Token ! [ & ](tokens_helper(f, &_binding_0.spans)))
878 }
879 BinOp::BitOr(_binding_0) => {
880 BinOp::BitOr(Token ! [ | ](tokens_helper(f, &_binding_0.spans)))
881 }
882 BinOp::Shl(_binding_0) => BinOp::Shl(Token ! [ << ](tokens_helper(f, &_binding_0.spans))),
883 BinOp::Shr(_binding_0) => BinOp::Shr(Token ! [ >> ](tokens_helper(f, &_binding_0.spans))),
884 BinOp::Eq(_binding_0) => BinOp::Eq(Token ! [ == ](tokens_helper(f, &_binding_0.spans))),
885 BinOp::Lt(_binding_0) => BinOp::Lt(Token ! [ < ](tokens_helper(f, &_binding_0.spans))),
886 BinOp::Le(_binding_0) => BinOp::Le(Token ! [ <= ](tokens_helper(f, &_binding_0.spans))),
887 BinOp::Ne(_binding_0) => BinOp::Ne(Token ! [ != ](tokens_helper(f, &_binding_0.spans))),
888 BinOp::Ge(_binding_0) => BinOp::Ge(Token ! [ >= ](tokens_helper(f, &_binding_0.spans))),
889 BinOp::Gt(_binding_0) => BinOp::Gt(Token ! [ > ](tokens_helper(f, &_binding_0.spans))),
890 BinOp::AddEq(_binding_0) => {
891 BinOp::AddEq(Token ! [ += ](tokens_helper(f, &_binding_0.spans)))
892 }
893 BinOp::SubEq(_binding_0) => {
894 BinOp::SubEq(Token ! [ -= ](tokens_helper(f, &_binding_0.spans)))
895 }
896 BinOp::MulEq(_binding_0) => {
897 BinOp::MulEq(Token ! [ *= ](tokens_helper(f, &_binding_0.spans)))
898 }
899 BinOp::DivEq(_binding_0) => {
900 BinOp::DivEq(Token ! [ /= ](tokens_helper(f, &_binding_0.spans)))
901 }
902 BinOp::RemEq(_binding_0) => {
903 BinOp::RemEq(Token ! [ %= ](tokens_helper(f, &_binding_0.spans)))
904 }
905 BinOp::BitXorEq(_binding_0) => {
906 BinOp::BitXorEq(Token ! [ ^= ](tokens_helper(f, &_binding_0.spans)))
907 }
908 BinOp::BitAndEq(_binding_0) => {
909 BinOp::BitAndEq(Token ! [ &= ](tokens_helper(f, &_binding_0.spans)))
910 }
911 BinOp::BitOrEq(_binding_0) => {
912 BinOp::BitOrEq(Token ! [ |= ](tokens_helper(f, &_binding_0.spans)))
913 }
914 BinOp::ShlEq(_binding_0) => {
915 BinOp::ShlEq(Token ! [ <<= ](tokens_helper(f, &_binding_0.spans)))
916 }
917 BinOp::ShrEq(_binding_0) => {
918 BinOp::ShrEq(Token ! [ >>= ](tokens_helper(f, &_binding_0.spans)))
919 }
920 }
921 }
922 #[cfg(any(feature = "derive", feature = "full"))]
fold_binding<F>(f: &mut F, node: Binding) -> Binding where F: Fold + ?Sized,923 pub fn fold_binding<F>(f: &mut F, node: Binding) -> Binding
924 where
925 F: Fold + ?Sized,
926 {
927 Binding {
928 ident: f.fold_ident(node.ident),
929 eq_token: Token ! [ = ](tokens_helper(f, &node.eq_token.spans)),
930 ty: f.fold_type(node.ty),
931 }
932 }
933 #[cfg(feature = "full")]
fold_block<F>(f: &mut F, node: Block) -> Block where F: Fold + ?Sized,934 pub fn fold_block<F>(f: &mut F, node: Block) -> Block
935 where
936 F: Fold + ?Sized,
937 {
938 Block {
939 brace_token: Brace(tokens_helper(f, &node.brace_token.span)),
940 stmts: FoldHelper::lift(node.stmts, |it| f.fold_stmt(it)),
941 }
942 }
943 #[cfg(any(feature = "derive", feature = "full"))]
fold_bound_lifetimes<F>(f: &mut F, node: BoundLifetimes) -> BoundLifetimes where F: Fold + ?Sized,944 pub fn fold_bound_lifetimes<F>(f: &mut F, node: BoundLifetimes) -> BoundLifetimes
945 where
946 F: Fold + ?Sized,
947 {
948 BoundLifetimes {
949 for_token: Token![for](tokens_helper(f, &node.for_token.span)),
950 lt_token: Token ! [ < ](tokens_helper(f, &node.lt_token.spans)),
951 lifetimes: FoldHelper::lift(node.lifetimes, |it| f.fold_lifetime_def(it)),
952 gt_token: Token ! [ > ](tokens_helper(f, &node.gt_token.spans)),
953 }
954 }
955 #[cfg(any(feature = "derive", feature = "full"))]
fold_const_param<F>(f: &mut F, node: ConstParam) -> ConstParam where F: Fold + ?Sized,956 pub fn fold_const_param<F>(f: &mut F, node: ConstParam) -> ConstParam
957 where
958 F: Fold + ?Sized,
959 {
960 ConstParam {
961 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
962 const_token: Token![const](tokens_helper(f, &node.const_token.span)),
963 ident: f.fold_ident(node.ident),
964 colon_token: Token ! [ : ](tokens_helper(f, &node.colon_token.spans)),
965 ty: f.fold_type(node.ty),
966 eq_token: (node.eq_token).map(|it| Token ! [ = ](tokens_helper(f, &it.spans))),
967 default: (node.default).map(|it| f.fold_expr(it)),
968 }
969 }
970 #[cfg(any(feature = "derive", feature = "full"))]
fold_constraint<F>(f: &mut F, node: Constraint) -> Constraint where F: Fold + ?Sized,971 pub fn fold_constraint<F>(f: &mut F, node: Constraint) -> Constraint
972 where
973 F: Fold + ?Sized,
974 {
975 Constraint {
976 ident: f.fold_ident(node.ident),
977 colon_token: Token ! [ : ](tokens_helper(f, &node.colon_token.spans)),
978 bounds: FoldHelper::lift(node.bounds, |it| f.fold_type_param_bound(it)),
979 }
980 }
981 #[cfg(feature = "derive")]
fold_data<F>(f: &mut F, node: Data) -> Data where F: Fold + ?Sized,982 pub fn fold_data<F>(f: &mut F, node: Data) -> Data
983 where
984 F: Fold + ?Sized,
985 {
986 match node {
987 Data::Struct(_binding_0) => Data::Struct(f.fold_data_struct(_binding_0)),
988 Data::Enum(_binding_0) => Data::Enum(f.fold_data_enum(_binding_0)),
989 Data::Union(_binding_0) => Data::Union(f.fold_data_union(_binding_0)),
990 }
991 }
992 #[cfg(feature = "derive")]
fold_data_enum<F>(f: &mut F, node: DataEnum) -> DataEnum where F: Fold + ?Sized,993 pub fn fold_data_enum<F>(f: &mut F, node: DataEnum) -> DataEnum
994 where
995 F: Fold + ?Sized,
996 {
997 DataEnum {
998 enum_token: Token![enum](tokens_helper(f, &node.enum_token.span)),
999 brace_token: Brace(tokens_helper(f, &node.brace_token.span)),
1000 variants: FoldHelper::lift(node.variants, |it| f.fold_variant(it)),
1001 }
1002 }
1003 #[cfg(feature = "derive")]
fold_data_struct<F>(f: &mut F, node: DataStruct) -> DataStruct where F: Fold + ?Sized,1004 pub fn fold_data_struct<F>(f: &mut F, node: DataStruct) -> DataStruct
1005 where
1006 F: Fold + ?Sized,
1007 {
1008 DataStruct {
1009 struct_token: Token![struct](tokens_helper(f, &node.struct_token.span)),
1010 fields: f.fold_fields(node.fields),
1011 semi_token: (node.semi_token).map(|it| Token ! [ ; ](tokens_helper(f, &it.spans))),
1012 }
1013 }
1014 #[cfg(feature = "derive")]
fold_data_union<F>(f: &mut F, node: DataUnion) -> DataUnion where F: Fold + ?Sized,1015 pub fn fold_data_union<F>(f: &mut F, node: DataUnion) -> DataUnion
1016 where
1017 F: Fold + ?Sized,
1018 {
1019 DataUnion {
1020 union_token: Token![union](tokens_helper(f, &node.union_token.span)),
1021 fields: f.fold_fields_named(node.fields),
1022 }
1023 }
1024 #[cfg(feature = "derive")]
fold_derive_input<F>(f: &mut F, node: DeriveInput) -> DeriveInput where F: Fold + ?Sized,1025 pub fn fold_derive_input<F>(f: &mut F, node: DeriveInput) -> DeriveInput
1026 where
1027 F: Fold + ?Sized,
1028 {
1029 DeriveInput {
1030 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1031 vis: f.fold_visibility(node.vis),
1032 ident: f.fold_ident(node.ident),
1033 generics: f.fold_generics(node.generics),
1034 data: f.fold_data(node.data),
1035 }
1036 }
1037 #[cfg(any(feature = "derive", feature = "full"))]
fold_expr<F>(f: &mut F, node: Expr) -> Expr where F: Fold + ?Sized,1038 pub fn fold_expr<F>(f: &mut F, node: Expr) -> Expr
1039 where
1040 F: Fold + ?Sized,
1041 {
1042 match node {
1043 Expr::Array(_binding_0) => Expr::Array(full!(f.fold_expr_array(_binding_0))),
1044 Expr::Assign(_binding_0) => Expr::Assign(full!(f.fold_expr_assign(_binding_0))),
1045 Expr::AssignOp(_binding_0) => Expr::AssignOp(full!(f.fold_expr_assign_op(_binding_0))),
1046 Expr::Async(_binding_0) => Expr::Async(full!(f.fold_expr_async(_binding_0))),
1047 Expr::Await(_binding_0) => Expr::Await(full!(f.fold_expr_await(_binding_0))),
1048 Expr::Binary(_binding_0) => Expr::Binary(f.fold_expr_binary(_binding_0)),
1049 Expr::Block(_binding_0) => Expr::Block(full!(f.fold_expr_block(_binding_0))),
1050 Expr::Box(_binding_0) => Expr::Box(full!(f.fold_expr_box(_binding_0))),
1051 Expr::Break(_binding_0) => Expr::Break(full!(f.fold_expr_break(_binding_0))),
1052 Expr::Call(_binding_0) => Expr::Call(f.fold_expr_call(_binding_0)),
1053 Expr::Cast(_binding_0) => Expr::Cast(f.fold_expr_cast(_binding_0)),
1054 Expr::Closure(_binding_0) => Expr::Closure(full!(f.fold_expr_closure(_binding_0))),
1055 Expr::Continue(_binding_0) => Expr::Continue(full!(f.fold_expr_continue(_binding_0))),
1056 Expr::Field(_binding_0) => Expr::Field(f.fold_expr_field(_binding_0)),
1057 Expr::ForLoop(_binding_0) => Expr::ForLoop(full!(f.fold_expr_for_loop(_binding_0))),
1058 Expr::Group(_binding_0) => Expr::Group(full!(f.fold_expr_group(_binding_0))),
1059 Expr::If(_binding_0) => Expr::If(full!(f.fold_expr_if(_binding_0))),
1060 Expr::Index(_binding_0) => Expr::Index(f.fold_expr_index(_binding_0)),
1061 Expr::Let(_binding_0) => Expr::Let(full!(f.fold_expr_let(_binding_0))),
1062 Expr::Lit(_binding_0) => Expr::Lit(f.fold_expr_lit(_binding_0)),
1063 Expr::Loop(_binding_0) => Expr::Loop(full!(f.fold_expr_loop(_binding_0))),
1064 Expr::Macro(_binding_0) => Expr::Macro(full!(f.fold_expr_macro(_binding_0))),
1065 Expr::Match(_binding_0) => Expr::Match(full!(f.fold_expr_match(_binding_0))),
1066 Expr::MethodCall(_binding_0) => {
1067 Expr::MethodCall(full!(f.fold_expr_method_call(_binding_0)))
1068 }
1069 Expr::Paren(_binding_0) => Expr::Paren(f.fold_expr_paren(_binding_0)),
1070 Expr::Path(_binding_0) => Expr::Path(f.fold_expr_path(_binding_0)),
1071 Expr::Range(_binding_0) => Expr::Range(full!(f.fold_expr_range(_binding_0))),
1072 Expr::Reference(_binding_0) => Expr::Reference(full!(f.fold_expr_reference(_binding_0))),
1073 Expr::Repeat(_binding_0) => Expr::Repeat(full!(f.fold_expr_repeat(_binding_0))),
1074 Expr::Return(_binding_0) => Expr::Return(full!(f.fold_expr_return(_binding_0))),
1075 Expr::Struct(_binding_0) => Expr::Struct(full!(f.fold_expr_struct(_binding_0))),
1076 Expr::Try(_binding_0) => Expr::Try(full!(f.fold_expr_try(_binding_0))),
1077 Expr::TryBlock(_binding_0) => Expr::TryBlock(full!(f.fold_expr_try_block(_binding_0))),
1078 Expr::Tuple(_binding_0) => Expr::Tuple(full!(f.fold_expr_tuple(_binding_0))),
1079 Expr::Type(_binding_0) => Expr::Type(full!(f.fold_expr_type(_binding_0))),
1080 Expr::Unary(_binding_0) => Expr::Unary(f.fold_expr_unary(_binding_0)),
1081 Expr::Unsafe(_binding_0) => Expr::Unsafe(full!(f.fold_expr_unsafe(_binding_0))),
1082 Expr::Verbatim(_binding_0) => Expr::Verbatim(_binding_0),
1083 Expr::While(_binding_0) => Expr::While(full!(f.fold_expr_while(_binding_0))),
1084 Expr::Yield(_binding_0) => Expr::Yield(full!(f.fold_expr_yield(_binding_0))),
1085 _ => unreachable!(),
1086 }
1087 }
1088 #[cfg(feature = "full")]
fold_expr_array<F>(f: &mut F, node: ExprArray) -> ExprArray where F: Fold + ?Sized,1089 pub fn fold_expr_array<F>(f: &mut F, node: ExprArray) -> ExprArray
1090 where
1091 F: Fold + ?Sized,
1092 {
1093 ExprArray {
1094 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1095 bracket_token: Bracket(tokens_helper(f, &node.bracket_token.span)),
1096 elems: FoldHelper::lift(node.elems, |it| f.fold_expr(it)),
1097 }
1098 }
1099 #[cfg(feature = "full")]
fold_expr_assign<F>(f: &mut F, node: ExprAssign) -> ExprAssign where F: Fold + ?Sized,1100 pub fn fold_expr_assign<F>(f: &mut F, node: ExprAssign) -> ExprAssign
1101 where
1102 F: Fold + ?Sized,
1103 {
1104 ExprAssign {
1105 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1106 left: Box::new(f.fold_expr(*node.left)),
1107 eq_token: Token ! [ = ](tokens_helper(f, &node.eq_token.spans)),
1108 right: Box::new(f.fold_expr(*node.right)),
1109 }
1110 }
1111 #[cfg(feature = "full")]
fold_expr_assign_op<F>(f: &mut F, node: ExprAssignOp) -> ExprAssignOp where F: Fold + ?Sized,1112 pub fn fold_expr_assign_op<F>(f: &mut F, node: ExprAssignOp) -> ExprAssignOp
1113 where
1114 F: Fold + ?Sized,
1115 {
1116 ExprAssignOp {
1117 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1118 left: Box::new(f.fold_expr(*node.left)),
1119 op: f.fold_bin_op(node.op),
1120 right: Box::new(f.fold_expr(*node.right)),
1121 }
1122 }
1123 #[cfg(feature = "full")]
fold_expr_async<F>(f: &mut F, node: ExprAsync) -> ExprAsync where F: Fold + ?Sized,1124 pub fn fold_expr_async<F>(f: &mut F, node: ExprAsync) -> ExprAsync
1125 where
1126 F: Fold + ?Sized,
1127 {
1128 ExprAsync {
1129 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1130 async_token: Token![async](tokens_helper(f, &node.async_token.span)),
1131 capture: (node.capture).map(|it| Token![move](tokens_helper(f, &it.span))),
1132 block: f.fold_block(node.block),
1133 }
1134 }
1135 #[cfg(feature = "full")]
fold_expr_await<F>(f: &mut F, node: ExprAwait) -> ExprAwait where F: Fold + ?Sized,1136 pub fn fold_expr_await<F>(f: &mut F, node: ExprAwait) -> ExprAwait
1137 where
1138 F: Fold + ?Sized,
1139 {
1140 ExprAwait {
1141 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1142 base: Box::new(f.fold_expr(*node.base)),
1143 dot_token: Token ! [ . ](tokens_helper(f, &node.dot_token.spans)),
1144 await_token: crate::token::Await(tokens_helper(f, &node.await_token.span)),
1145 }
1146 }
1147 #[cfg(any(feature = "derive", feature = "full"))]
fold_expr_binary<F>(f: &mut F, node: ExprBinary) -> ExprBinary where F: Fold + ?Sized,1148 pub fn fold_expr_binary<F>(f: &mut F, node: ExprBinary) -> ExprBinary
1149 where
1150 F: Fold + ?Sized,
1151 {
1152 ExprBinary {
1153 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1154 left: Box::new(f.fold_expr(*node.left)),
1155 op: f.fold_bin_op(node.op),
1156 right: Box::new(f.fold_expr(*node.right)),
1157 }
1158 }
1159 #[cfg(feature = "full")]
fold_expr_block<F>(f: &mut F, node: ExprBlock) -> ExprBlock where F: Fold + ?Sized,1160 pub fn fold_expr_block<F>(f: &mut F, node: ExprBlock) -> ExprBlock
1161 where
1162 F: Fold + ?Sized,
1163 {
1164 ExprBlock {
1165 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1166 label: (node.label).map(|it| f.fold_label(it)),
1167 block: f.fold_block(node.block),
1168 }
1169 }
1170 #[cfg(feature = "full")]
fold_expr_box<F>(f: &mut F, node: ExprBox) -> ExprBox where F: Fold + ?Sized,1171 pub fn fold_expr_box<F>(f: &mut F, node: ExprBox) -> ExprBox
1172 where
1173 F: Fold + ?Sized,
1174 {
1175 ExprBox {
1176 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1177 box_token: Token![box](tokens_helper(f, &node.box_token.span)),
1178 expr: Box::new(f.fold_expr(*node.expr)),
1179 }
1180 }
1181 #[cfg(feature = "full")]
fold_expr_break<F>(f: &mut F, node: ExprBreak) -> ExprBreak where F: Fold + ?Sized,1182 pub fn fold_expr_break<F>(f: &mut F, node: ExprBreak) -> ExprBreak
1183 where
1184 F: Fold + ?Sized,
1185 {
1186 ExprBreak {
1187 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1188 break_token: Token![break](tokens_helper(f, &node.break_token.span)),
1189 label: (node.label).map(|it| f.fold_lifetime(it)),
1190 expr: (node.expr).map(|it| Box::new(f.fold_expr(*it))),
1191 }
1192 }
1193 #[cfg(any(feature = "derive", feature = "full"))]
fold_expr_call<F>(f: &mut F, node: ExprCall) -> ExprCall where F: Fold + ?Sized,1194 pub fn fold_expr_call<F>(f: &mut F, node: ExprCall) -> ExprCall
1195 where
1196 F: Fold + ?Sized,
1197 {
1198 ExprCall {
1199 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1200 func: Box::new(f.fold_expr(*node.func)),
1201 paren_token: Paren(tokens_helper(f, &node.paren_token.span)),
1202 args: FoldHelper::lift(node.args, |it| f.fold_expr(it)),
1203 }
1204 }
1205 #[cfg(any(feature = "derive", feature = "full"))]
fold_expr_cast<F>(f: &mut F, node: ExprCast) -> ExprCast where F: Fold + ?Sized,1206 pub fn fold_expr_cast<F>(f: &mut F, node: ExprCast) -> ExprCast
1207 where
1208 F: Fold + ?Sized,
1209 {
1210 ExprCast {
1211 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1212 expr: Box::new(f.fold_expr(*node.expr)),
1213 as_token: Token![as](tokens_helper(f, &node.as_token.span)),
1214 ty: Box::new(f.fold_type(*node.ty)),
1215 }
1216 }
1217 #[cfg(feature = "full")]
fold_expr_closure<F>(f: &mut F, node: ExprClosure) -> ExprClosure where F: Fold + ?Sized,1218 pub fn fold_expr_closure<F>(f: &mut F, node: ExprClosure) -> ExprClosure
1219 where
1220 F: Fold + ?Sized,
1221 {
1222 ExprClosure {
1223 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1224 asyncness: (node.asyncness).map(|it| Token![async](tokens_helper(f, &it.span))),
1225 movability: (node.movability).map(|it| Token![static](tokens_helper(f, &it.span))),
1226 capture: (node.capture).map(|it| Token![move](tokens_helper(f, &it.span))),
1227 or1_token: Token ! [ | ](tokens_helper(f, &node.or1_token.spans)),
1228 inputs: FoldHelper::lift(node.inputs, |it| f.fold_pat(it)),
1229 or2_token: Token ! [ | ](tokens_helper(f, &node.or2_token.spans)),
1230 output: f.fold_return_type(node.output),
1231 body: Box::new(f.fold_expr(*node.body)),
1232 }
1233 }
1234 #[cfg(feature = "full")]
fold_expr_continue<F>(f: &mut F, node: ExprContinue) -> ExprContinue where F: Fold + ?Sized,1235 pub fn fold_expr_continue<F>(f: &mut F, node: ExprContinue) -> ExprContinue
1236 where
1237 F: Fold + ?Sized,
1238 {
1239 ExprContinue {
1240 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1241 continue_token: Token![continue](tokens_helper(f, &node.continue_token.span)),
1242 label: (node.label).map(|it| f.fold_lifetime(it)),
1243 }
1244 }
1245 #[cfg(any(feature = "derive", feature = "full"))]
fold_expr_field<F>(f: &mut F, node: ExprField) -> ExprField where F: Fold + ?Sized,1246 pub fn fold_expr_field<F>(f: &mut F, node: ExprField) -> ExprField
1247 where
1248 F: Fold + ?Sized,
1249 {
1250 ExprField {
1251 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1252 base: Box::new(f.fold_expr(*node.base)),
1253 dot_token: Token ! [ . ](tokens_helper(f, &node.dot_token.spans)),
1254 member: f.fold_member(node.member),
1255 }
1256 }
1257 #[cfg(feature = "full")]
fold_expr_for_loop<F>(f: &mut F, node: ExprForLoop) -> ExprForLoop where F: Fold + ?Sized,1258 pub fn fold_expr_for_loop<F>(f: &mut F, node: ExprForLoop) -> ExprForLoop
1259 where
1260 F: Fold + ?Sized,
1261 {
1262 ExprForLoop {
1263 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1264 label: (node.label).map(|it| f.fold_label(it)),
1265 for_token: Token![for](tokens_helper(f, &node.for_token.span)),
1266 pat: f.fold_pat(node.pat),
1267 in_token: Token![in](tokens_helper(f, &node.in_token.span)),
1268 expr: Box::new(f.fold_expr(*node.expr)),
1269 body: f.fold_block(node.body),
1270 }
1271 }
1272 #[cfg(feature = "full")]
fold_expr_group<F>(f: &mut F, node: ExprGroup) -> ExprGroup where F: Fold + ?Sized,1273 pub fn fold_expr_group<F>(f: &mut F, node: ExprGroup) -> ExprGroup
1274 where
1275 F: Fold + ?Sized,
1276 {
1277 ExprGroup {
1278 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1279 group_token: Group(tokens_helper(f, &node.group_token.span)),
1280 expr: Box::new(f.fold_expr(*node.expr)),
1281 }
1282 }
1283 #[cfg(feature = "full")]
fold_expr_if<F>(f: &mut F, node: ExprIf) -> ExprIf where F: Fold + ?Sized,1284 pub fn fold_expr_if<F>(f: &mut F, node: ExprIf) -> ExprIf
1285 where
1286 F: Fold + ?Sized,
1287 {
1288 ExprIf {
1289 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1290 if_token: Token![if](tokens_helper(f, &node.if_token.span)),
1291 cond: Box::new(f.fold_expr(*node.cond)),
1292 then_branch: f.fold_block(node.then_branch),
1293 else_branch: (node.else_branch).map(|it| {
1294 (
1295 Token![else](tokens_helper(f, &(it).0.span)),
1296 Box::new(f.fold_expr(*(it).1)),
1297 )
1298 }),
1299 }
1300 }
1301 #[cfg(any(feature = "derive", feature = "full"))]
fold_expr_index<F>(f: &mut F, node: ExprIndex) -> ExprIndex where F: Fold + ?Sized,1302 pub fn fold_expr_index<F>(f: &mut F, node: ExprIndex) -> ExprIndex
1303 where
1304 F: Fold + ?Sized,
1305 {
1306 ExprIndex {
1307 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1308 expr: Box::new(f.fold_expr(*node.expr)),
1309 bracket_token: Bracket(tokens_helper(f, &node.bracket_token.span)),
1310 index: Box::new(f.fold_expr(*node.index)),
1311 }
1312 }
1313 #[cfg(feature = "full")]
fold_expr_let<F>(f: &mut F, node: ExprLet) -> ExprLet where F: Fold + ?Sized,1314 pub fn fold_expr_let<F>(f: &mut F, node: ExprLet) -> ExprLet
1315 where
1316 F: Fold + ?Sized,
1317 {
1318 ExprLet {
1319 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1320 let_token: Token![let](tokens_helper(f, &node.let_token.span)),
1321 pat: f.fold_pat(node.pat),
1322 eq_token: Token ! [ = ](tokens_helper(f, &node.eq_token.spans)),
1323 expr: Box::new(f.fold_expr(*node.expr)),
1324 }
1325 }
1326 #[cfg(any(feature = "derive", feature = "full"))]
fold_expr_lit<F>(f: &mut F, node: ExprLit) -> ExprLit where F: Fold + ?Sized,1327 pub fn fold_expr_lit<F>(f: &mut F, node: ExprLit) -> ExprLit
1328 where
1329 F: Fold + ?Sized,
1330 {
1331 ExprLit {
1332 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1333 lit: f.fold_lit(node.lit),
1334 }
1335 }
1336 #[cfg(feature = "full")]
fold_expr_loop<F>(f: &mut F, node: ExprLoop) -> ExprLoop where F: Fold + ?Sized,1337 pub fn fold_expr_loop<F>(f: &mut F, node: ExprLoop) -> ExprLoop
1338 where
1339 F: Fold + ?Sized,
1340 {
1341 ExprLoop {
1342 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1343 label: (node.label).map(|it| f.fold_label(it)),
1344 loop_token: Token![loop](tokens_helper(f, &node.loop_token.span)),
1345 body: f.fold_block(node.body),
1346 }
1347 }
1348 #[cfg(feature = "full")]
fold_expr_macro<F>(f: &mut F, node: ExprMacro) -> ExprMacro where F: Fold + ?Sized,1349 pub fn fold_expr_macro<F>(f: &mut F, node: ExprMacro) -> ExprMacro
1350 where
1351 F: Fold + ?Sized,
1352 {
1353 ExprMacro {
1354 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1355 mac: f.fold_macro(node.mac),
1356 }
1357 }
1358 #[cfg(feature = "full")]
fold_expr_match<F>(f: &mut F, node: ExprMatch) -> ExprMatch where F: Fold + ?Sized,1359 pub fn fold_expr_match<F>(f: &mut F, node: ExprMatch) -> ExprMatch
1360 where
1361 F: Fold + ?Sized,
1362 {
1363 ExprMatch {
1364 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1365 match_token: Token![match](tokens_helper(f, &node.match_token.span)),
1366 expr: Box::new(f.fold_expr(*node.expr)),
1367 brace_token: Brace(tokens_helper(f, &node.brace_token.span)),
1368 arms: FoldHelper::lift(node.arms, |it| f.fold_arm(it)),
1369 }
1370 }
1371 #[cfg(feature = "full")]
fold_expr_method_call<F>(f: &mut F, node: ExprMethodCall) -> ExprMethodCall where F: Fold + ?Sized,1372 pub fn fold_expr_method_call<F>(f: &mut F, node: ExprMethodCall) -> ExprMethodCall
1373 where
1374 F: Fold + ?Sized,
1375 {
1376 ExprMethodCall {
1377 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1378 receiver: Box::new(f.fold_expr(*node.receiver)),
1379 dot_token: Token ! [ . ](tokens_helper(f, &node.dot_token.spans)),
1380 method: f.fold_ident(node.method),
1381 turbofish: (node.turbofish).map(|it| f.fold_method_turbofish(it)),
1382 paren_token: Paren(tokens_helper(f, &node.paren_token.span)),
1383 args: FoldHelper::lift(node.args, |it| f.fold_expr(it)),
1384 }
1385 }
1386 #[cfg(any(feature = "derive", feature = "full"))]
fold_expr_paren<F>(f: &mut F, node: ExprParen) -> ExprParen where F: Fold + ?Sized,1387 pub fn fold_expr_paren<F>(f: &mut F, node: ExprParen) -> ExprParen
1388 where
1389 F: Fold + ?Sized,
1390 {
1391 ExprParen {
1392 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1393 paren_token: Paren(tokens_helper(f, &node.paren_token.span)),
1394 expr: Box::new(f.fold_expr(*node.expr)),
1395 }
1396 }
1397 #[cfg(any(feature = "derive", feature = "full"))]
fold_expr_path<F>(f: &mut F, node: ExprPath) -> ExprPath where F: Fold + ?Sized,1398 pub fn fold_expr_path<F>(f: &mut F, node: ExprPath) -> ExprPath
1399 where
1400 F: Fold + ?Sized,
1401 {
1402 ExprPath {
1403 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1404 qself: (node.qself).map(|it| f.fold_qself(it)),
1405 path: f.fold_path(node.path),
1406 }
1407 }
1408 #[cfg(feature = "full")]
fold_expr_range<F>(f: &mut F, node: ExprRange) -> ExprRange where F: Fold + ?Sized,1409 pub fn fold_expr_range<F>(f: &mut F, node: ExprRange) -> ExprRange
1410 where
1411 F: Fold + ?Sized,
1412 {
1413 ExprRange {
1414 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1415 from: (node.from).map(|it| Box::new(f.fold_expr(*it))),
1416 limits: f.fold_range_limits(node.limits),
1417 to: (node.to).map(|it| Box::new(f.fold_expr(*it))),
1418 }
1419 }
1420 #[cfg(feature = "full")]
fold_expr_reference<F>(f: &mut F, node: ExprReference) -> ExprReference where F: Fold + ?Sized,1421 pub fn fold_expr_reference<F>(f: &mut F, node: ExprReference) -> ExprReference
1422 where
1423 F: Fold + ?Sized,
1424 {
1425 ExprReference {
1426 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1427 and_token: Token ! [ & ](tokens_helper(f, &node.and_token.spans)),
1428 raw: node.raw,
1429 mutability: (node.mutability).map(|it| Token![mut](tokens_helper(f, &it.span))),
1430 expr: Box::new(f.fold_expr(*node.expr)),
1431 }
1432 }
1433 #[cfg(feature = "full")]
fold_expr_repeat<F>(f: &mut F, node: ExprRepeat) -> ExprRepeat where F: Fold + ?Sized,1434 pub fn fold_expr_repeat<F>(f: &mut F, node: ExprRepeat) -> ExprRepeat
1435 where
1436 F: Fold + ?Sized,
1437 {
1438 ExprRepeat {
1439 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1440 bracket_token: Bracket(tokens_helper(f, &node.bracket_token.span)),
1441 expr: Box::new(f.fold_expr(*node.expr)),
1442 semi_token: Token ! [ ; ](tokens_helper(f, &node.semi_token.spans)),
1443 len: Box::new(f.fold_expr(*node.len)),
1444 }
1445 }
1446 #[cfg(feature = "full")]
fold_expr_return<F>(f: &mut F, node: ExprReturn) -> ExprReturn where F: Fold + ?Sized,1447 pub fn fold_expr_return<F>(f: &mut F, node: ExprReturn) -> ExprReturn
1448 where
1449 F: Fold + ?Sized,
1450 {
1451 ExprReturn {
1452 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1453 return_token: Token![return](tokens_helper(f, &node.return_token.span)),
1454 expr: (node.expr).map(|it| Box::new(f.fold_expr(*it))),
1455 }
1456 }
1457 #[cfg(feature = "full")]
fold_expr_struct<F>(f: &mut F, node: ExprStruct) -> ExprStruct where F: Fold + ?Sized,1458 pub fn fold_expr_struct<F>(f: &mut F, node: ExprStruct) -> ExprStruct
1459 where
1460 F: Fold + ?Sized,
1461 {
1462 ExprStruct {
1463 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1464 path: f.fold_path(node.path),
1465 brace_token: Brace(tokens_helper(f, &node.brace_token.span)),
1466 fields: FoldHelper::lift(node.fields, |it| f.fold_field_value(it)),
1467 dot2_token: (node.dot2_token).map(|it| Token![..](tokens_helper(f, &it.spans))),
1468 rest: (node.rest).map(|it| Box::new(f.fold_expr(*it))),
1469 }
1470 }
1471 #[cfg(feature = "full")]
fold_expr_try<F>(f: &mut F, node: ExprTry) -> ExprTry where F: Fold + ?Sized,1472 pub fn fold_expr_try<F>(f: &mut F, node: ExprTry) -> ExprTry
1473 where
1474 F: Fold + ?Sized,
1475 {
1476 ExprTry {
1477 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1478 expr: Box::new(f.fold_expr(*node.expr)),
1479 question_token: Token ! [ ? ](tokens_helper(f, &node.question_token.spans)),
1480 }
1481 }
1482 #[cfg(feature = "full")]
fold_expr_try_block<F>(f: &mut F, node: ExprTryBlock) -> ExprTryBlock where F: Fold + ?Sized,1483 pub fn fold_expr_try_block<F>(f: &mut F, node: ExprTryBlock) -> ExprTryBlock
1484 where
1485 F: Fold + ?Sized,
1486 {
1487 ExprTryBlock {
1488 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1489 try_token: Token![try](tokens_helper(f, &node.try_token.span)),
1490 block: f.fold_block(node.block),
1491 }
1492 }
1493 #[cfg(feature = "full")]
fold_expr_tuple<F>(f: &mut F, node: ExprTuple) -> ExprTuple where F: Fold + ?Sized,1494 pub fn fold_expr_tuple<F>(f: &mut F, node: ExprTuple) -> ExprTuple
1495 where
1496 F: Fold + ?Sized,
1497 {
1498 ExprTuple {
1499 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1500 paren_token: Paren(tokens_helper(f, &node.paren_token.span)),
1501 elems: FoldHelper::lift(node.elems, |it| f.fold_expr(it)),
1502 }
1503 }
1504 #[cfg(feature = "full")]
fold_expr_type<F>(f: &mut F, node: ExprType) -> ExprType where F: Fold + ?Sized,1505 pub fn fold_expr_type<F>(f: &mut F, node: ExprType) -> ExprType
1506 where
1507 F: Fold + ?Sized,
1508 {
1509 ExprType {
1510 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1511 expr: Box::new(f.fold_expr(*node.expr)),
1512 colon_token: Token ! [ : ](tokens_helper(f, &node.colon_token.spans)),
1513 ty: Box::new(f.fold_type(*node.ty)),
1514 }
1515 }
1516 #[cfg(any(feature = "derive", feature = "full"))]
fold_expr_unary<F>(f: &mut F, node: ExprUnary) -> ExprUnary where F: Fold + ?Sized,1517 pub fn fold_expr_unary<F>(f: &mut F, node: ExprUnary) -> ExprUnary
1518 where
1519 F: Fold + ?Sized,
1520 {
1521 ExprUnary {
1522 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1523 op: f.fold_un_op(node.op),
1524 expr: Box::new(f.fold_expr(*node.expr)),
1525 }
1526 }
1527 #[cfg(feature = "full")]
fold_expr_unsafe<F>(f: &mut F, node: ExprUnsafe) -> ExprUnsafe where F: Fold + ?Sized,1528 pub fn fold_expr_unsafe<F>(f: &mut F, node: ExprUnsafe) -> ExprUnsafe
1529 where
1530 F: Fold + ?Sized,
1531 {
1532 ExprUnsafe {
1533 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1534 unsafe_token: Token![unsafe](tokens_helper(f, &node.unsafe_token.span)),
1535 block: f.fold_block(node.block),
1536 }
1537 }
1538 #[cfg(feature = "full")]
fold_expr_while<F>(f: &mut F, node: ExprWhile) -> ExprWhile where F: Fold + ?Sized,1539 pub fn fold_expr_while<F>(f: &mut F, node: ExprWhile) -> ExprWhile
1540 where
1541 F: Fold + ?Sized,
1542 {
1543 ExprWhile {
1544 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1545 label: (node.label).map(|it| f.fold_label(it)),
1546 while_token: Token![while](tokens_helper(f, &node.while_token.span)),
1547 cond: Box::new(f.fold_expr(*node.cond)),
1548 body: f.fold_block(node.body),
1549 }
1550 }
1551 #[cfg(feature = "full")]
fold_expr_yield<F>(f: &mut F, node: ExprYield) -> ExprYield where F: Fold + ?Sized,1552 pub fn fold_expr_yield<F>(f: &mut F, node: ExprYield) -> ExprYield
1553 where
1554 F: Fold + ?Sized,
1555 {
1556 ExprYield {
1557 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1558 yield_token: Token![yield](tokens_helper(f, &node.yield_token.span)),
1559 expr: (node.expr).map(|it| Box::new(f.fold_expr(*it))),
1560 }
1561 }
1562 #[cfg(any(feature = "derive", feature = "full"))]
fold_field<F>(f: &mut F, node: Field) -> Field where F: Fold + ?Sized,1563 pub fn fold_field<F>(f: &mut F, node: Field) -> Field
1564 where
1565 F: Fold + ?Sized,
1566 {
1567 Field {
1568 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1569 vis: f.fold_visibility(node.vis),
1570 ident: (node.ident).map(|it| f.fold_ident(it)),
1571 colon_token: (node.colon_token).map(|it| Token ! [ : ](tokens_helper(f, &it.spans))),
1572 ty: f.fold_type(node.ty),
1573 }
1574 }
1575 #[cfg(feature = "full")]
fold_field_pat<F>(f: &mut F, node: FieldPat) -> FieldPat where F: Fold + ?Sized,1576 pub fn fold_field_pat<F>(f: &mut F, node: FieldPat) -> FieldPat
1577 where
1578 F: Fold + ?Sized,
1579 {
1580 FieldPat {
1581 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1582 member: f.fold_member(node.member),
1583 colon_token: (node.colon_token).map(|it| Token ! [ : ](tokens_helper(f, &it.spans))),
1584 pat: Box::new(f.fold_pat(*node.pat)),
1585 }
1586 }
1587 #[cfg(feature = "full")]
fold_field_value<F>(f: &mut F, node: FieldValue) -> FieldValue where F: Fold + ?Sized,1588 pub fn fold_field_value<F>(f: &mut F, node: FieldValue) -> FieldValue
1589 where
1590 F: Fold + ?Sized,
1591 {
1592 FieldValue {
1593 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1594 member: f.fold_member(node.member),
1595 colon_token: (node.colon_token).map(|it| Token ! [ : ](tokens_helper(f, &it.spans))),
1596 expr: f.fold_expr(node.expr),
1597 }
1598 }
1599 #[cfg(any(feature = "derive", feature = "full"))]
fold_fields<F>(f: &mut F, node: Fields) -> Fields where F: Fold + ?Sized,1600 pub fn fold_fields<F>(f: &mut F, node: Fields) -> Fields
1601 where
1602 F: Fold + ?Sized,
1603 {
1604 match node {
1605 Fields::Named(_binding_0) => Fields::Named(f.fold_fields_named(_binding_0)),
1606 Fields::Unnamed(_binding_0) => Fields::Unnamed(f.fold_fields_unnamed(_binding_0)),
1607 Fields::Unit => Fields::Unit,
1608 }
1609 }
1610 #[cfg(any(feature = "derive", feature = "full"))]
fold_fields_named<F>(f: &mut F, node: FieldsNamed) -> FieldsNamed where F: Fold + ?Sized,1611 pub fn fold_fields_named<F>(f: &mut F, node: FieldsNamed) -> FieldsNamed
1612 where
1613 F: Fold + ?Sized,
1614 {
1615 FieldsNamed {
1616 brace_token: Brace(tokens_helper(f, &node.brace_token.span)),
1617 named: FoldHelper::lift(node.named, |it| f.fold_field(it)),
1618 }
1619 }
1620 #[cfg(any(feature = "derive", feature = "full"))]
fold_fields_unnamed<F>(f: &mut F, node: FieldsUnnamed) -> FieldsUnnamed where F: Fold + ?Sized,1621 pub fn fold_fields_unnamed<F>(f: &mut F, node: FieldsUnnamed) -> FieldsUnnamed
1622 where
1623 F: Fold + ?Sized,
1624 {
1625 FieldsUnnamed {
1626 paren_token: Paren(tokens_helper(f, &node.paren_token.span)),
1627 unnamed: FoldHelper::lift(node.unnamed, |it| f.fold_field(it)),
1628 }
1629 }
1630 #[cfg(feature = "full")]
fold_file<F>(f: &mut F, node: File) -> File where F: Fold + ?Sized,1631 pub fn fold_file<F>(f: &mut F, node: File) -> File
1632 where
1633 F: Fold + ?Sized,
1634 {
1635 File {
1636 shebang: node.shebang,
1637 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1638 items: FoldHelper::lift(node.items, |it| f.fold_item(it)),
1639 }
1640 }
1641 #[cfg(feature = "full")]
fold_fn_arg<F>(f: &mut F, node: FnArg) -> FnArg where F: Fold + ?Sized,1642 pub fn fold_fn_arg<F>(f: &mut F, node: FnArg) -> FnArg
1643 where
1644 F: Fold + ?Sized,
1645 {
1646 match node {
1647 FnArg::Receiver(_binding_0) => FnArg::Receiver(f.fold_receiver(_binding_0)),
1648 FnArg::Typed(_binding_0) => FnArg::Typed(f.fold_pat_type(_binding_0)),
1649 }
1650 }
1651 #[cfg(feature = "full")]
fold_foreign_item<F>(f: &mut F, node: ForeignItem) -> ForeignItem where F: Fold + ?Sized,1652 pub fn fold_foreign_item<F>(f: &mut F, node: ForeignItem) -> ForeignItem
1653 where
1654 F: Fold + ?Sized,
1655 {
1656 match node {
1657 ForeignItem::Fn(_binding_0) => ForeignItem::Fn(f.fold_foreign_item_fn(_binding_0)),
1658 ForeignItem::Static(_binding_0) => {
1659 ForeignItem::Static(f.fold_foreign_item_static(_binding_0))
1660 }
1661 ForeignItem::Type(_binding_0) => ForeignItem::Type(f.fold_foreign_item_type(_binding_0)),
1662 ForeignItem::Macro(_binding_0) => ForeignItem::Macro(f.fold_foreign_item_macro(_binding_0)),
1663 ForeignItem::Verbatim(_binding_0) => ForeignItem::Verbatim(_binding_0),
1664 _ => unreachable!(),
1665 }
1666 }
1667 #[cfg(feature = "full")]
fold_foreign_item_fn<F>(f: &mut F, node: ForeignItemFn) -> ForeignItemFn where F: Fold + ?Sized,1668 pub fn fold_foreign_item_fn<F>(f: &mut F, node: ForeignItemFn) -> ForeignItemFn
1669 where
1670 F: Fold + ?Sized,
1671 {
1672 ForeignItemFn {
1673 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1674 vis: f.fold_visibility(node.vis),
1675 sig: f.fold_signature(node.sig),
1676 semi_token: Token ! [ ; ](tokens_helper(f, &node.semi_token.spans)),
1677 }
1678 }
1679 #[cfg(feature = "full")]
fold_foreign_item_macro<F>(f: &mut F, node: ForeignItemMacro) -> ForeignItemMacro where F: Fold + ?Sized,1680 pub fn fold_foreign_item_macro<F>(f: &mut F, node: ForeignItemMacro) -> ForeignItemMacro
1681 where
1682 F: Fold + ?Sized,
1683 {
1684 ForeignItemMacro {
1685 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1686 mac: f.fold_macro(node.mac),
1687 semi_token: (node.semi_token).map(|it| Token ! [ ; ](tokens_helper(f, &it.spans))),
1688 }
1689 }
1690 #[cfg(feature = "full")]
fold_foreign_item_static<F>(f: &mut F, node: ForeignItemStatic) -> ForeignItemStatic where F: Fold + ?Sized,1691 pub fn fold_foreign_item_static<F>(f: &mut F, node: ForeignItemStatic) -> ForeignItemStatic
1692 where
1693 F: Fold + ?Sized,
1694 {
1695 ForeignItemStatic {
1696 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1697 vis: f.fold_visibility(node.vis),
1698 static_token: Token![static](tokens_helper(f, &node.static_token.span)),
1699 mutability: (node.mutability).map(|it| Token![mut](tokens_helper(f, &it.span))),
1700 ident: f.fold_ident(node.ident),
1701 colon_token: Token ! [ : ](tokens_helper(f, &node.colon_token.spans)),
1702 ty: Box::new(f.fold_type(*node.ty)),
1703 semi_token: Token ! [ ; ](tokens_helper(f, &node.semi_token.spans)),
1704 }
1705 }
1706 #[cfg(feature = "full")]
fold_foreign_item_type<F>(f: &mut F, node: ForeignItemType) -> ForeignItemType where F: Fold + ?Sized,1707 pub fn fold_foreign_item_type<F>(f: &mut F, node: ForeignItemType) -> ForeignItemType
1708 where
1709 F: Fold + ?Sized,
1710 {
1711 ForeignItemType {
1712 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1713 vis: f.fold_visibility(node.vis),
1714 type_token: Token![type](tokens_helper(f, &node.type_token.span)),
1715 ident: f.fold_ident(node.ident),
1716 semi_token: Token ! [ ; ](tokens_helper(f, &node.semi_token.spans)),
1717 }
1718 }
1719 #[cfg(any(feature = "derive", feature = "full"))]
fold_generic_argument<F>(f: &mut F, node: GenericArgument) -> GenericArgument where F: Fold + ?Sized,1720 pub fn fold_generic_argument<F>(f: &mut F, node: GenericArgument) -> GenericArgument
1721 where
1722 F: Fold + ?Sized,
1723 {
1724 match node {
1725 GenericArgument::Lifetime(_binding_0) => {
1726 GenericArgument::Lifetime(f.fold_lifetime(_binding_0))
1727 }
1728 GenericArgument::Type(_binding_0) => GenericArgument::Type(f.fold_type(_binding_0)),
1729 GenericArgument::Binding(_binding_0) => {
1730 GenericArgument::Binding(f.fold_binding(_binding_0))
1731 }
1732 GenericArgument::Constraint(_binding_0) => {
1733 GenericArgument::Constraint(f.fold_constraint(_binding_0))
1734 }
1735 GenericArgument::Const(_binding_0) => GenericArgument::Const(f.fold_expr(_binding_0)),
1736 }
1737 }
1738 #[cfg(feature = "full")]
fold_generic_method_argument<F>( f: &mut F, node: GenericMethodArgument, ) -> GenericMethodArgument where F: Fold + ?Sized,1739 pub fn fold_generic_method_argument<F>(
1740 f: &mut F,
1741 node: GenericMethodArgument,
1742 ) -> GenericMethodArgument
1743 where
1744 F: Fold + ?Sized,
1745 {
1746 match node {
1747 GenericMethodArgument::Type(_binding_0) => {
1748 GenericMethodArgument::Type(f.fold_type(_binding_0))
1749 }
1750 GenericMethodArgument::Const(_binding_0) => {
1751 GenericMethodArgument::Const(f.fold_expr(_binding_0))
1752 }
1753 }
1754 }
1755 #[cfg(any(feature = "derive", feature = "full"))]
fold_generic_param<F>(f: &mut F, node: GenericParam) -> GenericParam where F: Fold + ?Sized,1756 pub fn fold_generic_param<F>(f: &mut F, node: GenericParam) -> GenericParam
1757 where
1758 F: Fold + ?Sized,
1759 {
1760 match node {
1761 GenericParam::Type(_binding_0) => GenericParam::Type(f.fold_type_param(_binding_0)),
1762 GenericParam::Lifetime(_binding_0) => {
1763 GenericParam::Lifetime(f.fold_lifetime_def(_binding_0))
1764 }
1765 GenericParam::Const(_binding_0) => GenericParam::Const(f.fold_const_param(_binding_0)),
1766 }
1767 }
1768 #[cfg(any(feature = "derive", feature = "full"))]
fold_generics<F>(f: &mut F, node: Generics) -> Generics where F: Fold + ?Sized,1769 pub fn fold_generics<F>(f: &mut F, node: Generics) -> Generics
1770 where
1771 F: Fold + ?Sized,
1772 {
1773 Generics {
1774 lt_token: (node.lt_token).map(|it| Token ! [ < ](tokens_helper(f, &it.spans))),
1775 params: FoldHelper::lift(node.params, |it| f.fold_generic_param(it)),
1776 gt_token: (node.gt_token).map(|it| Token ! [ > ](tokens_helper(f, &it.spans))),
1777 where_clause: (node.where_clause).map(|it| f.fold_where_clause(it)),
1778 }
1779 }
fold_ident<F>(f: &mut F, node: Ident) -> Ident where F: Fold + ?Sized,1780 pub fn fold_ident<F>(f: &mut F, node: Ident) -> Ident
1781 where
1782 F: Fold + ?Sized,
1783 {
1784 let mut node = node;
1785 let span = f.fold_span(node.span());
1786 node.set_span(span);
1787 node
1788 }
1789 #[cfg(feature = "full")]
fold_impl_item<F>(f: &mut F, node: ImplItem) -> ImplItem where F: Fold + ?Sized,1790 pub fn fold_impl_item<F>(f: &mut F, node: ImplItem) -> ImplItem
1791 where
1792 F: Fold + ?Sized,
1793 {
1794 match node {
1795 ImplItem::Const(_binding_0) => ImplItem::Const(f.fold_impl_item_const(_binding_0)),
1796 ImplItem::Method(_binding_0) => ImplItem::Method(f.fold_impl_item_method(_binding_0)),
1797 ImplItem::Type(_binding_0) => ImplItem::Type(f.fold_impl_item_type(_binding_0)),
1798 ImplItem::Macro(_binding_0) => ImplItem::Macro(f.fold_impl_item_macro(_binding_0)),
1799 ImplItem::Verbatim(_binding_0) => ImplItem::Verbatim(_binding_0),
1800 _ => unreachable!(),
1801 }
1802 }
1803 #[cfg(feature = "full")]
fold_impl_item_const<F>(f: &mut F, node: ImplItemConst) -> ImplItemConst where F: Fold + ?Sized,1804 pub fn fold_impl_item_const<F>(f: &mut F, node: ImplItemConst) -> ImplItemConst
1805 where
1806 F: Fold + ?Sized,
1807 {
1808 ImplItemConst {
1809 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1810 vis: f.fold_visibility(node.vis),
1811 defaultness: (node.defaultness).map(|it| Token![default](tokens_helper(f, &it.span))),
1812 const_token: Token![const](tokens_helper(f, &node.const_token.span)),
1813 ident: f.fold_ident(node.ident),
1814 colon_token: Token ! [ : ](tokens_helper(f, &node.colon_token.spans)),
1815 ty: f.fold_type(node.ty),
1816 eq_token: Token ! [ = ](tokens_helper(f, &node.eq_token.spans)),
1817 expr: f.fold_expr(node.expr),
1818 semi_token: Token ! [ ; ](tokens_helper(f, &node.semi_token.spans)),
1819 }
1820 }
1821 #[cfg(feature = "full")]
fold_impl_item_macro<F>(f: &mut F, node: ImplItemMacro) -> ImplItemMacro where F: Fold + ?Sized,1822 pub fn fold_impl_item_macro<F>(f: &mut F, node: ImplItemMacro) -> ImplItemMacro
1823 where
1824 F: Fold + ?Sized,
1825 {
1826 ImplItemMacro {
1827 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1828 mac: f.fold_macro(node.mac),
1829 semi_token: (node.semi_token).map(|it| Token ! [ ; ](tokens_helper(f, &it.spans))),
1830 }
1831 }
1832 #[cfg(feature = "full")]
fold_impl_item_method<F>(f: &mut F, node: ImplItemMethod) -> ImplItemMethod where F: Fold + ?Sized,1833 pub fn fold_impl_item_method<F>(f: &mut F, node: ImplItemMethod) -> ImplItemMethod
1834 where
1835 F: Fold + ?Sized,
1836 {
1837 ImplItemMethod {
1838 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1839 vis: f.fold_visibility(node.vis),
1840 defaultness: (node.defaultness).map(|it| Token![default](tokens_helper(f, &it.span))),
1841 sig: f.fold_signature(node.sig),
1842 block: f.fold_block(node.block),
1843 }
1844 }
1845 #[cfg(feature = "full")]
fold_impl_item_type<F>(f: &mut F, node: ImplItemType) -> ImplItemType where F: Fold + ?Sized,1846 pub fn fold_impl_item_type<F>(f: &mut F, node: ImplItemType) -> ImplItemType
1847 where
1848 F: Fold + ?Sized,
1849 {
1850 ImplItemType {
1851 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1852 vis: f.fold_visibility(node.vis),
1853 defaultness: (node.defaultness).map(|it| Token![default](tokens_helper(f, &it.span))),
1854 type_token: Token![type](tokens_helper(f, &node.type_token.span)),
1855 ident: f.fold_ident(node.ident),
1856 generics: f.fold_generics(node.generics),
1857 eq_token: Token ! [ = ](tokens_helper(f, &node.eq_token.spans)),
1858 ty: f.fold_type(node.ty),
1859 semi_token: Token ! [ ; ](tokens_helper(f, &node.semi_token.spans)),
1860 }
1861 }
1862 #[cfg(any(feature = "derive", feature = "full"))]
fold_index<F>(f: &mut F, node: Index) -> Index where F: Fold + ?Sized,1863 pub fn fold_index<F>(f: &mut F, node: Index) -> Index
1864 where
1865 F: Fold + ?Sized,
1866 {
1867 Index {
1868 index: node.index,
1869 span: f.fold_span(node.span),
1870 }
1871 }
1872 #[cfg(feature = "full")]
fold_item<F>(f: &mut F, node: Item) -> Item where F: Fold + ?Sized,1873 pub fn fold_item<F>(f: &mut F, node: Item) -> Item
1874 where
1875 F: Fold + ?Sized,
1876 {
1877 match node {
1878 Item::Const(_binding_0) => Item::Const(f.fold_item_const(_binding_0)),
1879 Item::Enum(_binding_0) => Item::Enum(f.fold_item_enum(_binding_0)),
1880 Item::ExternCrate(_binding_0) => Item::ExternCrate(f.fold_item_extern_crate(_binding_0)),
1881 Item::Fn(_binding_0) => Item::Fn(f.fold_item_fn(_binding_0)),
1882 Item::ForeignMod(_binding_0) => Item::ForeignMod(f.fold_item_foreign_mod(_binding_0)),
1883 Item::Impl(_binding_0) => Item::Impl(f.fold_item_impl(_binding_0)),
1884 Item::Macro(_binding_0) => Item::Macro(f.fold_item_macro(_binding_0)),
1885 Item::Macro2(_binding_0) => Item::Macro2(f.fold_item_macro2(_binding_0)),
1886 Item::Mod(_binding_0) => Item::Mod(f.fold_item_mod(_binding_0)),
1887 Item::Static(_binding_0) => Item::Static(f.fold_item_static(_binding_0)),
1888 Item::Struct(_binding_0) => Item::Struct(f.fold_item_struct(_binding_0)),
1889 Item::Trait(_binding_0) => Item::Trait(f.fold_item_trait(_binding_0)),
1890 Item::TraitAlias(_binding_0) => Item::TraitAlias(f.fold_item_trait_alias(_binding_0)),
1891 Item::Type(_binding_0) => Item::Type(f.fold_item_type(_binding_0)),
1892 Item::Union(_binding_0) => Item::Union(f.fold_item_union(_binding_0)),
1893 Item::Use(_binding_0) => Item::Use(f.fold_item_use(_binding_0)),
1894 Item::Verbatim(_binding_0) => Item::Verbatim(_binding_0),
1895 _ => unreachable!(),
1896 }
1897 }
1898 #[cfg(feature = "full")]
fold_item_const<F>(f: &mut F, node: ItemConst) -> ItemConst where F: Fold + ?Sized,1899 pub fn fold_item_const<F>(f: &mut F, node: ItemConst) -> ItemConst
1900 where
1901 F: Fold + ?Sized,
1902 {
1903 ItemConst {
1904 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1905 vis: f.fold_visibility(node.vis),
1906 const_token: Token![const](tokens_helper(f, &node.const_token.span)),
1907 ident: f.fold_ident(node.ident),
1908 colon_token: Token ! [ : ](tokens_helper(f, &node.colon_token.spans)),
1909 ty: Box::new(f.fold_type(*node.ty)),
1910 eq_token: Token ! [ = ](tokens_helper(f, &node.eq_token.spans)),
1911 expr: Box::new(f.fold_expr(*node.expr)),
1912 semi_token: Token ! [ ; ](tokens_helper(f, &node.semi_token.spans)),
1913 }
1914 }
1915 #[cfg(feature = "full")]
fold_item_enum<F>(f: &mut F, node: ItemEnum) -> ItemEnum where F: Fold + ?Sized,1916 pub fn fold_item_enum<F>(f: &mut F, node: ItemEnum) -> ItemEnum
1917 where
1918 F: Fold + ?Sized,
1919 {
1920 ItemEnum {
1921 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1922 vis: f.fold_visibility(node.vis),
1923 enum_token: Token![enum](tokens_helper(f, &node.enum_token.span)),
1924 ident: f.fold_ident(node.ident),
1925 generics: f.fold_generics(node.generics),
1926 brace_token: Brace(tokens_helper(f, &node.brace_token.span)),
1927 variants: FoldHelper::lift(node.variants, |it| f.fold_variant(it)),
1928 }
1929 }
1930 #[cfg(feature = "full")]
fold_item_extern_crate<F>(f: &mut F, node: ItemExternCrate) -> ItemExternCrate where F: Fold + ?Sized,1931 pub fn fold_item_extern_crate<F>(f: &mut F, node: ItemExternCrate) -> ItemExternCrate
1932 where
1933 F: Fold + ?Sized,
1934 {
1935 ItemExternCrate {
1936 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1937 vis: f.fold_visibility(node.vis),
1938 extern_token: Token![extern](tokens_helper(f, &node.extern_token.span)),
1939 crate_token: Token![crate](tokens_helper(f, &node.crate_token.span)),
1940 ident: f.fold_ident(node.ident),
1941 rename: (node.rename).map(|it| {
1942 (
1943 Token![as](tokens_helper(f, &(it).0.span)),
1944 f.fold_ident((it).1),
1945 )
1946 }),
1947 semi_token: Token ! [ ; ](tokens_helper(f, &node.semi_token.spans)),
1948 }
1949 }
1950 #[cfg(feature = "full")]
fold_item_fn<F>(f: &mut F, node: ItemFn) -> ItemFn where F: Fold + ?Sized,1951 pub fn fold_item_fn<F>(f: &mut F, node: ItemFn) -> ItemFn
1952 where
1953 F: Fold + ?Sized,
1954 {
1955 ItemFn {
1956 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1957 vis: f.fold_visibility(node.vis),
1958 sig: f.fold_signature(node.sig),
1959 block: Box::new(f.fold_block(*node.block)),
1960 }
1961 }
1962 #[cfg(feature = "full")]
fold_item_foreign_mod<F>(f: &mut F, node: ItemForeignMod) -> ItemForeignMod where F: Fold + ?Sized,1963 pub fn fold_item_foreign_mod<F>(f: &mut F, node: ItemForeignMod) -> ItemForeignMod
1964 where
1965 F: Fold + ?Sized,
1966 {
1967 ItemForeignMod {
1968 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1969 abi: f.fold_abi(node.abi),
1970 brace_token: Brace(tokens_helper(f, &node.brace_token.span)),
1971 items: FoldHelper::lift(node.items, |it| f.fold_foreign_item(it)),
1972 }
1973 }
1974 #[cfg(feature = "full")]
fold_item_impl<F>(f: &mut F, node: ItemImpl) -> ItemImpl where F: Fold + ?Sized,1975 pub fn fold_item_impl<F>(f: &mut F, node: ItemImpl) -> ItemImpl
1976 where
1977 F: Fold + ?Sized,
1978 {
1979 ItemImpl {
1980 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
1981 defaultness: (node.defaultness).map(|it| Token![default](tokens_helper(f, &it.span))),
1982 unsafety: (node.unsafety).map(|it| Token![unsafe](tokens_helper(f, &it.span))),
1983 impl_token: Token![impl](tokens_helper(f, &node.impl_token.span)),
1984 generics: f.fold_generics(node.generics),
1985 trait_: (node.trait_).map(|it| {
1986 (
1987 ((it).0).map(|it| Token![!](tokens_helper(f, &it.spans))),
1988 f.fold_path((it).1),
1989 Token![for](tokens_helper(f, &(it).2.span)),
1990 )
1991 }),
1992 self_ty: Box::new(f.fold_type(*node.self_ty)),
1993 brace_token: Brace(tokens_helper(f, &node.brace_token.span)),
1994 items: FoldHelper::lift(node.items, |it| f.fold_impl_item(it)),
1995 }
1996 }
1997 #[cfg(feature = "full")]
fold_item_macro<F>(f: &mut F, node: ItemMacro) -> ItemMacro where F: Fold + ?Sized,1998 pub fn fold_item_macro<F>(f: &mut F, node: ItemMacro) -> ItemMacro
1999 where
2000 F: Fold + ?Sized,
2001 {
2002 ItemMacro {
2003 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
2004 ident: (node.ident).map(|it| f.fold_ident(it)),
2005 mac: f.fold_macro(node.mac),
2006 semi_token: (node.semi_token).map(|it| Token ! [ ; ](tokens_helper(f, &it.spans))),
2007 }
2008 }
2009 #[cfg(feature = "full")]
fold_item_macro2<F>(f: &mut F, node: ItemMacro2) -> ItemMacro2 where F: Fold + ?Sized,2010 pub fn fold_item_macro2<F>(f: &mut F, node: ItemMacro2) -> ItemMacro2
2011 where
2012 F: Fold + ?Sized,
2013 {
2014 ItemMacro2 {
2015 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
2016 vis: f.fold_visibility(node.vis),
2017 macro_token: Token![macro](tokens_helper(f, &node.macro_token.span)),
2018 ident: f.fold_ident(node.ident),
2019 rules: node.rules,
2020 }
2021 }
2022 #[cfg(feature = "full")]
fold_item_mod<F>(f: &mut F, node: ItemMod) -> ItemMod where F: Fold + ?Sized,2023 pub fn fold_item_mod<F>(f: &mut F, node: ItemMod) -> ItemMod
2024 where
2025 F: Fold + ?Sized,
2026 {
2027 ItemMod {
2028 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
2029 vis: f.fold_visibility(node.vis),
2030 mod_token: Token![mod](tokens_helper(f, &node.mod_token.span)),
2031 ident: f.fold_ident(node.ident),
2032 content: (node.content).map(|it| {
2033 (
2034 Brace(tokens_helper(f, &(it).0.span)),
2035 FoldHelper::lift((it).1, |it| f.fold_item(it)),
2036 )
2037 }),
2038 semi: (node.semi).map(|it| Token ! [ ; ](tokens_helper(f, &it.spans))),
2039 }
2040 }
2041 #[cfg(feature = "full")]
fold_item_static<F>(f: &mut F, node: ItemStatic) -> ItemStatic where F: Fold + ?Sized,2042 pub fn fold_item_static<F>(f: &mut F, node: ItemStatic) -> ItemStatic
2043 where
2044 F: Fold + ?Sized,
2045 {
2046 ItemStatic {
2047 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
2048 vis: f.fold_visibility(node.vis),
2049 static_token: Token![static](tokens_helper(f, &node.static_token.span)),
2050 mutability: (node.mutability).map(|it| Token![mut](tokens_helper(f, &it.span))),
2051 ident: f.fold_ident(node.ident),
2052 colon_token: Token ! [ : ](tokens_helper(f, &node.colon_token.spans)),
2053 ty: Box::new(f.fold_type(*node.ty)),
2054 eq_token: Token ! [ = ](tokens_helper(f, &node.eq_token.spans)),
2055 expr: Box::new(f.fold_expr(*node.expr)),
2056 semi_token: Token ! [ ; ](tokens_helper(f, &node.semi_token.spans)),
2057 }
2058 }
2059 #[cfg(feature = "full")]
fold_item_struct<F>(f: &mut F, node: ItemStruct) -> ItemStruct where F: Fold + ?Sized,2060 pub fn fold_item_struct<F>(f: &mut F, node: ItemStruct) -> ItemStruct
2061 where
2062 F: Fold + ?Sized,
2063 {
2064 ItemStruct {
2065 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
2066 vis: f.fold_visibility(node.vis),
2067 struct_token: Token![struct](tokens_helper(f, &node.struct_token.span)),
2068 ident: f.fold_ident(node.ident),
2069 generics: f.fold_generics(node.generics),
2070 fields: f.fold_fields(node.fields),
2071 semi_token: (node.semi_token).map(|it| Token ! [ ; ](tokens_helper(f, &it.spans))),
2072 }
2073 }
2074 #[cfg(feature = "full")]
fold_item_trait<F>(f: &mut F, node: ItemTrait) -> ItemTrait where F: Fold + ?Sized,2075 pub fn fold_item_trait<F>(f: &mut F, node: ItemTrait) -> ItemTrait
2076 where
2077 F: Fold + ?Sized,
2078 {
2079 ItemTrait {
2080 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
2081 vis: f.fold_visibility(node.vis),
2082 unsafety: (node.unsafety).map(|it| Token![unsafe](tokens_helper(f, &it.span))),
2083 auto_token: (node.auto_token).map(|it| Token![auto](tokens_helper(f, &it.span))),
2084 trait_token: Token![trait](tokens_helper(f, &node.trait_token.span)),
2085 ident: f.fold_ident(node.ident),
2086 generics: f.fold_generics(node.generics),
2087 colon_token: (node.colon_token).map(|it| Token ! [ : ](tokens_helper(f, &it.spans))),
2088 supertraits: FoldHelper::lift(node.supertraits, |it| f.fold_type_param_bound(it)),
2089 brace_token: Brace(tokens_helper(f, &node.brace_token.span)),
2090 items: FoldHelper::lift(node.items, |it| f.fold_trait_item(it)),
2091 }
2092 }
2093 #[cfg(feature = "full")]
fold_item_trait_alias<F>(f: &mut F, node: ItemTraitAlias) -> ItemTraitAlias where F: Fold + ?Sized,2094 pub fn fold_item_trait_alias<F>(f: &mut F, node: ItemTraitAlias) -> ItemTraitAlias
2095 where
2096 F: Fold + ?Sized,
2097 {
2098 ItemTraitAlias {
2099 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
2100 vis: f.fold_visibility(node.vis),
2101 trait_token: Token![trait](tokens_helper(f, &node.trait_token.span)),
2102 ident: f.fold_ident(node.ident),
2103 generics: f.fold_generics(node.generics),
2104 eq_token: Token ! [ = ](tokens_helper(f, &node.eq_token.spans)),
2105 bounds: FoldHelper::lift(node.bounds, |it| f.fold_type_param_bound(it)),
2106 semi_token: Token ! [ ; ](tokens_helper(f, &node.semi_token.spans)),
2107 }
2108 }
2109 #[cfg(feature = "full")]
fold_item_type<F>(f: &mut F, node: ItemType) -> ItemType where F: Fold + ?Sized,2110 pub fn fold_item_type<F>(f: &mut F, node: ItemType) -> ItemType
2111 where
2112 F: Fold + ?Sized,
2113 {
2114 ItemType {
2115 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
2116 vis: f.fold_visibility(node.vis),
2117 type_token: Token![type](tokens_helper(f, &node.type_token.span)),
2118 ident: f.fold_ident(node.ident),
2119 generics: f.fold_generics(node.generics),
2120 eq_token: Token ! [ = ](tokens_helper(f, &node.eq_token.spans)),
2121 ty: Box::new(f.fold_type(*node.ty)),
2122 semi_token: Token ! [ ; ](tokens_helper(f, &node.semi_token.spans)),
2123 }
2124 }
2125 #[cfg(feature = "full")]
fold_item_union<F>(f: &mut F, node: ItemUnion) -> ItemUnion where F: Fold + ?Sized,2126 pub fn fold_item_union<F>(f: &mut F, node: ItemUnion) -> ItemUnion
2127 where
2128 F: Fold + ?Sized,
2129 {
2130 ItemUnion {
2131 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
2132 vis: f.fold_visibility(node.vis),
2133 union_token: Token![union](tokens_helper(f, &node.union_token.span)),
2134 ident: f.fold_ident(node.ident),
2135 generics: f.fold_generics(node.generics),
2136 fields: f.fold_fields_named(node.fields),
2137 }
2138 }
2139 #[cfg(feature = "full")]
fold_item_use<F>(f: &mut F, node: ItemUse) -> ItemUse where F: Fold + ?Sized,2140 pub fn fold_item_use<F>(f: &mut F, node: ItemUse) -> ItemUse
2141 where
2142 F: Fold + ?Sized,
2143 {
2144 ItemUse {
2145 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
2146 vis: f.fold_visibility(node.vis),
2147 use_token: Token![use](tokens_helper(f, &node.use_token.span)),
2148 leading_colon: (node.leading_colon).map(|it| Token ! [ :: ](tokens_helper(f, &it.spans))),
2149 tree: f.fold_use_tree(node.tree),
2150 semi_token: Token ! [ ; ](tokens_helper(f, &node.semi_token.spans)),
2151 }
2152 }
2153 #[cfg(feature = "full")]
fold_label<F>(f: &mut F, node: Label) -> Label where F: Fold + ?Sized,2154 pub fn fold_label<F>(f: &mut F, node: Label) -> Label
2155 where
2156 F: Fold + ?Sized,
2157 {
2158 Label {
2159 name: f.fold_lifetime(node.name),
2160 colon_token: Token ! [ : ](tokens_helper(f, &node.colon_token.spans)),
2161 }
2162 }
fold_lifetime<F>(f: &mut F, node: Lifetime) -> Lifetime where F: Fold + ?Sized,2163 pub fn fold_lifetime<F>(f: &mut F, node: Lifetime) -> Lifetime
2164 where
2165 F: Fold + ?Sized,
2166 {
2167 Lifetime {
2168 apostrophe: f.fold_span(node.apostrophe),
2169 ident: f.fold_ident(node.ident),
2170 }
2171 }
2172 #[cfg(any(feature = "derive", feature = "full"))]
fold_lifetime_def<F>(f: &mut F, node: LifetimeDef) -> LifetimeDef where F: Fold + ?Sized,2173 pub fn fold_lifetime_def<F>(f: &mut F, node: LifetimeDef) -> LifetimeDef
2174 where
2175 F: Fold + ?Sized,
2176 {
2177 LifetimeDef {
2178 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
2179 lifetime: f.fold_lifetime(node.lifetime),
2180 colon_token: (node.colon_token).map(|it| Token ! [ : ](tokens_helper(f, &it.spans))),
2181 bounds: FoldHelper::lift(node.bounds, |it| f.fold_lifetime(it)),
2182 }
2183 }
fold_lit<F>(f: &mut F, node: Lit) -> Lit where F: Fold + ?Sized,2184 pub fn fold_lit<F>(f: &mut F, node: Lit) -> Lit
2185 where
2186 F: Fold + ?Sized,
2187 {
2188 match node {
2189 Lit::Str(_binding_0) => Lit::Str(f.fold_lit_str(_binding_0)),
2190 Lit::ByteStr(_binding_0) => Lit::ByteStr(f.fold_lit_byte_str(_binding_0)),
2191 Lit::Byte(_binding_0) => Lit::Byte(f.fold_lit_byte(_binding_0)),
2192 Lit::Char(_binding_0) => Lit::Char(f.fold_lit_char(_binding_0)),
2193 Lit::Int(_binding_0) => Lit::Int(f.fold_lit_int(_binding_0)),
2194 Lit::Float(_binding_0) => Lit::Float(f.fold_lit_float(_binding_0)),
2195 Lit::Bool(_binding_0) => Lit::Bool(f.fold_lit_bool(_binding_0)),
2196 Lit::Verbatim(_binding_0) => Lit::Verbatim(_binding_0),
2197 }
2198 }
fold_lit_bool<F>(f: &mut F, node: LitBool) -> LitBool where F: Fold + ?Sized,2199 pub fn fold_lit_bool<F>(f: &mut F, node: LitBool) -> LitBool
2200 where
2201 F: Fold + ?Sized,
2202 {
2203 LitBool {
2204 value: node.value,
2205 span: f.fold_span(node.span),
2206 }
2207 }
fold_lit_byte<F>(f: &mut F, node: LitByte) -> LitByte where F: Fold + ?Sized,2208 pub fn fold_lit_byte<F>(f: &mut F, node: LitByte) -> LitByte
2209 where
2210 F: Fold + ?Sized,
2211 {
2212 let span = f.fold_span(node.span());
2213 let mut node = node;
2214 node.set_span(span);
2215 node
2216 }
fold_lit_byte_str<F>(f: &mut F, node: LitByteStr) -> LitByteStr where F: Fold + ?Sized,2217 pub fn fold_lit_byte_str<F>(f: &mut F, node: LitByteStr) -> LitByteStr
2218 where
2219 F: Fold + ?Sized,
2220 {
2221 let span = f.fold_span(node.span());
2222 let mut node = node;
2223 node.set_span(span);
2224 node
2225 }
fold_lit_char<F>(f: &mut F, node: LitChar) -> LitChar where F: Fold + ?Sized,2226 pub fn fold_lit_char<F>(f: &mut F, node: LitChar) -> LitChar
2227 where
2228 F: Fold + ?Sized,
2229 {
2230 let span = f.fold_span(node.span());
2231 let mut node = node;
2232 node.set_span(span);
2233 node
2234 }
fold_lit_float<F>(f: &mut F, node: LitFloat) -> LitFloat where F: Fold + ?Sized,2235 pub fn fold_lit_float<F>(f: &mut F, node: LitFloat) -> LitFloat
2236 where
2237 F: Fold + ?Sized,
2238 {
2239 let span = f.fold_span(node.span());
2240 let mut node = node;
2241 node.set_span(span);
2242 node
2243 }
fold_lit_int<F>(f: &mut F, node: LitInt) -> LitInt where F: Fold + ?Sized,2244 pub fn fold_lit_int<F>(f: &mut F, node: LitInt) -> LitInt
2245 where
2246 F: Fold + ?Sized,
2247 {
2248 let span = f.fold_span(node.span());
2249 let mut node = node;
2250 node.set_span(span);
2251 node
2252 }
fold_lit_str<F>(f: &mut F, node: LitStr) -> LitStr where F: Fold + ?Sized,2253 pub fn fold_lit_str<F>(f: &mut F, node: LitStr) -> LitStr
2254 where
2255 F: Fold + ?Sized,
2256 {
2257 let span = f.fold_span(node.span());
2258 let mut node = node;
2259 node.set_span(span);
2260 node
2261 }
2262 #[cfg(feature = "full")]
fold_local<F>(f: &mut F, node: Local) -> Local where F: Fold + ?Sized,2263 pub fn fold_local<F>(f: &mut F, node: Local) -> Local
2264 where
2265 F: Fold + ?Sized,
2266 {
2267 Local {
2268 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
2269 let_token: Token![let](tokens_helper(f, &node.let_token.span)),
2270 pat: f.fold_pat(node.pat),
2271 init: (node.init).map(|it| {
2272 (
2273 Token ! [ = ](tokens_helper(f, &(it).0.spans)),
2274 Box::new(f.fold_expr(*(it).1)),
2275 )
2276 }),
2277 semi_token: Token ! [ ; ](tokens_helper(f, &node.semi_token.spans)),
2278 }
2279 }
2280 #[cfg(any(feature = "derive", feature = "full"))]
fold_macro<F>(f: &mut F, node: Macro) -> Macro where F: Fold + ?Sized,2281 pub fn fold_macro<F>(f: &mut F, node: Macro) -> Macro
2282 where
2283 F: Fold + ?Sized,
2284 {
2285 Macro {
2286 path: f.fold_path(node.path),
2287 bang_token: Token![!](tokens_helper(f, &node.bang_token.spans)),
2288 delimiter: f.fold_macro_delimiter(node.delimiter),
2289 tokens: node.tokens,
2290 }
2291 }
2292 #[cfg(any(feature = "derive", feature = "full"))]
fold_macro_delimiter<F>(f: &mut F, node: MacroDelimiter) -> MacroDelimiter where F: Fold + ?Sized,2293 pub fn fold_macro_delimiter<F>(f: &mut F, node: MacroDelimiter) -> MacroDelimiter
2294 where
2295 F: Fold + ?Sized,
2296 {
2297 match node {
2298 MacroDelimiter::Paren(_binding_0) => {
2299 MacroDelimiter::Paren(Paren(tokens_helper(f, &_binding_0.span)))
2300 }
2301 MacroDelimiter::Brace(_binding_0) => {
2302 MacroDelimiter::Brace(Brace(tokens_helper(f, &_binding_0.span)))
2303 }
2304 MacroDelimiter::Bracket(_binding_0) => {
2305 MacroDelimiter::Bracket(Bracket(tokens_helper(f, &_binding_0.span)))
2306 }
2307 }
2308 }
2309 #[cfg(any(feature = "derive", feature = "full"))]
fold_member<F>(f: &mut F, node: Member) -> Member where F: Fold + ?Sized,2310 pub fn fold_member<F>(f: &mut F, node: Member) -> Member
2311 where
2312 F: Fold + ?Sized,
2313 {
2314 match node {
2315 Member::Named(_binding_0) => Member::Named(f.fold_ident(_binding_0)),
2316 Member::Unnamed(_binding_0) => Member::Unnamed(f.fold_index(_binding_0)),
2317 }
2318 }
2319 #[cfg(any(feature = "derive", feature = "full"))]
fold_meta<F>(f: &mut F, node: Meta) -> Meta where F: Fold + ?Sized,2320 pub fn fold_meta<F>(f: &mut F, node: Meta) -> Meta
2321 where
2322 F: Fold + ?Sized,
2323 {
2324 match node {
2325 Meta::Path(_binding_0) => Meta::Path(f.fold_path(_binding_0)),
2326 Meta::List(_binding_0) => Meta::List(f.fold_meta_list(_binding_0)),
2327 Meta::NameValue(_binding_0) => Meta::NameValue(f.fold_meta_name_value(_binding_0)),
2328 }
2329 }
2330 #[cfg(any(feature = "derive", feature = "full"))]
fold_meta_list<F>(f: &mut F, node: MetaList) -> MetaList where F: Fold + ?Sized,2331 pub fn fold_meta_list<F>(f: &mut F, node: MetaList) -> MetaList
2332 where
2333 F: Fold + ?Sized,
2334 {
2335 MetaList {
2336 path: f.fold_path(node.path),
2337 paren_token: Paren(tokens_helper(f, &node.paren_token.span)),
2338 nested: FoldHelper::lift(node.nested, |it| f.fold_nested_meta(it)),
2339 }
2340 }
2341 #[cfg(any(feature = "derive", feature = "full"))]
fold_meta_name_value<F>(f: &mut F, node: MetaNameValue) -> MetaNameValue where F: Fold + ?Sized,2342 pub fn fold_meta_name_value<F>(f: &mut F, node: MetaNameValue) -> MetaNameValue
2343 where
2344 F: Fold + ?Sized,
2345 {
2346 MetaNameValue {
2347 path: f.fold_path(node.path),
2348 eq_token: Token ! [ = ](tokens_helper(f, &node.eq_token.spans)),
2349 lit: f.fold_lit(node.lit),
2350 }
2351 }
2352 #[cfg(feature = "full")]
fold_method_turbofish<F>(f: &mut F, node: MethodTurbofish) -> MethodTurbofish where F: Fold + ?Sized,2353 pub fn fold_method_turbofish<F>(f: &mut F, node: MethodTurbofish) -> MethodTurbofish
2354 where
2355 F: Fold + ?Sized,
2356 {
2357 MethodTurbofish {
2358 colon2_token: Token ! [ :: ](tokens_helper(f, &node.colon2_token.spans)),
2359 lt_token: Token ! [ < ](tokens_helper(f, &node.lt_token.spans)),
2360 args: FoldHelper::lift(node.args, |it| f.fold_generic_method_argument(it)),
2361 gt_token: Token ! [ > ](tokens_helper(f, &node.gt_token.spans)),
2362 }
2363 }
2364 #[cfg(any(feature = "derive", feature = "full"))]
fold_nested_meta<F>(f: &mut F, node: NestedMeta) -> NestedMeta where F: Fold + ?Sized,2365 pub fn fold_nested_meta<F>(f: &mut F, node: NestedMeta) -> NestedMeta
2366 where
2367 F: Fold + ?Sized,
2368 {
2369 match node {
2370 NestedMeta::Meta(_binding_0) => NestedMeta::Meta(f.fold_meta(_binding_0)),
2371 NestedMeta::Lit(_binding_0) => NestedMeta::Lit(f.fold_lit(_binding_0)),
2372 }
2373 }
2374 #[cfg(any(feature = "derive", feature = "full"))]
fold_parenthesized_generic_arguments<F>( f: &mut F, node: ParenthesizedGenericArguments, ) -> ParenthesizedGenericArguments where F: Fold + ?Sized,2375 pub fn fold_parenthesized_generic_arguments<F>(
2376 f: &mut F,
2377 node: ParenthesizedGenericArguments,
2378 ) -> ParenthesizedGenericArguments
2379 where
2380 F: Fold + ?Sized,
2381 {
2382 ParenthesizedGenericArguments {
2383 paren_token: Paren(tokens_helper(f, &node.paren_token.span)),
2384 inputs: FoldHelper::lift(node.inputs, |it| f.fold_type(it)),
2385 output: f.fold_return_type(node.output),
2386 }
2387 }
2388 #[cfg(feature = "full")]
fold_pat<F>(f: &mut F, node: Pat) -> Pat where F: Fold + ?Sized,2389 pub fn fold_pat<F>(f: &mut F, node: Pat) -> Pat
2390 where
2391 F: Fold + ?Sized,
2392 {
2393 match node {
2394 Pat::Box(_binding_0) => Pat::Box(f.fold_pat_box(_binding_0)),
2395 Pat::Ident(_binding_0) => Pat::Ident(f.fold_pat_ident(_binding_0)),
2396 Pat::Lit(_binding_0) => Pat::Lit(f.fold_pat_lit(_binding_0)),
2397 Pat::Macro(_binding_0) => Pat::Macro(f.fold_pat_macro(_binding_0)),
2398 Pat::Or(_binding_0) => Pat::Or(f.fold_pat_or(_binding_0)),
2399 Pat::Path(_binding_0) => Pat::Path(f.fold_pat_path(_binding_0)),
2400 Pat::Range(_binding_0) => Pat::Range(f.fold_pat_range(_binding_0)),
2401 Pat::Reference(_binding_0) => Pat::Reference(f.fold_pat_reference(_binding_0)),
2402 Pat::Rest(_binding_0) => Pat::Rest(f.fold_pat_rest(_binding_0)),
2403 Pat::Slice(_binding_0) => Pat::Slice(f.fold_pat_slice(_binding_0)),
2404 Pat::Struct(_binding_0) => Pat::Struct(f.fold_pat_struct(_binding_0)),
2405 Pat::Tuple(_binding_0) => Pat::Tuple(f.fold_pat_tuple(_binding_0)),
2406 Pat::TupleStruct(_binding_0) => Pat::TupleStruct(f.fold_pat_tuple_struct(_binding_0)),
2407 Pat::Type(_binding_0) => Pat::Type(f.fold_pat_type(_binding_0)),
2408 Pat::Verbatim(_binding_0) => Pat::Verbatim(_binding_0),
2409 Pat::Wild(_binding_0) => Pat::Wild(f.fold_pat_wild(_binding_0)),
2410 _ => unreachable!(),
2411 }
2412 }
2413 #[cfg(feature = "full")]
fold_pat_box<F>(f: &mut F, node: PatBox) -> PatBox where F: Fold + ?Sized,2414 pub fn fold_pat_box<F>(f: &mut F, node: PatBox) -> PatBox
2415 where
2416 F: Fold + ?Sized,
2417 {
2418 PatBox {
2419 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
2420 box_token: Token![box](tokens_helper(f, &node.box_token.span)),
2421 pat: Box::new(f.fold_pat(*node.pat)),
2422 }
2423 }
2424 #[cfg(feature = "full")]
fold_pat_ident<F>(f: &mut F, node: PatIdent) -> PatIdent where F: Fold + ?Sized,2425 pub fn fold_pat_ident<F>(f: &mut F, node: PatIdent) -> PatIdent
2426 where
2427 F: Fold + ?Sized,
2428 {
2429 PatIdent {
2430 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
2431 by_ref: (node.by_ref).map(|it| Token![ref](tokens_helper(f, &it.span))),
2432 mutability: (node.mutability).map(|it| Token![mut](tokens_helper(f, &it.span))),
2433 ident: f.fold_ident(node.ident),
2434 subpat: (node.subpat).map(|it| {
2435 (
2436 Token ! [ @ ](tokens_helper(f, &(it).0.spans)),
2437 Box::new(f.fold_pat(*(it).1)),
2438 )
2439 }),
2440 }
2441 }
2442 #[cfg(feature = "full")]
fold_pat_lit<F>(f: &mut F, node: PatLit) -> PatLit where F: Fold + ?Sized,2443 pub fn fold_pat_lit<F>(f: &mut F, node: PatLit) -> PatLit
2444 where
2445 F: Fold + ?Sized,
2446 {
2447 PatLit {
2448 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
2449 expr: Box::new(f.fold_expr(*node.expr)),
2450 }
2451 }
2452 #[cfg(feature = "full")]
fold_pat_macro<F>(f: &mut F, node: PatMacro) -> PatMacro where F: Fold + ?Sized,2453 pub fn fold_pat_macro<F>(f: &mut F, node: PatMacro) -> PatMacro
2454 where
2455 F: Fold + ?Sized,
2456 {
2457 PatMacro {
2458 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
2459 mac: f.fold_macro(node.mac),
2460 }
2461 }
2462 #[cfg(feature = "full")]
fold_pat_or<F>(f: &mut F, node: PatOr) -> PatOr where F: Fold + ?Sized,2463 pub fn fold_pat_or<F>(f: &mut F, node: PatOr) -> PatOr
2464 where
2465 F: Fold + ?Sized,
2466 {
2467 PatOr {
2468 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
2469 leading_vert: (node.leading_vert).map(|it| Token ! [ | ](tokens_helper(f, &it.spans))),
2470 cases: FoldHelper::lift(node.cases, |it| f.fold_pat(it)),
2471 }
2472 }
2473 #[cfg(feature = "full")]
fold_pat_path<F>(f: &mut F, node: PatPath) -> PatPath where F: Fold + ?Sized,2474 pub fn fold_pat_path<F>(f: &mut F, node: PatPath) -> PatPath
2475 where
2476 F: Fold + ?Sized,
2477 {
2478 PatPath {
2479 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
2480 qself: (node.qself).map(|it| f.fold_qself(it)),
2481 path: f.fold_path(node.path),
2482 }
2483 }
2484 #[cfg(feature = "full")]
fold_pat_range<F>(f: &mut F, node: PatRange) -> PatRange where F: Fold + ?Sized,2485 pub fn fold_pat_range<F>(f: &mut F, node: PatRange) -> PatRange
2486 where
2487 F: Fold + ?Sized,
2488 {
2489 PatRange {
2490 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
2491 lo: Box::new(f.fold_expr(*node.lo)),
2492 limits: f.fold_range_limits(node.limits),
2493 hi: Box::new(f.fold_expr(*node.hi)),
2494 }
2495 }
2496 #[cfg(feature = "full")]
fold_pat_reference<F>(f: &mut F, node: PatReference) -> PatReference where F: Fold + ?Sized,2497 pub fn fold_pat_reference<F>(f: &mut F, node: PatReference) -> PatReference
2498 where
2499 F: Fold + ?Sized,
2500 {
2501 PatReference {
2502 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
2503 and_token: Token ! [ & ](tokens_helper(f, &node.and_token.spans)),
2504 mutability: (node.mutability).map(|it| Token![mut](tokens_helper(f, &it.span))),
2505 pat: Box::new(f.fold_pat(*node.pat)),
2506 }
2507 }
2508 #[cfg(feature = "full")]
fold_pat_rest<F>(f: &mut F, node: PatRest) -> PatRest where F: Fold + ?Sized,2509 pub fn fold_pat_rest<F>(f: &mut F, node: PatRest) -> PatRest
2510 where
2511 F: Fold + ?Sized,
2512 {
2513 PatRest {
2514 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
2515 dot2_token: Token![..](tokens_helper(f, &node.dot2_token.spans)),
2516 }
2517 }
2518 #[cfg(feature = "full")]
fold_pat_slice<F>(f: &mut F, node: PatSlice) -> PatSlice where F: Fold + ?Sized,2519 pub fn fold_pat_slice<F>(f: &mut F, node: PatSlice) -> PatSlice
2520 where
2521 F: Fold + ?Sized,
2522 {
2523 PatSlice {
2524 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
2525 bracket_token: Bracket(tokens_helper(f, &node.bracket_token.span)),
2526 elems: FoldHelper::lift(node.elems, |it| f.fold_pat(it)),
2527 }
2528 }
2529 #[cfg(feature = "full")]
fold_pat_struct<F>(f: &mut F, node: PatStruct) -> PatStruct where F: Fold + ?Sized,2530 pub fn fold_pat_struct<F>(f: &mut F, node: PatStruct) -> PatStruct
2531 where
2532 F: Fold + ?Sized,
2533 {
2534 PatStruct {
2535 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
2536 path: f.fold_path(node.path),
2537 brace_token: Brace(tokens_helper(f, &node.brace_token.span)),
2538 fields: FoldHelper::lift(node.fields, |it| f.fold_field_pat(it)),
2539 dot2_token: (node.dot2_token).map(|it| Token![..](tokens_helper(f, &it.spans))),
2540 }
2541 }
2542 #[cfg(feature = "full")]
fold_pat_tuple<F>(f: &mut F, node: PatTuple) -> PatTuple where F: Fold + ?Sized,2543 pub fn fold_pat_tuple<F>(f: &mut F, node: PatTuple) -> PatTuple
2544 where
2545 F: Fold + ?Sized,
2546 {
2547 PatTuple {
2548 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
2549 paren_token: Paren(tokens_helper(f, &node.paren_token.span)),
2550 elems: FoldHelper::lift(node.elems, |it| f.fold_pat(it)),
2551 }
2552 }
2553 #[cfg(feature = "full")]
fold_pat_tuple_struct<F>(f: &mut F, node: PatTupleStruct) -> PatTupleStruct where F: Fold + ?Sized,2554 pub fn fold_pat_tuple_struct<F>(f: &mut F, node: PatTupleStruct) -> PatTupleStruct
2555 where
2556 F: Fold + ?Sized,
2557 {
2558 PatTupleStruct {
2559 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
2560 path: f.fold_path(node.path),
2561 pat: f.fold_pat_tuple(node.pat),
2562 }
2563 }
2564 #[cfg(feature = "full")]
fold_pat_type<F>(f: &mut F, node: PatType) -> PatType where F: Fold + ?Sized,2565 pub fn fold_pat_type<F>(f: &mut F, node: PatType) -> PatType
2566 where
2567 F: Fold + ?Sized,
2568 {
2569 PatType {
2570 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
2571 pat: Box::new(f.fold_pat(*node.pat)),
2572 colon_token: Token ! [ : ](tokens_helper(f, &node.colon_token.spans)),
2573 ty: Box::new(f.fold_type(*node.ty)),
2574 }
2575 }
2576 #[cfg(feature = "full")]
fold_pat_wild<F>(f: &mut F, node: PatWild) -> PatWild where F: Fold + ?Sized,2577 pub fn fold_pat_wild<F>(f: &mut F, node: PatWild) -> PatWild
2578 where
2579 F: Fold + ?Sized,
2580 {
2581 PatWild {
2582 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
2583 underscore_token: Token![_](tokens_helper(f, &node.underscore_token.spans)),
2584 }
2585 }
2586 #[cfg(any(feature = "derive", feature = "full"))]
fold_path<F>(f: &mut F, node: Path) -> Path where F: Fold + ?Sized,2587 pub fn fold_path<F>(f: &mut F, node: Path) -> Path
2588 where
2589 F: Fold + ?Sized,
2590 {
2591 Path {
2592 leading_colon: (node.leading_colon).map(|it| Token ! [ :: ](tokens_helper(f, &it.spans))),
2593 segments: FoldHelper::lift(node.segments, |it| f.fold_path_segment(it)),
2594 }
2595 }
2596 #[cfg(any(feature = "derive", feature = "full"))]
fold_path_arguments<F>(f: &mut F, node: PathArguments) -> PathArguments where F: Fold + ?Sized,2597 pub fn fold_path_arguments<F>(f: &mut F, node: PathArguments) -> PathArguments
2598 where
2599 F: Fold + ?Sized,
2600 {
2601 match node {
2602 PathArguments::None => PathArguments::None,
2603 PathArguments::AngleBracketed(_binding_0) => {
2604 PathArguments::AngleBracketed(f.fold_angle_bracketed_generic_arguments(_binding_0))
2605 }
2606 PathArguments::Parenthesized(_binding_0) => {
2607 PathArguments::Parenthesized(f.fold_parenthesized_generic_arguments(_binding_0))
2608 }
2609 }
2610 }
2611 #[cfg(any(feature = "derive", feature = "full"))]
fold_path_segment<F>(f: &mut F, node: PathSegment) -> PathSegment where F: Fold + ?Sized,2612 pub fn fold_path_segment<F>(f: &mut F, node: PathSegment) -> PathSegment
2613 where
2614 F: Fold + ?Sized,
2615 {
2616 PathSegment {
2617 ident: f.fold_ident(node.ident),
2618 arguments: f.fold_path_arguments(node.arguments),
2619 }
2620 }
2621 #[cfg(any(feature = "derive", feature = "full"))]
fold_predicate_eq<F>(f: &mut F, node: PredicateEq) -> PredicateEq where F: Fold + ?Sized,2622 pub fn fold_predicate_eq<F>(f: &mut F, node: PredicateEq) -> PredicateEq
2623 where
2624 F: Fold + ?Sized,
2625 {
2626 PredicateEq {
2627 lhs_ty: f.fold_type(node.lhs_ty),
2628 eq_token: Token ! [ = ](tokens_helper(f, &node.eq_token.spans)),
2629 rhs_ty: f.fold_type(node.rhs_ty),
2630 }
2631 }
2632 #[cfg(any(feature = "derive", feature = "full"))]
fold_predicate_lifetime<F>(f: &mut F, node: PredicateLifetime) -> PredicateLifetime where F: Fold + ?Sized,2633 pub fn fold_predicate_lifetime<F>(f: &mut F, node: PredicateLifetime) -> PredicateLifetime
2634 where
2635 F: Fold + ?Sized,
2636 {
2637 PredicateLifetime {
2638 lifetime: f.fold_lifetime(node.lifetime),
2639 colon_token: Token ! [ : ](tokens_helper(f, &node.colon_token.spans)),
2640 bounds: FoldHelper::lift(node.bounds, |it| f.fold_lifetime(it)),
2641 }
2642 }
2643 #[cfg(any(feature = "derive", feature = "full"))]
fold_predicate_type<F>(f: &mut F, node: PredicateType) -> PredicateType where F: Fold + ?Sized,2644 pub fn fold_predicate_type<F>(f: &mut F, node: PredicateType) -> PredicateType
2645 where
2646 F: Fold + ?Sized,
2647 {
2648 PredicateType {
2649 lifetimes: (node.lifetimes).map(|it| f.fold_bound_lifetimes(it)),
2650 bounded_ty: f.fold_type(node.bounded_ty),
2651 colon_token: Token ! [ : ](tokens_helper(f, &node.colon_token.spans)),
2652 bounds: FoldHelper::lift(node.bounds, |it| f.fold_type_param_bound(it)),
2653 }
2654 }
2655 #[cfg(any(feature = "derive", feature = "full"))]
fold_qself<F>(f: &mut F, node: QSelf) -> QSelf where F: Fold + ?Sized,2656 pub fn fold_qself<F>(f: &mut F, node: QSelf) -> QSelf
2657 where
2658 F: Fold + ?Sized,
2659 {
2660 QSelf {
2661 lt_token: Token ! [ < ](tokens_helper(f, &node.lt_token.spans)),
2662 ty: Box::new(f.fold_type(*node.ty)),
2663 position: node.position,
2664 as_token: (node.as_token).map(|it| Token![as](tokens_helper(f, &it.span))),
2665 gt_token: Token ! [ > ](tokens_helper(f, &node.gt_token.spans)),
2666 }
2667 }
2668 #[cfg(feature = "full")]
fold_range_limits<F>(f: &mut F, node: RangeLimits) -> RangeLimits where F: Fold + ?Sized,2669 pub fn fold_range_limits<F>(f: &mut F, node: RangeLimits) -> RangeLimits
2670 where
2671 F: Fold + ?Sized,
2672 {
2673 match node {
2674 RangeLimits::HalfOpen(_binding_0) => {
2675 RangeLimits::HalfOpen(Token![..](tokens_helper(f, &_binding_0.spans)))
2676 }
2677 RangeLimits::Closed(_binding_0) => {
2678 RangeLimits::Closed(Token ! [ ..= ](tokens_helper(f, &_binding_0.spans)))
2679 }
2680 }
2681 }
2682 #[cfg(feature = "full")]
fold_receiver<F>(f: &mut F, node: Receiver) -> Receiver where F: Fold + ?Sized,2683 pub fn fold_receiver<F>(f: &mut F, node: Receiver) -> Receiver
2684 where
2685 F: Fold + ?Sized,
2686 {
2687 Receiver {
2688 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
2689 reference: (node.reference).map(|it| {
2690 (
2691 Token ! [ & ](tokens_helper(f, &(it).0.spans)),
2692 ((it).1).map(|it| f.fold_lifetime(it)),
2693 )
2694 }),
2695 mutability: (node.mutability).map(|it| Token![mut](tokens_helper(f, &it.span))),
2696 self_token: Token![self](tokens_helper(f, &node.self_token.span)),
2697 }
2698 }
2699 #[cfg(any(feature = "derive", feature = "full"))]
fold_return_type<F>(f: &mut F, node: ReturnType) -> ReturnType where F: Fold + ?Sized,2700 pub fn fold_return_type<F>(f: &mut F, node: ReturnType) -> ReturnType
2701 where
2702 F: Fold + ?Sized,
2703 {
2704 match node {
2705 ReturnType::Default => ReturnType::Default,
2706 ReturnType::Type(_binding_0, _binding_1) => ReturnType::Type(
2707 Token ! [ -> ](tokens_helper(f, &_binding_0.spans)),
2708 Box::new(f.fold_type(*_binding_1)),
2709 ),
2710 }
2711 }
2712 #[cfg(feature = "full")]
fold_signature<F>(f: &mut F, node: Signature) -> Signature where F: Fold + ?Sized,2713 pub fn fold_signature<F>(f: &mut F, node: Signature) -> Signature
2714 where
2715 F: Fold + ?Sized,
2716 {
2717 Signature {
2718 constness: (node.constness).map(|it| Token![const](tokens_helper(f, &it.span))),
2719 asyncness: (node.asyncness).map(|it| Token![async](tokens_helper(f, &it.span))),
2720 unsafety: (node.unsafety).map(|it| Token![unsafe](tokens_helper(f, &it.span))),
2721 abi: (node.abi).map(|it| f.fold_abi(it)),
2722 fn_token: Token![fn](tokens_helper(f, &node.fn_token.span)),
2723 ident: f.fold_ident(node.ident),
2724 generics: f.fold_generics(node.generics),
2725 paren_token: Paren(tokens_helper(f, &node.paren_token.span)),
2726 inputs: FoldHelper::lift(node.inputs, |it| f.fold_fn_arg(it)),
2727 variadic: (node.variadic).map(|it| f.fold_variadic(it)),
2728 output: f.fold_return_type(node.output),
2729 }
2730 }
fold_span<F>(f: &mut F, node: Span) -> Span where F: Fold + ?Sized,2731 pub fn fold_span<F>(f: &mut F, node: Span) -> Span
2732 where
2733 F: Fold + ?Sized,
2734 {
2735 node
2736 }
2737 #[cfg(feature = "full")]
fold_stmt<F>(f: &mut F, node: Stmt) -> Stmt where F: Fold + ?Sized,2738 pub fn fold_stmt<F>(f: &mut F, node: Stmt) -> Stmt
2739 where
2740 F: Fold + ?Sized,
2741 {
2742 match node {
2743 Stmt::Local(_binding_0) => Stmt::Local(f.fold_local(_binding_0)),
2744 Stmt::Item(_binding_0) => Stmt::Item(f.fold_item(_binding_0)),
2745 Stmt::Expr(_binding_0) => Stmt::Expr(f.fold_expr(_binding_0)),
2746 Stmt::Semi(_binding_0, _binding_1) => Stmt::Semi(
2747 f.fold_expr(_binding_0),
2748 Token ! [ ; ](tokens_helper(f, &_binding_1.spans)),
2749 ),
2750 }
2751 }
2752 #[cfg(any(feature = "derive", feature = "full"))]
fold_trait_bound<F>(f: &mut F, node: TraitBound) -> TraitBound where F: Fold + ?Sized,2753 pub fn fold_trait_bound<F>(f: &mut F, node: TraitBound) -> TraitBound
2754 where
2755 F: Fold + ?Sized,
2756 {
2757 TraitBound {
2758 paren_token: (node.paren_token).map(|it| Paren(tokens_helper(f, &it.span))),
2759 modifier: f.fold_trait_bound_modifier(node.modifier),
2760 lifetimes: (node.lifetimes).map(|it| f.fold_bound_lifetimes(it)),
2761 path: f.fold_path(node.path),
2762 }
2763 }
2764 #[cfg(any(feature = "derive", feature = "full"))]
fold_trait_bound_modifier<F>(f: &mut F, node: TraitBoundModifier) -> TraitBoundModifier where F: Fold + ?Sized,2765 pub fn fold_trait_bound_modifier<F>(f: &mut F, node: TraitBoundModifier) -> TraitBoundModifier
2766 where
2767 F: Fold + ?Sized,
2768 {
2769 match node {
2770 TraitBoundModifier::None => TraitBoundModifier::None,
2771 TraitBoundModifier::Maybe(_binding_0) => {
2772 TraitBoundModifier::Maybe(Token ! [ ? ](tokens_helper(f, &_binding_0.spans)))
2773 }
2774 }
2775 }
2776 #[cfg(feature = "full")]
fold_trait_item<F>(f: &mut F, node: TraitItem) -> TraitItem where F: Fold + ?Sized,2777 pub fn fold_trait_item<F>(f: &mut F, node: TraitItem) -> TraitItem
2778 where
2779 F: Fold + ?Sized,
2780 {
2781 match node {
2782 TraitItem::Const(_binding_0) => TraitItem::Const(f.fold_trait_item_const(_binding_0)),
2783 TraitItem::Method(_binding_0) => TraitItem::Method(f.fold_trait_item_method(_binding_0)),
2784 TraitItem::Type(_binding_0) => TraitItem::Type(f.fold_trait_item_type(_binding_0)),
2785 TraitItem::Macro(_binding_0) => TraitItem::Macro(f.fold_trait_item_macro(_binding_0)),
2786 TraitItem::Verbatim(_binding_0) => TraitItem::Verbatim(_binding_0),
2787 _ => unreachable!(),
2788 }
2789 }
2790 #[cfg(feature = "full")]
fold_trait_item_const<F>(f: &mut F, node: TraitItemConst) -> TraitItemConst where F: Fold + ?Sized,2791 pub fn fold_trait_item_const<F>(f: &mut F, node: TraitItemConst) -> TraitItemConst
2792 where
2793 F: Fold + ?Sized,
2794 {
2795 TraitItemConst {
2796 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
2797 const_token: Token![const](tokens_helper(f, &node.const_token.span)),
2798 ident: f.fold_ident(node.ident),
2799 colon_token: Token ! [ : ](tokens_helper(f, &node.colon_token.spans)),
2800 ty: f.fold_type(node.ty),
2801 default: (node.default).map(|it| {
2802 (
2803 Token ! [ = ](tokens_helper(f, &(it).0.spans)),
2804 f.fold_expr((it).1),
2805 )
2806 }),
2807 semi_token: Token ! [ ; ](tokens_helper(f, &node.semi_token.spans)),
2808 }
2809 }
2810 #[cfg(feature = "full")]
fold_trait_item_macro<F>(f: &mut F, node: TraitItemMacro) -> TraitItemMacro where F: Fold + ?Sized,2811 pub fn fold_trait_item_macro<F>(f: &mut F, node: TraitItemMacro) -> TraitItemMacro
2812 where
2813 F: Fold + ?Sized,
2814 {
2815 TraitItemMacro {
2816 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
2817 mac: f.fold_macro(node.mac),
2818 semi_token: (node.semi_token).map(|it| Token ! [ ; ](tokens_helper(f, &it.spans))),
2819 }
2820 }
2821 #[cfg(feature = "full")]
fold_trait_item_method<F>(f: &mut F, node: TraitItemMethod) -> TraitItemMethod where F: Fold + ?Sized,2822 pub fn fold_trait_item_method<F>(f: &mut F, node: TraitItemMethod) -> TraitItemMethod
2823 where
2824 F: Fold + ?Sized,
2825 {
2826 TraitItemMethod {
2827 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
2828 sig: f.fold_signature(node.sig),
2829 default: (node.default).map(|it| f.fold_block(it)),
2830 semi_token: (node.semi_token).map(|it| Token ! [ ; ](tokens_helper(f, &it.spans))),
2831 }
2832 }
2833 #[cfg(feature = "full")]
fold_trait_item_type<F>(f: &mut F, node: TraitItemType) -> TraitItemType where F: Fold + ?Sized,2834 pub fn fold_trait_item_type<F>(f: &mut F, node: TraitItemType) -> TraitItemType
2835 where
2836 F: Fold + ?Sized,
2837 {
2838 TraitItemType {
2839 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
2840 type_token: Token![type](tokens_helper(f, &node.type_token.span)),
2841 ident: f.fold_ident(node.ident),
2842 generics: f.fold_generics(node.generics),
2843 colon_token: (node.colon_token).map(|it| Token ! [ : ](tokens_helper(f, &it.spans))),
2844 bounds: FoldHelper::lift(node.bounds, |it| f.fold_type_param_bound(it)),
2845 default: (node.default).map(|it| {
2846 (
2847 Token ! [ = ](tokens_helper(f, &(it).0.spans)),
2848 f.fold_type((it).1),
2849 )
2850 }),
2851 semi_token: Token ! [ ; ](tokens_helper(f, &node.semi_token.spans)),
2852 }
2853 }
2854 #[cfg(any(feature = "derive", feature = "full"))]
fold_type<F>(f: &mut F, node: Type) -> Type where F: Fold + ?Sized,2855 pub fn fold_type<F>(f: &mut F, node: Type) -> Type
2856 where
2857 F: Fold + ?Sized,
2858 {
2859 match node {
2860 Type::Array(_binding_0) => Type::Array(f.fold_type_array(_binding_0)),
2861 Type::BareFn(_binding_0) => Type::BareFn(f.fold_type_bare_fn(_binding_0)),
2862 Type::Group(_binding_0) => Type::Group(f.fold_type_group(_binding_0)),
2863 Type::ImplTrait(_binding_0) => Type::ImplTrait(f.fold_type_impl_trait(_binding_0)),
2864 Type::Infer(_binding_0) => Type::Infer(f.fold_type_infer(_binding_0)),
2865 Type::Macro(_binding_0) => Type::Macro(f.fold_type_macro(_binding_0)),
2866 Type::Never(_binding_0) => Type::Never(f.fold_type_never(_binding_0)),
2867 Type::Paren(_binding_0) => Type::Paren(f.fold_type_paren(_binding_0)),
2868 Type::Path(_binding_0) => Type::Path(f.fold_type_path(_binding_0)),
2869 Type::Ptr(_binding_0) => Type::Ptr(f.fold_type_ptr(_binding_0)),
2870 Type::Reference(_binding_0) => Type::Reference(f.fold_type_reference(_binding_0)),
2871 Type::Slice(_binding_0) => Type::Slice(f.fold_type_slice(_binding_0)),
2872 Type::TraitObject(_binding_0) => Type::TraitObject(f.fold_type_trait_object(_binding_0)),
2873 Type::Tuple(_binding_0) => Type::Tuple(f.fold_type_tuple(_binding_0)),
2874 Type::Verbatim(_binding_0) => Type::Verbatim(_binding_0),
2875 _ => unreachable!(),
2876 }
2877 }
2878 #[cfg(any(feature = "derive", feature = "full"))]
fold_type_array<F>(f: &mut F, node: TypeArray) -> TypeArray where F: Fold + ?Sized,2879 pub fn fold_type_array<F>(f: &mut F, node: TypeArray) -> TypeArray
2880 where
2881 F: Fold + ?Sized,
2882 {
2883 TypeArray {
2884 bracket_token: Bracket(tokens_helper(f, &node.bracket_token.span)),
2885 elem: Box::new(f.fold_type(*node.elem)),
2886 semi_token: Token ! [ ; ](tokens_helper(f, &node.semi_token.spans)),
2887 len: f.fold_expr(node.len),
2888 }
2889 }
2890 #[cfg(any(feature = "derive", feature = "full"))]
fold_type_bare_fn<F>(f: &mut F, node: TypeBareFn) -> TypeBareFn where F: Fold + ?Sized,2891 pub fn fold_type_bare_fn<F>(f: &mut F, node: TypeBareFn) -> TypeBareFn
2892 where
2893 F: Fold + ?Sized,
2894 {
2895 TypeBareFn {
2896 lifetimes: (node.lifetimes).map(|it| f.fold_bound_lifetimes(it)),
2897 unsafety: (node.unsafety).map(|it| Token![unsafe](tokens_helper(f, &it.span))),
2898 abi: (node.abi).map(|it| f.fold_abi(it)),
2899 fn_token: Token![fn](tokens_helper(f, &node.fn_token.span)),
2900 paren_token: Paren(tokens_helper(f, &node.paren_token.span)),
2901 inputs: FoldHelper::lift(node.inputs, |it| f.fold_bare_fn_arg(it)),
2902 variadic: (node.variadic).map(|it| f.fold_variadic(it)),
2903 output: f.fold_return_type(node.output),
2904 }
2905 }
2906 #[cfg(any(feature = "derive", feature = "full"))]
fold_type_group<F>(f: &mut F, node: TypeGroup) -> TypeGroup where F: Fold + ?Sized,2907 pub fn fold_type_group<F>(f: &mut F, node: TypeGroup) -> TypeGroup
2908 where
2909 F: Fold + ?Sized,
2910 {
2911 TypeGroup {
2912 group_token: Group(tokens_helper(f, &node.group_token.span)),
2913 elem: Box::new(f.fold_type(*node.elem)),
2914 }
2915 }
2916 #[cfg(any(feature = "derive", feature = "full"))]
fold_type_impl_trait<F>(f: &mut F, node: TypeImplTrait) -> TypeImplTrait where F: Fold + ?Sized,2917 pub fn fold_type_impl_trait<F>(f: &mut F, node: TypeImplTrait) -> TypeImplTrait
2918 where
2919 F: Fold + ?Sized,
2920 {
2921 TypeImplTrait {
2922 impl_token: Token![impl](tokens_helper(f, &node.impl_token.span)),
2923 bounds: FoldHelper::lift(node.bounds, |it| f.fold_type_param_bound(it)),
2924 }
2925 }
2926 #[cfg(any(feature = "derive", feature = "full"))]
fold_type_infer<F>(f: &mut F, node: TypeInfer) -> TypeInfer where F: Fold + ?Sized,2927 pub fn fold_type_infer<F>(f: &mut F, node: TypeInfer) -> TypeInfer
2928 where
2929 F: Fold + ?Sized,
2930 {
2931 TypeInfer {
2932 underscore_token: Token![_](tokens_helper(f, &node.underscore_token.spans)),
2933 }
2934 }
2935 #[cfg(any(feature = "derive", feature = "full"))]
fold_type_macro<F>(f: &mut F, node: TypeMacro) -> TypeMacro where F: Fold + ?Sized,2936 pub fn fold_type_macro<F>(f: &mut F, node: TypeMacro) -> TypeMacro
2937 where
2938 F: Fold + ?Sized,
2939 {
2940 TypeMacro {
2941 mac: f.fold_macro(node.mac),
2942 }
2943 }
2944 #[cfg(any(feature = "derive", feature = "full"))]
fold_type_never<F>(f: &mut F, node: TypeNever) -> TypeNever where F: Fold + ?Sized,2945 pub fn fold_type_never<F>(f: &mut F, node: TypeNever) -> TypeNever
2946 where
2947 F: Fold + ?Sized,
2948 {
2949 TypeNever {
2950 bang_token: Token![!](tokens_helper(f, &node.bang_token.spans)),
2951 }
2952 }
2953 #[cfg(any(feature = "derive", feature = "full"))]
fold_type_param<F>(f: &mut F, node: TypeParam) -> TypeParam where F: Fold + ?Sized,2954 pub fn fold_type_param<F>(f: &mut F, node: TypeParam) -> TypeParam
2955 where
2956 F: Fold + ?Sized,
2957 {
2958 TypeParam {
2959 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
2960 ident: f.fold_ident(node.ident),
2961 colon_token: (node.colon_token).map(|it| Token ! [ : ](tokens_helper(f, &it.spans))),
2962 bounds: FoldHelper::lift(node.bounds, |it| f.fold_type_param_bound(it)),
2963 eq_token: (node.eq_token).map(|it| Token ! [ = ](tokens_helper(f, &it.spans))),
2964 default: (node.default).map(|it| f.fold_type(it)),
2965 }
2966 }
2967 #[cfg(any(feature = "derive", feature = "full"))]
fold_type_param_bound<F>(f: &mut F, node: TypeParamBound) -> TypeParamBound where F: Fold + ?Sized,2968 pub fn fold_type_param_bound<F>(f: &mut F, node: TypeParamBound) -> TypeParamBound
2969 where
2970 F: Fold + ?Sized,
2971 {
2972 match node {
2973 TypeParamBound::Trait(_binding_0) => TypeParamBound::Trait(f.fold_trait_bound(_binding_0)),
2974 TypeParamBound::Lifetime(_binding_0) => {
2975 TypeParamBound::Lifetime(f.fold_lifetime(_binding_0))
2976 }
2977 }
2978 }
2979 #[cfg(any(feature = "derive", feature = "full"))]
fold_type_paren<F>(f: &mut F, node: TypeParen) -> TypeParen where F: Fold + ?Sized,2980 pub fn fold_type_paren<F>(f: &mut F, node: TypeParen) -> TypeParen
2981 where
2982 F: Fold + ?Sized,
2983 {
2984 TypeParen {
2985 paren_token: Paren(tokens_helper(f, &node.paren_token.span)),
2986 elem: Box::new(f.fold_type(*node.elem)),
2987 }
2988 }
2989 #[cfg(any(feature = "derive", feature = "full"))]
fold_type_path<F>(f: &mut F, node: TypePath) -> TypePath where F: Fold + ?Sized,2990 pub fn fold_type_path<F>(f: &mut F, node: TypePath) -> TypePath
2991 where
2992 F: Fold + ?Sized,
2993 {
2994 TypePath {
2995 qself: (node.qself).map(|it| f.fold_qself(it)),
2996 path: f.fold_path(node.path),
2997 }
2998 }
2999 #[cfg(any(feature = "derive", feature = "full"))]
fold_type_ptr<F>(f: &mut F, node: TypePtr) -> TypePtr where F: Fold + ?Sized,3000 pub fn fold_type_ptr<F>(f: &mut F, node: TypePtr) -> TypePtr
3001 where
3002 F: Fold + ?Sized,
3003 {
3004 TypePtr {
3005 star_token: Token ! [ * ](tokens_helper(f, &node.star_token.spans)),
3006 const_token: (node.const_token).map(|it| Token![const](tokens_helper(f, &it.span))),
3007 mutability: (node.mutability).map(|it| Token![mut](tokens_helper(f, &it.span))),
3008 elem: Box::new(f.fold_type(*node.elem)),
3009 }
3010 }
3011 #[cfg(any(feature = "derive", feature = "full"))]
fold_type_reference<F>(f: &mut F, node: TypeReference) -> TypeReference where F: Fold + ?Sized,3012 pub fn fold_type_reference<F>(f: &mut F, node: TypeReference) -> TypeReference
3013 where
3014 F: Fold + ?Sized,
3015 {
3016 TypeReference {
3017 and_token: Token ! [ & ](tokens_helper(f, &node.and_token.spans)),
3018 lifetime: (node.lifetime).map(|it| f.fold_lifetime(it)),
3019 mutability: (node.mutability).map(|it| Token![mut](tokens_helper(f, &it.span))),
3020 elem: Box::new(f.fold_type(*node.elem)),
3021 }
3022 }
3023 #[cfg(any(feature = "derive", feature = "full"))]
fold_type_slice<F>(f: &mut F, node: TypeSlice) -> TypeSlice where F: Fold + ?Sized,3024 pub fn fold_type_slice<F>(f: &mut F, node: TypeSlice) -> TypeSlice
3025 where
3026 F: Fold + ?Sized,
3027 {
3028 TypeSlice {
3029 bracket_token: Bracket(tokens_helper(f, &node.bracket_token.span)),
3030 elem: Box::new(f.fold_type(*node.elem)),
3031 }
3032 }
3033 #[cfg(any(feature = "derive", feature = "full"))]
fold_type_trait_object<F>(f: &mut F, node: TypeTraitObject) -> TypeTraitObject where F: Fold + ?Sized,3034 pub fn fold_type_trait_object<F>(f: &mut F, node: TypeTraitObject) -> TypeTraitObject
3035 where
3036 F: Fold + ?Sized,
3037 {
3038 TypeTraitObject {
3039 dyn_token: (node.dyn_token).map(|it| Token![dyn](tokens_helper(f, &it.span))),
3040 bounds: FoldHelper::lift(node.bounds, |it| f.fold_type_param_bound(it)),
3041 }
3042 }
3043 #[cfg(any(feature = "derive", feature = "full"))]
fold_type_tuple<F>(f: &mut F, node: TypeTuple) -> TypeTuple where F: Fold + ?Sized,3044 pub fn fold_type_tuple<F>(f: &mut F, node: TypeTuple) -> TypeTuple
3045 where
3046 F: Fold + ?Sized,
3047 {
3048 TypeTuple {
3049 paren_token: Paren(tokens_helper(f, &node.paren_token.span)),
3050 elems: FoldHelper::lift(node.elems, |it| f.fold_type(it)),
3051 }
3052 }
3053 #[cfg(any(feature = "derive", feature = "full"))]
fold_un_op<F>(f: &mut F, node: UnOp) -> UnOp where F: Fold + ?Sized,3054 pub fn fold_un_op<F>(f: &mut F, node: UnOp) -> UnOp
3055 where
3056 F: Fold + ?Sized,
3057 {
3058 match node {
3059 UnOp::Deref(_binding_0) => UnOp::Deref(Token ! [ * ](tokens_helper(f, &_binding_0.spans))),
3060 UnOp::Not(_binding_0) => UnOp::Not(Token![!](tokens_helper(f, &_binding_0.spans))),
3061 UnOp::Neg(_binding_0) => UnOp::Neg(Token ! [ - ](tokens_helper(f, &_binding_0.spans))),
3062 }
3063 }
3064 #[cfg(feature = "full")]
fold_use_glob<F>(f: &mut F, node: UseGlob) -> UseGlob where F: Fold + ?Sized,3065 pub fn fold_use_glob<F>(f: &mut F, node: UseGlob) -> UseGlob
3066 where
3067 F: Fold + ?Sized,
3068 {
3069 UseGlob {
3070 star_token: Token ! [ * ](tokens_helper(f, &node.star_token.spans)),
3071 }
3072 }
3073 #[cfg(feature = "full")]
fold_use_group<F>(f: &mut F, node: UseGroup) -> UseGroup where F: Fold + ?Sized,3074 pub fn fold_use_group<F>(f: &mut F, node: UseGroup) -> UseGroup
3075 where
3076 F: Fold + ?Sized,
3077 {
3078 UseGroup {
3079 brace_token: Brace(tokens_helper(f, &node.brace_token.span)),
3080 items: FoldHelper::lift(node.items, |it| f.fold_use_tree(it)),
3081 }
3082 }
3083 #[cfg(feature = "full")]
fold_use_name<F>(f: &mut F, node: UseName) -> UseName where F: Fold + ?Sized,3084 pub fn fold_use_name<F>(f: &mut F, node: UseName) -> UseName
3085 where
3086 F: Fold + ?Sized,
3087 {
3088 UseName {
3089 ident: f.fold_ident(node.ident),
3090 }
3091 }
3092 #[cfg(feature = "full")]
fold_use_path<F>(f: &mut F, node: UsePath) -> UsePath where F: Fold + ?Sized,3093 pub fn fold_use_path<F>(f: &mut F, node: UsePath) -> UsePath
3094 where
3095 F: Fold + ?Sized,
3096 {
3097 UsePath {
3098 ident: f.fold_ident(node.ident),
3099 colon2_token: Token ! [ :: ](tokens_helper(f, &node.colon2_token.spans)),
3100 tree: Box::new(f.fold_use_tree(*node.tree)),
3101 }
3102 }
3103 #[cfg(feature = "full")]
fold_use_rename<F>(f: &mut F, node: UseRename) -> UseRename where F: Fold + ?Sized,3104 pub fn fold_use_rename<F>(f: &mut F, node: UseRename) -> UseRename
3105 where
3106 F: Fold + ?Sized,
3107 {
3108 UseRename {
3109 ident: f.fold_ident(node.ident),
3110 as_token: Token![as](tokens_helper(f, &node.as_token.span)),
3111 rename: f.fold_ident(node.rename),
3112 }
3113 }
3114 #[cfg(feature = "full")]
fold_use_tree<F>(f: &mut F, node: UseTree) -> UseTree where F: Fold + ?Sized,3115 pub fn fold_use_tree<F>(f: &mut F, node: UseTree) -> UseTree
3116 where
3117 F: Fold + ?Sized,
3118 {
3119 match node {
3120 UseTree::Path(_binding_0) => UseTree::Path(f.fold_use_path(_binding_0)),
3121 UseTree::Name(_binding_0) => UseTree::Name(f.fold_use_name(_binding_0)),
3122 UseTree::Rename(_binding_0) => UseTree::Rename(f.fold_use_rename(_binding_0)),
3123 UseTree::Glob(_binding_0) => UseTree::Glob(f.fold_use_glob(_binding_0)),
3124 UseTree::Group(_binding_0) => UseTree::Group(f.fold_use_group(_binding_0)),
3125 }
3126 }
3127 #[cfg(any(feature = "derive", feature = "full"))]
fold_variadic<F>(f: &mut F, node: Variadic) -> Variadic where F: Fold + ?Sized,3128 pub fn fold_variadic<F>(f: &mut F, node: Variadic) -> Variadic
3129 where
3130 F: Fold + ?Sized,
3131 {
3132 Variadic {
3133 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
3134 dots: Token ! [ ... ](tokens_helper(f, &node.dots.spans)),
3135 }
3136 }
3137 #[cfg(any(feature = "derive", feature = "full"))]
fold_variant<F>(f: &mut F, node: Variant) -> Variant where F: Fold + ?Sized,3138 pub fn fold_variant<F>(f: &mut F, node: Variant) -> Variant
3139 where
3140 F: Fold + ?Sized,
3141 {
3142 Variant {
3143 attrs: FoldHelper::lift(node.attrs, |it| f.fold_attribute(it)),
3144 ident: f.fold_ident(node.ident),
3145 fields: f.fold_fields(node.fields),
3146 discriminant: (node.discriminant).map(|it| {
3147 (
3148 Token ! [ = ](tokens_helper(f, &(it).0.spans)),
3149 f.fold_expr((it).1),
3150 )
3151 }),
3152 }
3153 }
3154 #[cfg(any(feature = "derive", feature = "full"))]
fold_vis_crate<F>(f: &mut F, node: VisCrate) -> VisCrate where F: Fold + ?Sized,3155 pub fn fold_vis_crate<F>(f: &mut F, node: VisCrate) -> VisCrate
3156 where
3157 F: Fold + ?Sized,
3158 {
3159 VisCrate {
3160 crate_token: Token![crate](tokens_helper(f, &node.crate_token.span)),
3161 }
3162 }
3163 #[cfg(any(feature = "derive", feature = "full"))]
fold_vis_public<F>(f: &mut F, node: VisPublic) -> VisPublic where F: Fold + ?Sized,3164 pub fn fold_vis_public<F>(f: &mut F, node: VisPublic) -> VisPublic
3165 where
3166 F: Fold + ?Sized,
3167 {
3168 VisPublic {
3169 pub_token: Token![pub](tokens_helper(f, &node.pub_token.span)),
3170 }
3171 }
3172 #[cfg(any(feature = "derive", feature = "full"))]
fold_vis_restricted<F>(f: &mut F, node: VisRestricted) -> VisRestricted where F: Fold + ?Sized,3173 pub fn fold_vis_restricted<F>(f: &mut F, node: VisRestricted) -> VisRestricted
3174 where
3175 F: Fold + ?Sized,
3176 {
3177 VisRestricted {
3178 pub_token: Token![pub](tokens_helper(f, &node.pub_token.span)),
3179 paren_token: Paren(tokens_helper(f, &node.paren_token.span)),
3180 in_token: (node.in_token).map(|it| Token![in](tokens_helper(f, &it.span))),
3181 path: Box::new(f.fold_path(*node.path)),
3182 }
3183 }
3184 #[cfg(any(feature = "derive", feature = "full"))]
fold_visibility<F>(f: &mut F, node: Visibility) -> Visibility where F: Fold + ?Sized,3185 pub fn fold_visibility<F>(f: &mut F, node: Visibility) -> Visibility
3186 where
3187 F: Fold + ?Sized,
3188 {
3189 match node {
3190 Visibility::Public(_binding_0) => Visibility::Public(f.fold_vis_public(_binding_0)),
3191 Visibility::Crate(_binding_0) => Visibility::Crate(f.fold_vis_crate(_binding_0)),
3192 Visibility::Restricted(_binding_0) => {
3193 Visibility::Restricted(f.fold_vis_restricted(_binding_0))
3194 }
3195 Visibility::Inherited => Visibility::Inherited,
3196 }
3197 }
3198 #[cfg(any(feature = "derive", feature = "full"))]
fold_where_clause<F>(f: &mut F, node: WhereClause) -> WhereClause where F: Fold + ?Sized,3199 pub fn fold_where_clause<F>(f: &mut F, node: WhereClause) -> WhereClause
3200 where
3201 F: Fold + ?Sized,
3202 {
3203 WhereClause {
3204 where_token: Token![where](tokens_helper(f, &node.where_token.span)),
3205 predicates: FoldHelper::lift(node.predicates, |it| f.fold_where_predicate(it)),
3206 }
3207 }
3208 #[cfg(any(feature = "derive", feature = "full"))]
fold_where_predicate<F>(f: &mut F, node: WherePredicate) -> WherePredicate where F: Fold + ?Sized,3209 pub fn fold_where_predicate<F>(f: &mut F, node: WherePredicate) -> WherePredicate
3210 where
3211 F: Fold + ?Sized,
3212 {
3213 match node {
3214 WherePredicate::Type(_binding_0) => WherePredicate::Type(f.fold_predicate_type(_binding_0)),
3215 WherePredicate::Lifetime(_binding_0) => {
3216 WherePredicate::Lifetime(f.fold_predicate_lifetime(_binding_0))
3217 }
3218 WherePredicate::Eq(_binding_0) => WherePredicate::Eq(f.fold_predicate_eq(_binding_0)),
3219 }
3220 }
3221