syn/gen/
visit.rs

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