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