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