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