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