Debian Codegraph @

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