Debian Codegraph @

.cargo/vendor/syn/src/gen/visit.rs

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