1// This file is @generated by syn-internal-codegen.
2// It is not intended for manual editing.
3
4#![allow(unused_variables)]
5#![allow(clippy::needless_pass_by_ref_mut)]
6#[cfg(any(feature = "full", feature = "derive"))]
7use crate::punctuated::Punctuated;
8#[cfg(feature = "full")]
9macro_rules! full {
10 ($e:expr) => {
11 $e
12 };
13}
14#[cfg(all(feature = "derive", not(feature = "full")))]
15macro_rules! full {
16 ($e:expr) => {
17 unreachable!()
18 };
19}
20macro_rules! skip {
21 ($($tt:tt)*) => {};
22}
23/// Syntax tree traversal to walk a shared borrow of a syntax tree.
24///
25/// See the [module documentation] for details.
26///
27/// [module documentation]: self
28pub trait Visit<'ast> {
29 #[cfg(any(feature = "derive", feature = "full"))]
30 #[cfg_attr(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"))))]
949pub fn visit_abi<'ast, V>(v: &mut V, node: &'ast crate::Abi)
950where
951 V: Visit<'ast> + ?Sized,
952{
953 skip!(node.extern_token);
954 if let Some(it: &LitStr) = &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"))))]
960pub fn visit_angle_bracketed_generic_arguments<'ast, V>(
961 v: &mut V,
962 node: &'ast crate::AngleBracketedGenericArguments,
963)
964where
965 V: Visit<'ast> + ?Sized,
966{
967 skip!(node.colon2_token);
968 skip!(node.lt_token);
969 for el: Pair<&GenericArgument, &Comma> in Punctuated::pairs(&node.args) {
970 let it: &&GenericArgument = 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")))]
977pub fn visit_arm<'ast, V>(v: &mut V, node: &'ast crate::Arm)
978where
979 V: Visit<'ast> + ?Sized,
980{
981 for it: &Attribute in &node.attrs {
982 v.visit_attribute(it);
983 }
984 v.visit_pat(&node.pat);
985 if let Some(it: &(If, Box)) = &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"))))]
995pub fn visit_assoc_const<'ast, V>(v: &mut V, node: &'ast crate::AssocConst)
996where
997 V: Visit<'ast> + ?Sized,
998{
999 v.visit_ident(&node.ident);
1000 if let Some(it: &AngleBracketedGenericArguments) = &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"))))]
1008pub fn visit_assoc_type<'ast, V>(v: &mut V, node: &'ast crate::AssocType)
1009where
1010 V: Visit<'ast> + ?Sized,
1011{
1012 v.visit_ident(&node.ident);
1013 if let Some(it: &AngleBracketedGenericArguments) = &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"))))]
1021pub fn visit_attr_style<'ast, V>(v: &mut V, node: &'ast crate::AttrStyle)
1022where
1023 V: Visit<'ast> + ?Sized,
1024{
1025 match node {
1026 crate::AttrStyle::Outer => {}
1027 crate::AttrStyle::Inner(_binding_0: &Not) => {
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"))))]
1034pub fn visit_attribute<'ast, V>(v: &mut V, node: &'ast crate::Attribute)
1035where
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"))))]
1045pub fn visit_bare_fn_arg<'ast, V>(v: &mut V, node: &'ast crate::BareFnArg)
1046where
1047 V: Visit<'ast> + ?Sized,
1048{
1049 for it: &Attribute in &node.attrs {
1050 v.visit_attribute(it);
1051 }
1052 if let Some(it: &(Ident, Colon)) = &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"))))]
1060pub fn visit_bare_variadic<'ast, V>(v: &mut V, node: &'ast crate::BareVariadic)
1061where
1062 V: Visit<'ast> + ?Sized,
1063{
1064 for it: &Attribute in &node.attrs {
1065 v.visit_attribute(it);
1066 }
1067 if let Some(it: &(Ident, Colon)) = &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"))))]
1076pub fn visit_bin_op<'ast, V>(v: &mut V, node: &'ast crate::BinOp)
1077where
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")))]
1169pub fn visit_block<'ast, V>(v: &mut V, node: &'ast crate::Block)
1170where
1171 V: Visit<'ast> + ?Sized,
1172{
1173 skip!(node.brace_token);
1174 for it: &Stmt 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"))))]
1180pub fn visit_bound_lifetimes<'ast, V>(v: &mut V, node: &'ast crate::BoundLifetimes)
1181where
1182 V: Visit<'ast> + ?Sized,
1183{
1184 skip!(node.for_token);
1185 skip!(node.lt_token);
1186 for el: Pair<&GenericParam, &Comma> in Punctuated::pairs(&node.lifetimes) {
1187 let it: &&GenericParam = 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")))]
1194pub fn visit_captured_param<'ast, V>(v: &mut V, node: &'ast crate::CapturedParam)
1195where
1196 V: Visit<'ast> + ?Sized,
1197{
1198 match node {
1199 crate::CapturedParam::Lifetime(_binding_0: &Lifetime) => {
1200 v.visit_lifetime(_binding_0);
1201 }
1202 crate::CapturedParam::Ident(_binding_0: &Ident) => {
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"))))]
1209pub fn visit_const_param<'ast, V>(v: &mut V, node: &'ast crate::ConstParam)
1210where
1211 V: Visit<'ast> + ?Sized,
1212{
1213 for it: &Attribute 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: &Expr) = &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"))))]
1227pub fn visit_constraint<'ast, V>(v: &mut V, node: &'ast crate::Constraint)
1228where
1229 V: Visit<'ast> + ?Sized,
1230{
1231 v.visit_ident(&node.ident);
1232 if let Some(it: &AngleBracketedGenericArguments) = &node.generics {
1233 v.visit_angle_bracketed_generic_arguments(it);
1234 }
1235 skip!(node.colon_token);
1236 for el: Pair<&TypeParamBound, &Plus> in Punctuated::pairs(&node.bounds) {
1237 let it: &&TypeParamBound = el.value();
1238 v.visit_type_param_bound(it);
1239 }
1240}
1241#[cfg(feature = "derive")]
1242#[cfg_attr(docsrs, doc(cfg(feature = "derive")))]
1243pub fn visit_data<'ast, V>(v: &mut V, node: &'ast crate::Data)
1244where
1245 V: Visit<'ast> + ?Sized,
1246{
1247 match node {
1248 crate::Data::Struct(_binding_0: &DataStruct) => {
1249 v.visit_data_struct(_binding_0);
1250 }
1251 crate::Data::Enum(_binding_0: &DataEnum) => {
1252 v.visit_data_enum(_binding_0);
1253 }
1254 crate::Data::Union(_binding_0: &DataUnion) => {
1255 v.visit_data_union(_binding_0);
1256 }
1257 }
1258}
1259#[cfg(feature = "derive")]
1260#[cfg_attr(docsrs, doc(cfg(feature = "derive")))]
1261pub fn visit_data_enum<'ast, V>(v: &mut V, node: &'ast crate::DataEnum)
1262where
1263 V: Visit<'ast> + ?Sized,
1264{
1265 skip!(node.enum_token);
1266 skip!(node.brace_token);
1267 for el: Pair<&Variant, &Comma> in Punctuated::pairs(&node.variants) {
1268 let it: &&Variant = el.value();
1269 v.visit_variant(it);
1270 }
1271}
1272#[cfg(feature = "derive")]
1273#[cfg_attr(docsrs, doc(cfg(feature = "derive")))]
1274pub fn visit_data_struct<'ast, V>(v: &mut V, node: &'ast crate::DataStruct)
1275where
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")))]
1284pub fn visit_data_union<'ast, V>(v: &mut V, node: &'ast crate::DataUnion)
1285where
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")))]
1293pub fn visit_derive_input<'ast, V>(v: &mut V, node: &'ast crate::DeriveInput)
1294where
1295 V: Visit<'ast> + ?Sized,
1296{
1297 for it: &Attribute 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"))))]
1307pub fn visit_expr<'ast, V>(v: &mut V, node: &'ast crate::Expr)
1308where
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")))]
1436pub fn visit_expr_array<'ast, V>(v: &mut V, node: &'ast crate::ExprArray)
1437where
1438 V: Visit<'ast> + ?Sized,
1439{
1440 for it: &Attribute in &node.attrs {
1441 v.visit_attribute(it);
1442 }
1443 skip!(node.bracket_token);
1444 for el: Pair<&Expr, &Comma> in Punctuated::pairs(&node.elems) {
1445 let it: &&Expr = el.value();
1446 v.visit_expr(it);
1447 }
1448}
1449#[cfg(feature = "full")]
1450#[cfg_attr(docsrs, doc(cfg(feature = "full")))]
1451pub fn visit_expr_assign<'ast, V>(v: &mut V, node: &'ast crate::ExprAssign)
1452where
1453 V: Visit<'ast> + ?Sized,
1454{
1455 for it: &Attribute 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")))]
1464pub fn visit_expr_async<'ast, V>(v: &mut V, node: &'ast crate::ExprAsync)
1465where
1466 V: Visit<'ast> + ?Sized,
1467{
1468 for it: &Attribute 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")))]
1477pub fn visit_expr_await<'ast, V>(v: &mut V, node: &'ast crate::ExprAwait)
1478where
1479 V: Visit<'ast> + ?Sized,
1480{
1481 for it: &Attribute 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"))))]
1490pub fn visit_expr_binary<'ast, V>(v: &mut V, node: &'ast crate::ExprBinary)
1491where
1492 V: Visit<'ast> + ?Sized,
1493{
1494 for it: &Attribute 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")))]
1503pub fn visit_expr_block<'ast, V>(v: &mut V, node: &'ast crate::ExprBlock)
1504where
1505 V: Visit<'ast> + ?Sized,
1506{
1507 for it: &Attribute in &node.attrs {
1508 v.visit_attribute(it);
1509 }
1510 if let Some(it: &Label) = &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")))]
1517pub fn visit_expr_break<'ast, V>(v: &mut V, node: &'ast crate::ExprBreak)
1518where
1519 V: Visit<'ast> + ?Sized,
1520{
1521 for it: &Attribute in &node.attrs {
1522 v.visit_attribute(it);
1523 }
1524 skip!(node.break_token);
1525 if let Some(it: &Lifetime) = &node.label {
1526 v.visit_lifetime(it);
1527 }
1528 if let Some(it: &Box) = &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"))))]
1534pub fn visit_expr_call<'ast, V>(v: &mut V, node: &'ast crate::ExprCall)
1535where
1536 V: Visit<'ast> + ?Sized,
1537{
1538 for it: &Attribute in &node.attrs {
1539 v.visit_attribute(it);
1540 }
1541 v.visit_expr(&*node.func);
1542 skip!(node.paren_token);
1543 for el: Pair<&Expr, &Comma> in Punctuated::pairs(&node.args) {
1544 let it: &&Expr = 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"))))]
1550pub fn visit_expr_cast<'ast, V>(v: &mut V, node: &'ast crate::ExprCast)
1551where
1552 V: Visit<'ast> + ?Sized,
1553{
1554 for it: &Attribute 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")))]
1563pub fn visit_expr_closure<'ast, V>(v: &mut V, node: &'ast crate::ExprClosure)
1564where
1565 V: Visit<'ast> + ?Sized,
1566{
1567 for it: &Attribute in &node.attrs {
1568 v.visit_attribute(it);
1569 }
1570 if let Some(it: &BoundLifetimes) = &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: Pair<&Pat, &Comma> in Punctuated::pairs(&node.inputs) {
1579 let it: &&Pat = 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")))]
1588pub fn visit_expr_const<'ast, V>(v: &mut V, node: &'ast crate::ExprConst)
1589where
1590 V: Visit<'ast> + ?Sized,
1591{
1592 for it: &Attribute 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")))]
1600pub fn visit_expr_continue<'ast, V>(v: &mut V, node: &'ast crate::ExprContinue)
1601where
1602 V: Visit<'ast> + ?Sized,
1603{
1604 for it: &Attribute in &node.attrs {
1605 v.visit_attribute(it);
1606 }
1607 skip!(node.continue_token);
1608 if let Some(it: &Lifetime) = &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"))))]
1614pub fn visit_expr_field<'ast, V>(v: &mut V, node: &'ast crate::ExprField)
1615where
1616 V: Visit<'ast> + ?Sized,
1617{
1618 for it: &Attribute 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")))]
1627pub fn visit_expr_for_loop<'ast, V>(v: &mut V, node: &'ast crate::ExprForLoop)
1628where
1629 V: Visit<'ast> + ?Sized,
1630{
1631 for it: &Attribute in &node.attrs {
1632 v.visit_attribute(it);
1633 }
1634 if let Some(it: &Label) = &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"))))]
1645pub fn visit_expr_group<'ast, V>(v: &mut V, node: &'ast crate::ExprGroup)
1646where
1647 V: Visit<'ast> + ?Sized,
1648{
1649 for it: &Attribute 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")))]
1657pub fn visit_expr_if<'ast, V>(v: &mut V, node: &'ast crate::ExprIf)
1658where
1659 V: Visit<'ast> + ?Sized,
1660{
1661 for it: &Attribute 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: &(Else, Box)) = &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"))))]
1674pub fn visit_expr_index<'ast, V>(v: &mut V, node: &'ast crate::ExprIndex)
1675where
1676 V: Visit<'ast> + ?Sized,
1677{
1678 for it: &Attribute 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")))]
1687pub fn visit_expr_infer<'ast, V>(v: &mut V, node: &'ast crate::ExprInfer)
1688where
1689 V: Visit<'ast> + ?Sized,
1690{
1691 for it: &Attribute 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")))]
1698pub fn visit_expr_let<'ast, V>(v: &mut V, node: &'ast crate::ExprLet)
1699where
1700 V: Visit<'ast> + ?Sized,
1701{
1702 for it: &Attribute 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"))))]
1712pub fn visit_expr_lit<'ast, V>(v: &mut V, node: &'ast crate::ExprLit)
1713where
1714 V: Visit<'ast> + ?Sized,
1715{
1716 for it: &Attribute 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")))]
1723pub fn visit_expr_loop<'ast, V>(v: &mut V, node: &'ast crate::ExprLoop)
1724where
1725 V: Visit<'ast> + ?Sized,
1726{
1727 for it: &Attribute in &node.attrs {
1728 v.visit_attribute(it);
1729 }
1730 if let Some(it: &Label) = &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"))))]
1738pub fn visit_expr_macro<'ast, V>(v: &mut V, node: &'ast crate::ExprMacro)
1739where
1740 V: Visit<'ast> + ?Sized,
1741{
1742 for it: &Attribute 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")))]
1749pub fn visit_expr_match<'ast, V>(v: &mut V, node: &'ast crate::ExprMatch)
1750where
1751 V: Visit<'ast> + ?Sized,
1752{
1753 for it: &Attribute 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: &Arm 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"))))]
1765pub fn visit_expr_method_call<'ast, V>(v: &mut V, node: &'ast crate::ExprMethodCall)
1766where
1767 V: Visit<'ast> + ?Sized,
1768{
1769 for it: &Attribute 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: &AngleBracketedGenericArguments) = &node.turbofish {
1776 v.visit_angle_bracketed_generic_arguments(it);
1777 }
1778 skip!(node.paren_token);
1779 for el: Pair<&Expr, &Comma> in Punctuated::pairs(&node.args) {
1780 let it: &&Expr = 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"))))]
1786pub fn visit_expr_paren<'ast, V>(v: &mut V, node: &'ast crate::ExprParen)
1787where
1788 V: Visit<'ast> + ?Sized,
1789{
1790 for it: &Attribute 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"))))]
1798pub fn visit_expr_path<'ast, V>(v: &mut V, node: &'ast crate::ExprPath)
1799where
1800 V: Visit<'ast> + ?Sized,
1801{
1802 for it: &Attribute in &node.attrs {
1803 v.visit_attribute(it);
1804 }
1805 if let Some(it: &QSelf) = &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")))]
1812pub fn visit_expr_range<'ast, V>(v: &mut V, node: &'ast crate::ExprRange)
1813where
1814 V: Visit<'ast> + ?Sized,
1815{
1816 for it: &Attribute in &node.attrs {
1817 v.visit_attribute(it);
1818 }
1819 if let Some(it: &Box) = &node.start {
1820 v.visit_expr(&**it);
1821 }
1822 v.visit_range_limits(&node.limits);
1823 if let Some(it: &Box) = &node.end {
1824 v.visit_expr(&**it);
1825 }
1826}
1827#[cfg(feature = "full")]
1828#[cfg_attr(docsrs, doc(cfg(feature = "full")))]
1829pub fn visit_expr_raw_addr<'ast, V>(v: &mut V, node: &'ast crate::ExprRawAddr)
1830where
1831 V: Visit<'ast> + ?Sized,
1832{
1833 for it: &Attribute 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"))))]
1843pub fn visit_expr_reference<'ast, V>(v: &mut V, node: &'ast crate::ExprReference)
1844where
1845 V: Visit<'ast> + ?Sized,
1846{
1847 for it: &Attribute 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")))]
1856pub fn visit_expr_repeat<'ast, V>(v: &mut V, node: &'ast crate::ExprRepeat)
1857where
1858 V: Visit<'ast> + ?Sized,
1859{
1860 for it: &Attribute 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")))]
1870pub fn visit_expr_return<'ast, V>(v: &mut V, node: &'ast crate::ExprReturn)
1871where
1872 V: Visit<'ast> + ?Sized,
1873{
1874 for it: &Attribute in &node.attrs {
1875 v.visit_attribute(it);
1876 }
1877 skip!(node.return_token);
1878 if let Some(it: &Box) = &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"))))]
1884pub fn visit_expr_struct<'ast, V>(v: &mut V, node: &'ast crate::ExprStruct)
1885where
1886 V: Visit<'ast> + ?Sized,
1887{
1888 for it: &Attribute in &node.attrs {
1889 v.visit_attribute(it);
1890 }
1891 if let Some(it: &QSelf) = &node.qself {
1892 v.visit_qself(it);
1893 }
1894 v.visit_path(&node.path);
1895 skip!(node.brace_token);
1896 for el: Pair<&FieldValue, &Comma> in Punctuated::pairs(&node.fields) {
1897 let it: &&FieldValue = el.value();
1898 v.visit_field_value(it);
1899 }
1900 skip!(node.dot2_token);
1901 if let Some(it: &Box) = &node.rest {
1902 v.visit_expr(&**it);
1903 }
1904}
1905#[cfg(feature = "full")]
1906#[cfg_attr(docsrs, doc(cfg(feature = "full")))]
1907pub fn visit_expr_try<'ast, V>(v: &mut V, node: &'ast crate::ExprTry)
1908where
1909 V: Visit<'ast> + ?Sized,
1910{
1911 for it: &Attribute 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")))]
1919pub fn visit_expr_try_block<'ast, V>(v: &mut V, node: &'ast crate::ExprTryBlock)
1920where
1921 V: Visit<'ast> + ?Sized,
1922{
1923 for it: &Attribute 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"))))]
1931pub fn visit_expr_tuple<'ast, V>(v: &mut V, node: &'ast crate::ExprTuple)
1932where
1933 V: Visit<'ast> + ?Sized,
1934{
1935 for it: &Attribute in &node.attrs {
1936 v.visit_attribute(it);
1937 }
1938 skip!(node.paren_token);
1939 for el: Pair<&Expr, &Comma> in Punctuated::pairs(&node.elems) {
1940 let it: &&Expr = 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"))))]
1946pub fn visit_expr_unary<'ast, V>(v: &mut V, node: &'ast crate::ExprUnary)
1947where
1948 V: Visit<'ast> + ?Sized,
1949{
1950 for it: &Attribute 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")))]
1958pub fn visit_expr_unsafe<'ast, V>(v: &mut V, node: &'ast crate::ExprUnsafe)
1959where
1960 V: Visit<'ast> + ?Sized,
1961{
1962 for it: &Attribute 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")))]
1970pub fn visit_expr_while<'ast, V>(v: &mut V, node: &'ast crate::ExprWhile)
1971where
1972 V: Visit<'ast> + ?Sized,
1973{
1974 for it: &Attribute in &node.attrs {
1975 v.visit_attribute(it);
1976 }
1977 if let Some(it: &Label) = &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")))]
1986pub fn visit_expr_yield<'ast, V>(v: &mut V, node: &'ast crate::ExprYield)
1987where
1988 V: Visit<'ast> + ?Sized,
1989{
1990 for it: &Attribute in &node.attrs {
1991 v.visit_attribute(it);
1992 }
1993 skip!(node.yield_token);
1994 if let Some(it: &Box) = &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"))))]
2000pub fn visit_field<'ast, V>(v: &mut V, node: &'ast crate::Field)
2001where
2002 V: Visit<'ast> + ?Sized,
2003{
2004 for it: &Attribute 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: &Ident) = &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"))))]
2017pub fn visit_field_mutability<'ast, V>(v: &mut V, node: &'ast crate::FieldMutability)
2018where
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")))]
2027pub fn visit_field_pat<'ast, V>(v: &mut V, node: &'ast crate::FieldPat)
2028where
2029 V: Visit<'ast> + ?Sized,
2030{
2031 for it: &Attribute 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"))))]
2040pub fn visit_field_value<'ast, V>(v: &mut V, node: &'ast crate::FieldValue)
2041where
2042 V: Visit<'ast> + ?Sized,
2043{
2044 for it: &Attribute 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"))))]
2053pub fn visit_fields<'ast, V>(v: &mut V, node: &'ast crate::Fields)
2054where
2055 V: Visit<'ast> + ?Sized,
2056{
2057 match node {
2058 crate::Fields::Named(_binding_0: &FieldsNamed) => {
2059 v.visit_fields_named(_binding_0);
2060 }
2061 crate::Fields::Unnamed(_binding_0: &FieldsUnnamed) => {
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"))))]
2069pub fn visit_fields_named<'ast, V>(v: &mut V, node: &'ast crate::FieldsNamed)
2070where
2071 V: Visit<'ast> + ?Sized,
2072{
2073 skip!(node.brace_token);
2074 for el: Pair<&Field, &Comma> in Punctuated::pairs(&node.named) {
2075 let it: &&Field = 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"))))]
2081pub fn visit_fields_unnamed<'ast, V>(v: &mut V, node: &'ast crate::FieldsUnnamed)
2082where
2083 V: Visit<'ast> + ?Sized,
2084{
2085 skip!(node.paren_token);
2086 for el: Pair<&Field, &Comma> in Punctuated::pairs(&node.unnamed) {
2087 let it: &&Field = el.value();
2088 v.visit_field(it);
2089 }
2090}
2091#[cfg(feature = "full")]
2092#[cfg_attr(docsrs, doc(cfg(feature = "full")))]
2093pub fn visit_file<'ast, V>(v: &mut V, node: &'ast crate::File)
2094where
2095 V: Visit<'ast> + ?Sized,
2096{
2097 skip!(node.shebang);
2098 for it: &Attribute in &node.attrs {
2099 v.visit_attribute(it);
2100 }
2101 for it: &Item in &node.items {
2102 v.visit_item(it);
2103 }
2104}
2105#[cfg(feature = "full")]
2106#[cfg_attr(docsrs, doc(cfg(feature = "full")))]
2107pub fn visit_fn_arg<'ast, V>(v: &mut V, node: &'ast crate::FnArg)
2108where
2109 V: Visit<'ast> + ?Sized,
2110{
2111 match node {
2112 crate::FnArg::Receiver(_binding_0: &Receiver) => {
2113 v.visit_receiver(_binding_0);
2114 }
2115 crate::FnArg::Typed(_binding_0: &PatType) => {
2116 v.visit_pat_type(_binding_0);
2117 }
2118 }
2119}
2120#[cfg(feature = "full")]
2121#[cfg_attr(docsrs, doc(cfg(feature = "full")))]
2122pub fn visit_foreign_item<'ast, V>(v: &mut V, node: &'ast crate::ForeignItem)
2123where
2124 V: Visit<'ast> + ?Sized,
2125{
2126 match node {
2127 crate::ForeignItem::Fn(_binding_0: &ForeignItemFn) => {
2128 v.visit_foreign_item_fn(_binding_0);
2129 }
2130 crate::ForeignItem::Static(_binding_0: &ForeignItemStatic) => {
2131 v.visit_foreign_item_static(_binding_0);
2132 }
2133 crate::ForeignItem::Type(_binding_0: &ForeignItemType) => {
2134 v.visit_foreign_item_type(_binding_0);
2135 }
2136 crate::ForeignItem::Macro(_binding_0: &ForeignItemMacro) => {
2137 v.visit_foreign_item_macro(_binding_0);
2138 }
2139 crate::ForeignItem::Verbatim(_binding_0: &TokenStream) => {
2140 skip!(_binding_0);
2141 }
2142 }
2143}
2144#[cfg(feature = "full")]
2145#[cfg_attr(docsrs, doc(cfg(feature = "full")))]
2146pub fn visit_foreign_item_fn<'ast, V>(v: &mut V, node: &'ast crate::ForeignItemFn)
2147where
2148 V: Visit<'ast> + ?Sized,
2149{
2150 for it: &Attribute 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")))]
2159pub fn visit_foreign_item_macro<'ast, V>(v: &mut V, node: &'ast crate::ForeignItemMacro)
2160where
2161 V: Visit<'ast> + ?Sized,
2162{
2163 for it: &Attribute 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")))]
2171pub fn visit_foreign_item_static<'ast, V>(
2172 v: &mut V,
2173 node: &'ast crate::ForeignItemStatic,
2174)
2175where
2176 V: Visit<'ast> + ?Sized,
2177{
2178 for it: &Attribute 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")))]
2191pub fn visit_foreign_item_type<'ast, V>(v: &mut V, node: &'ast crate::ForeignItemType)
2192where
2193 V: Visit<'ast> + ?Sized,
2194{
2195 for it: &Attribute 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"))))]
2206pub fn visit_generic_argument<'ast, V>(v: &mut V, node: &'ast crate::GenericArgument)
2207where
2208 V: Visit<'ast> + ?Sized,
2209{
2210 match node {
2211 crate::GenericArgument::Lifetime(_binding_0: &Lifetime) => {
2212 v.visit_lifetime(_binding_0);
2213 }
2214 crate::GenericArgument::Type(_binding_0: &Type) => {
2215 v.visit_type(_binding_0);
2216 }
2217 crate::GenericArgument::Const(_binding_0: &Expr) => {
2218 v.visit_expr(_binding_0);
2219 }
2220 crate::GenericArgument::AssocType(_binding_0: &AssocType) => {
2221 v.visit_assoc_type(_binding_0);
2222 }
2223 crate::GenericArgument::AssocConst(_binding_0: &AssocConst) => {
2224 v.visit_assoc_const(_binding_0);
2225 }
2226 crate::GenericArgument::Constraint(_binding_0: &Constraint) => {
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"))))]
2233pub fn visit_generic_param<'ast, V>(v: &mut V, node: &'ast crate::GenericParam)
2234where
2235 V: Visit<'ast> + ?Sized,
2236{
2237 match node {
2238 crate::GenericParam::Lifetime(_binding_0: &LifetimeParam) => {
2239 v.visit_lifetime_param(_binding_0);
2240 }
2241 crate::GenericParam::Type(_binding_0: &TypeParam) => {
2242 v.visit_type_param(_binding_0);
2243 }
2244 crate::GenericParam::Const(_binding_0: &ConstParam) => {
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"))))]
2251pub fn visit_generics<'ast, V>(v: &mut V, node: &'ast crate::Generics)
2252where
2253 V: Visit<'ast> + ?Sized,
2254{
2255 skip!(node.lt_token);
2256 for el: Pair<&GenericParam, &Comma> in Punctuated::pairs(&node.params) {
2257 let it: &&GenericParam = el.value();
2258 v.visit_generic_param(it);
2259 }
2260 skip!(node.gt_token);
2261 if let Some(it: &WhereClause) = &node.where_clause {
2262 v.visit_where_clause(it);
2263 }
2264}
2265pub fn visit_ident<'ast, V>(v: &mut V, node: &'ast proc_macro2::Ident)
2266where
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")))]
2273pub fn visit_impl_item<'ast, V>(v: &mut V, node: &'ast crate::ImplItem)
2274where
2275 V: Visit<'ast> + ?Sized,
2276{
2277 match node {
2278 crate::ImplItem::Const(_binding_0: &ImplItemConst) => {
2279 v.visit_impl_item_const(_binding_0);
2280 }
2281 crate::ImplItem::Fn(_binding_0: &ImplItemFn) => {
2282 v.visit_impl_item_fn(_binding_0);
2283 }
2284 crate::ImplItem::Type(_binding_0: &ImplItemType) => {
2285 v.visit_impl_item_type(_binding_0);
2286 }
2287 crate::ImplItem::Macro(_binding_0: &ImplItemMacro) => {
2288 v.visit_impl_item_macro(_binding_0);
2289 }
2290 crate::ImplItem::Verbatim(_binding_0: &TokenStream) => {
2291 skip!(_binding_0);
2292 }
2293 }
2294}
2295#[cfg(feature = "full")]
2296#[cfg_attr(docsrs, doc(cfg(feature = "full")))]
2297pub fn visit_impl_item_const<'ast, V>(v: &mut V, node: &'ast crate::ImplItemConst)
2298where
2299 V: Visit<'ast> + ?Sized,
2300{
2301 for it: &Attribute 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")))]
2317pub fn visit_impl_item_fn<'ast, V>(v: &mut V, node: &'ast crate::ImplItemFn)
2318where
2319 V: Visit<'ast> + ?Sized,
2320{
2321 for it: &Attribute 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")))]
2331pub fn visit_impl_item_macro<'ast, V>(v: &mut V, node: &'ast crate::ImplItemMacro)
2332where
2333 V: Visit<'ast> + ?Sized,
2334{
2335 for it: &Attribute 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")))]
2343pub fn visit_impl_item_type<'ast, V>(v: &mut V, node: &'ast crate::ImplItemType)
2344where
2345 V: Visit<'ast> + ?Sized,
2346{
2347 for it: &Attribute 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")))]
2361pub fn visit_impl_restriction<'ast, V>(v: &mut V, node: &'ast crate::ImplRestriction)
2362where
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"))))]
2369pub fn visit_index<'ast, V>(v: &mut V, node: &'ast crate::Index)
2370where
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")))]
2378pub fn visit_item<'ast, V>(v: &mut V, node: &'ast crate::Item)
2379where
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")))]
2435pub fn visit_item_const<'ast, V>(v: &mut V, node: &'ast crate::ItemConst)
2436where
2437 V: Visit<'ast> + ?Sized,
2438{
2439 for it: &Attribute 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")))]
2454pub fn visit_item_enum<'ast, V>(v: &mut V, node: &'ast crate::ItemEnum)
2455where
2456 V: Visit<'ast> + ?Sized,
2457{
2458 for it: &Attribute 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: Pair<&Variant, &Comma> in Punctuated::pairs(&node.variants) {
2467 let it: &&Variant = el.value();
2468 v.visit_variant(it);
2469 }
2470}
2471#[cfg(feature = "full")]
2472#[cfg_attr(docsrs, doc(cfg(feature = "full")))]
2473pub fn visit_item_extern_crate<'ast, V>(v: &mut V, node: &'ast crate::ItemExternCrate)
2474where
2475 V: Visit<'ast> + ?Sized,
2476{
2477 for it: &Attribute 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: &(As, Ident)) = &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")))]
2492pub fn visit_item_fn<'ast, V>(v: &mut V, node: &'ast crate::ItemFn)
2493where
2494 V: Visit<'ast> + ?Sized,
2495{
2496 for it: &Attribute 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")))]
2505pub fn visit_item_foreign_mod<'ast, V>(v: &mut V, node: &'ast crate::ItemForeignMod)
2506where
2507 V: Visit<'ast> + ?Sized,
2508{
2509 for it: &Attribute 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: &ForeignItem in &node.items {
2516 v.visit_foreign_item(it);
2517 }
2518}
2519#[cfg(feature = "full")]
2520#[cfg_attr(docsrs, doc(cfg(feature = "full")))]
2521pub fn visit_item_impl<'ast, V>(v: &mut V, node: &'ast crate::ItemImpl)
2522where
2523 V: Visit<'ast> + ?Sized,
2524{
2525 for it: &Attribute 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: &(Option, Path, For)) = &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: &ImplItem in &node.items {
2540 v.visit_impl_item(it);
2541 }
2542}
2543#[cfg(feature = "full")]
2544#[cfg_attr(docsrs, doc(cfg(feature = "full")))]
2545pub fn visit_item_macro<'ast, V>(v: &mut V, node: &'ast crate::ItemMacro)
2546where
2547 V: Visit<'ast> + ?Sized,
2548{
2549 for it: &Attribute in &node.attrs {
2550 v.visit_attribute(it);
2551 }
2552 if let Some(it: &Ident) = &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")))]
2560pub fn visit_item_mod<'ast, V>(v: &mut V, node: &'ast crate::ItemMod)
2561where
2562 V: Visit<'ast> + ?Sized,
2563{
2564 for it: &Attribute 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: &(Brace, Vec)) = &node.content {
2572 skip!((it).0);
2573 for it: &Item 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")))]
2581pub fn visit_item_static<'ast, V>(v: &mut V, node: &'ast crate::ItemStatic)
2582where
2583 V: Visit<'ast> + ?Sized,
2584{
2585 for it: &Attribute 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")))]
2600pub fn visit_item_struct<'ast, V>(v: &mut V, node: &'ast crate::ItemStruct)
2601where
2602 V: Visit<'ast> + ?Sized,
2603{
2604 for it: &Attribute 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")))]
2616pub fn visit_item_trait<'ast, V>(v: &mut V, node: &'ast crate::ItemTrait)
2617where
2618 V: Visit<'ast> + ?Sized,
2619{
2620 for it: &Attribute 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: &ImplRestriction) = &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: Pair<&TypeParamBound, &Plus> in Punctuated::pairs(&node.supertraits) {
2634 let it: &&TypeParamBound = el.value();
2635 v.visit_type_param_bound(it);
2636 }
2637 skip!(node.brace_token);
2638 for it: &TraitItem in &node.items {
2639 v.visit_trait_item(it);
2640 }
2641}
2642#[cfg(feature = "full")]
2643#[cfg_attr(docsrs, doc(cfg(feature = "full")))]
2644pub fn visit_item_trait_alias<'ast, V>(v: &mut V, node: &'ast crate::ItemTraitAlias)
2645where
2646 V: Visit<'ast> + ?Sized,
2647{
2648 for it: &Attribute 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: Pair<&TypeParamBound, &Plus> in Punctuated::pairs(&node.bounds) {
2657 let it: &&TypeParamBound = 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")))]
2664pub fn visit_item_type<'ast, V>(v: &mut V, node: &'ast crate::ItemType)
2665where
2666 V: Visit<'ast> + ?Sized,
2667{
2668 for it: &Attribute 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")))]
2681pub fn visit_item_union<'ast, V>(v: &mut V, node: &'ast crate::ItemUnion)
2682where
2683 V: Visit<'ast> + ?Sized,
2684{
2685 for it: &Attribute 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")))]
2696pub fn visit_item_use<'ast, V>(v: &mut V, node: &'ast crate::ItemUse)
2697where
2698 V: Visit<'ast> + ?Sized,
2699{
2700 for it: &Attribute 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")))]
2711pub fn visit_label<'ast, V>(v: &mut V, node: &'ast crate::Label)
2712where
2713 V: Visit<'ast> + ?Sized,
2714{
2715 v.visit_lifetime(&node.name);
2716 skip!(node.colon_token);
2717}
2718pub fn visit_lifetime<'ast, V>(v: &mut V, node: &'ast crate::Lifetime)
2719where
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"))))]
2727pub fn visit_lifetime_param<'ast, V>(v: &mut V, node: &'ast crate::LifetimeParam)
2728where
2729 V: Visit<'ast> + ?Sized,
2730{
2731 for it: &Attribute in &node.attrs {
2732 v.visit_attribute(it);
2733 }
2734 v.visit_lifetime(&node.lifetime);
2735 skip!(node.colon_token);
2736 for el: Pair<&Lifetime, &Plus> in Punctuated::pairs(&node.bounds) {
2737 let it: &&Lifetime = el.value();
2738 v.visit_lifetime(it);
2739 }
2740}
2741pub fn visit_lit<'ast, V>(v: &mut V, node: &'ast crate::Lit)
2742where
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}
2775pub fn visit_lit_bool<'ast, V>(v: &mut V, node: &'ast crate::LitBool)
2776where
2777 V: Visit<'ast> + ?Sized,
2778{
2779 skip!(node.value);
2780 v.visit_span(&node.span);
2781}
2782pub fn visit_lit_byte<'ast, V>(v: &mut V, node: &'ast crate::LitByte)
2783where
2784 V: Visit<'ast> + ?Sized,
2785{}
2786pub fn visit_lit_byte_str<'ast, V>(v: &mut V, node: &'ast crate::LitByteStr)
2787where
2788 V: Visit<'ast> + ?Sized,
2789{}
2790pub fn visit_lit_cstr<'ast, V>(v: &mut V, node: &'ast crate::LitCStr)
2791where
2792 V: Visit<'ast> + ?Sized,
2793{}
2794pub fn visit_lit_char<'ast, V>(v: &mut V, node: &'ast crate::LitChar)
2795where
2796 V: Visit<'ast> + ?Sized,
2797{}
2798pub fn visit_lit_float<'ast, V>(v: &mut V, node: &'ast crate::LitFloat)
2799where
2800 V: Visit<'ast> + ?Sized,
2801{}
2802pub fn visit_lit_int<'ast, V>(v: &mut V, node: &'ast crate::LitInt)
2803where
2804 V: Visit<'ast> + ?Sized,
2805{}
2806pub fn visit_lit_str<'ast, V>(v: &mut V, node: &'ast crate::LitStr)
2807where
2808 V: Visit<'ast> + ?Sized,
2809{}
2810#[cfg(feature = "full")]
2811#[cfg_attr(docsrs, doc(cfg(feature = "full")))]
2812pub fn visit_local<'ast, V>(v: &mut V, node: &'ast crate::Local)
2813where
2814 V: Visit<'ast> + ?Sized,
2815{
2816 for it: &Attribute 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: &LocalInit) = &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")))]
2828pub fn visit_local_init<'ast, V>(v: &mut V, node: &'ast crate::LocalInit)
2829where
2830 V: Visit<'ast> + ?Sized,
2831{
2832 skip!(node.eq_token);
2833 v.visit_expr(&*node.expr);
2834 if let Some(it: &(Else, Box)) = &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"))))]
2841pub fn visit_macro<'ast, V>(v: &mut V, node: &'ast crate::Macro)
2842where
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"))))]
2852pub fn visit_macro_delimiter<'ast, V>(v: &mut V, node: &'ast crate::MacroDelimiter)
2853where
2854 V: Visit<'ast> + ?Sized,
2855{
2856 match node {
2857 crate::MacroDelimiter::Paren(_binding_0: &Paren) => {
2858 skip!(_binding_0);
2859 }
2860 crate::MacroDelimiter::Brace(_binding_0: &Brace) => {
2861 skip!(_binding_0);
2862 }
2863 crate::MacroDelimiter::Bracket(_binding_0: &Bracket) => {
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"))))]
2870pub fn visit_member<'ast, V>(v: &mut V, node: &'ast crate::Member)
2871where
2872 V: Visit<'ast> + ?Sized,
2873{
2874 match node {
2875 crate::Member::Named(_binding_0: &Ident) => {
2876 v.visit_ident(_binding_0);
2877 }
2878 crate::Member::Unnamed(_binding_0: &Index) => {
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"))))]
2885pub fn visit_meta<'ast, V>(v: &mut V, node: &'ast crate::Meta)
2886where
2887 V: Visit<'ast> + ?Sized,
2888{
2889 match node {
2890 crate::Meta::Path(_binding_0: &Path) => {
2891 v.visit_path(_binding_0);
2892 }
2893 crate::Meta::List(_binding_0: &MetaList) => {
2894 v.visit_meta_list(_binding_0);
2895 }
2896 crate::Meta::NameValue(_binding_0: &MetaNameValue) => {
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"))))]
2903pub fn visit_meta_list<'ast, V>(v: &mut V, node: &'ast crate::MetaList)
2904where
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"))))]
2913pub fn visit_meta_name_value<'ast, V>(v: &mut V, node: &'ast crate::MetaNameValue)
2914where
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"))))]
2923pub fn visit_parenthesized_generic_arguments<'ast, V>(
2924 v: &mut V,
2925 node: &'ast crate::ParenthesizedGenericArguments,
2926)
2927where
2928 V: Visit<'ast> + ?Sized,
2929{
2930 skip!(node.paren_token);
2931 for el: Pair<&Type, &Comma> in Punctuated::pairs(&node.inputs) {
2932 let it: &&Type = 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")))]
2939pub fn visit_pat<'ast, V>(v: &mut V, node: &'ast crate::Pat)
2940where
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")))]
2999pub fn visit_pat_ident<'ast, V>(v: &mut V, node: &'ast crate::PatIdent)
3000where
3001 V: Visit<'ast> + ?Sized,
3002{
3003 for it: &Attribute 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: &(At, Box)) = &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")))]
3016pub fn visit_pat_or<'ast, V>(v: &mut V, node: &'ast crate::PatOr)
3017where
3018 V: Visit<'ast> + ?Sized,
3019{
3020 for it: &Attribute in &node.attrs {
3021 v.visit_attribute(it);
3022 }
3023 skip!(node.leading_vert);
3024 for el: Pair<&Pat, &Or> in Punctuated::pairs(&node.cases) {
3025 let it: &&Pat = el.value();
3026 v.visit_pat(it);
3027 }
3028}
3029#[cfg(feature = "full")]
3030#[cfg_attr(docsrs, doc(cfg(feature = "full")))]
3031pub fn visit_pat_paren<'ast, V>(v: &mut V, node: &'ast crate::PatParen)
3032where
3033 V: Visit<'ast> + ?Sized,
3034{
3035 for it: &Attribute 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")))]
3043pub fn visit_pat_reference<'ast, V>(v: &mut V, node: &'ast crate::PatReference)
3044where
3045 V: Visit<'ast> + ?Sized,
3046{
3047 for it: &Attribute 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")))]
3056pub fn visit_pat_rest<'ast, V>(v: &mut V, node: &'ast crate::PatRest)
3057where
3058 V: Visit<'ast> + ?Sized,
3059{
3060 for it: &Attribute 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")))]
3067pub fn visit_pat_slice<'ast, V>(v: &mut V, node: &'ast crate::PatSlice)
3068where
3069 V: Visit<'ast> + ?Sized,
3070{
3071 for it: &Attribute in &node.attrs {
3072 v.visit_attribute(it);
3073 }
3074 skip!(node.bracket_token);
3075 for el: Pair<&Pat, &Comma> in Punctuated::pairs(&node.elems) {
3076 let it: &&Pat = el.value();
3077 v.visit_pat(it);
3078 }
3079}
3080#[cfg(feature = "full")]
3081#[cfg_attr(docsrs, doc(cfg(feature = "full")))]
3082pub fn visit_pat_struct<'ast, V>(v: &mut V, node: &'ast crate::PatStruct)
3083where
3084 V: Visit<'ast> + ?Sized,
3085{
3086 for it: &Attribute in &node.attrs {
3087 v.visit_attribute(it);
3088 }
3089 if let Some(it: &QSelf) = &node.qself {
3090 v.visit_qself(it);
3091 }
3092 v.visit_path(&node.path);
3093 skip!(node.brace_token);
3094 for el: Pair<&FieldPat, &Comma> in Punctuated::pairs(&node.fields) {
3095 let it: &&FieldPat = el.value();
3096 v.visit_field_pat(it);
3097 }
3098 if let Some(it: &PatRest) = &node.rest {
3099 v.visit_pat_rest(it);
3100 }
3101}
3102#[cfg(feature = "full")]
3103#[cfg_attr(docsrs, doc(cfg(feature = "full")))]
3104pub fn visit_pat_tuple<'ast, V>(v: &mut V, node: &'ast crate::PatTuple)
3105where
3106 V: Visit<'ast> + ?Sized,
3107{
3108 for it: &Attribute in &node.attrs {
3109 v.visit_attribute(it);
3110 }
3111 skip!(node.paren_token);
3112 for el: Pair<&Pat, &Comma> in Punctuated::pairs(&node.elems) {
3113 let it: &&Pat = el.value();
3114 v.visit_pat(it);
3115 }
3116}
3117#[cfg(feature = "full")]
3118#[cfg_attr(docsrs, doc(cfg(feature = "full")))]
3119pub fn visit_pat_tuple_struct<'ast, V>(v: &mut V, node: &'ast crate::PatTupleStruct)
3120where
3121 V: Visit<'ast> + ?Sized,
3122{
3123 for it: &Attribute in &node.attrs {
3124 v.visit_attribute(it);
3125 }
3126 if let Some(it: &QSelf) = &node.qself {
3127 v.visit_qself(it);
3128 }
3129 v.visit_path(&node.path);
3130 skip!(node.paren_token);
3131 for el: Pair<&Pat, &Comma> in Punctuated::pairs(&node.elems) {
3132 let it: &&Pat = el.value();
3133 v.visit_pat(it);
3134 }
3135}
3136#[cfg(feature = "full")]
3137#[cfg_attr(docsrs, doc(cfg(feature = "full")))]
3138pub fn visit_pat_type<'ast, V>(v: &mut V, node: &'ast crate::PatType)
3139where
3140 V: Visit<'ast> + ?Sized,
3141{
3142 for it: &Attribute 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")))]
3151pub fn visit_pat_wild<'ast, V>(v: &mut V, node: &'ast crate::PatWild)
3152where
3153 V: Visit<'ast> + ?Sized,
3154{
3155 for it: &Attribute 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"))))]
3162pub fn visit_path<'ast, V>(v: &mut V, node: &'ast crate::Path)
3163where
3164 V: Visit<'ast> + ?Sized,
3165{
3166 skip!(node.leading_colon);
3167 for el: Pair<&PathSegment, &PathSep> in Punctuated::pairs(&node.segments) {
3168 let it: &&PathSegment = 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"))))]
3174pub fn visit_path_arguments<'ast, V>(v: &mut V, node: &'ast crate::PathArguments)
3175where
3176 V: Visit<'ast> + ?Sized,
3177{
3178 match node {
3179 crate::PathArguments::None => {}
3180 crate::PathArguments::AngleBracketed(_binding_0: &AngleBracketedGenericArguments) => {
3181 v.visit_angle_bracketed_generic_arguments(_binding_0);
3182 }
3183 crate::PathArguments::Parenthesized(_binding_0: &ParenthesizedGenericArguments) => {
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"))))]
3190pub fn visit_path_segment<'ast, V>(v: &mut V, node: &'ast crate::PathSegment)
3191where
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")))]
3199pub fn visit_pointer_mutability<'ast, V>(v: &mut V, node: &'ast crate::PointerMutability)
3200where
3201 V: Visit<'ast> + ?Sized,
3202{
3203 match node {
3204 crate::PointerMutability::Const(_binding_0: &Const) => {
3205 skip!(_binding_0);
3206 }
3207 crate::PointerMutability::Mut(_binding_0: &Mut) => {
3208 skip!(_binding_0);
3209 }
3210 }
3211}
3212#[cfg(feature = "full")]
3213#[cfg_attr(docsrs, doc(cfg(feature = "full")))]
3214pub fn visit_precise_capture<'ast, V>(v: &mut V, node: &'ast crate::PreciseCapture)
3215where
3216 V: Visit<'ast> + ?Sized,
3217{
3218 skip!(node.use_token);
3219 skip!(node.lt_token);
3220 for el: Pair<&CapturedParam, &Comma> in Punctuated::pairs(&node.params) {
3221 let it: &&CapturedParam = 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"))))]
3228pub fn visit_predicate_lifetime<'ast, V>(v: &mut V, node: &'ast crate::PredicateLifetime)
3229where
3230 V: Visit<'ast> + ?Sized,
3231{
3232 v.visit_lifetime(&node.lifetime);
3233 skip!(node.colon_token);
3234 for el: Pair<&Lifetime, &Plus> in Punctuated::pairs(&node.bounds) {
3235 let it: &&Lifetime = 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"))))]
3241pub fn visit_predicate_type<'ast, V>(v: &mut V, node: &'ast crate::PredicateType)
3242where
3243 V: Visit<'ast> + ?Sized,
3244{
3245 if let Some(it: &BoundLifetimes) = &node.lifetimes {
3246 v.visit_bound_lifetimes(it);
3247 }
3248 v.visit_type(&node.bounded_ty);
3249 skip!(node.colon_token);
3250 for el: Pair<&TypeParamBound, &Plus> in Punctuated::pairs(&node.bounds) {
3251 let it: &&TypeParamBound = 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"))))]
3257pub fn visit_qself<'ast, V>(v: &mut V, node: &'ast crate::QSelf)
3258where
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")))]
3269pub fn visit_range_limits<'ast, V>(v: &mut V, node: &'ast crate::RangeLimits)
3270where
3271 V: Visit<'ast> + ?Sized,
3272{
3273 match node {
3274 crate::RangeLimits::HalfOpen(_binding_0: &DotDot) => {
3275 skip!(_binding_0);
3276 }
3277 crate::RangeLimits::Closed(_binding_0: &DotDotEq) => {
3278 skip!(_binding_0);
3279 }
3280 }
3281}
3282#[cfg(feature = "full")]
3283#[cfg_attr(docsrs, doc(cfg(feature = "full")))]
3284pub fn visit_receiver<'ast, V>(v: &mut V, node: &'ast crate::Receiver)
3285where
3286 V: Visit<'ast> + ?Sized,
3287{
3288 for it: &Attribute in &node.attrs {
3289 v.visit_attribute(it);
3290 }
3291 if let Some(it: &(And, Option)) = &node.reference {
3292 skip!((it).0);
3293 if let Some(it: &Lifetime) = &(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"))))]
3304pub fn visit_return_type<'ast, V>(v: &mut V, node: &'ast crate::ReturnType)
3305where
3306 V: Visit<'ast> + ?Sized,
3307{
3308 match node {
3309 crate::ReturnType::Default => {}
3310 crate::ReturnType::Type(_binding_0: &RArrow, _binding_1: &Box) => {
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")))]
3318pub fn visit_signature<'ast, V>(v: &mut V, node: &'ast crate::Signature)
3319where
3320 V: Visit<'ast> + ?Sized,
3321{
3322 skip!(node.constness);
3323 skip!(node.asyncness);
3324 skip!(node.unsafety);
3325 if let Some(it: &Abi) = &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: Pair<&FnArg, &Comma> in Punctuated::pairs(&node.inputs) {
3333 let it: &&FnArg = el.value();
3334 v.visit_fn_arg(it);
3335 }
3336 if let Some(it: &Variadic) = &node.variadic {
3337 v.visit_variadic(it);
3338 }
3339 v.visit_return_type(&node.output);
3340}
3341pub fn visit_span<'ast, V>(v: &mut V, node: &proc_macro2::Span)
3342where
3343 V: Visit<'ast> + ?Sized,
3344{}
3345#[cfg(feature = "full")]
3346#[cfg_attr(docsrs, doc(cfg(feature = "full")))]
3347pub fn visit_static_mutability<'ast, V>(v: &mut V, node: &'ast crate::StaticMutability)
3348where
3349 V: Visit<'ast> + ?Sized,
3350{
3351 match node {
3352 crate::StaticMutability::Mut(_binding_0: &Mut) => {
3353 skip!(_binding_0);
3354 }
3355 crate::StaticMutability::None => {}
3356 }
3357}
3358#[cfg(feature = "full")]
3359#[cfg_attr(docsrs, doc(cfg(feature = "full")))]
3360pub fn visit_stmt<'ast, V>(v: &mut V, node: &'ast crate::Stmt)
3361where
3362 V: Visit<'ast> + ?Sized,
3363{
3364 match node {
3365 crate::Stmt::Local(_binding_0: &Local) => {
3366 v.visit_local(_binding_0);
3367 }
3368 crate::Stmt::Item(_binding_0: &Item) => {
3369 v.visit_item(_binding_0);
3370 }
3371 crate::Stmt::Expr(_binding_0: &Expr, _binding_1: &Option) => {
3372 v.visit_expr(_binding_0);
3373 skip!(_binding_1);
3374 }
3375 crate::Stmt::Macro(_binding_0: &StmtMacro) => {
3376 v.visit_stmt_macro(_binding_0);
3377 }
3378 }
3379}
3380#[cfg(feature = "full")]
3381#[cfg_attr(docsrs, doc(cfg(feature = "full")))]
3382pub fn visit_stmt_macro<'ast, V>(v: &mut V, node: &'ast crate::StmtMacro)
3383where
3384 V: Visit<'ast> + ?Sized,
3385{
3386 for it: &Attribute 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"))))]
3394pub fn visit_trait_bound<'ast, V>(v: &mut V, node: &'ast crate::TraitBound)
3395where
3396 V: Visit<'ast> + ?Sized,
3397{
3398 skip!(node.paren_token);
3399 v.visit_trait_bound_modifier(&node.modifier);
3400 if let Some(it: &BoundLifetimes) = &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"))))]
3407pub fn visit_trait_bound_modifier<'ast, V>(
3408 v: &mut V,
3409 node: &'ast crate::TraitBoundModifier,
3410)
3411where
3412 V: Visit<'ast> + ?Sized,
3413{
3414 match node {
3415 crate::TraitBoundModifier::None => {}
3416 crate::TraitBoundModifier::Maybe(_binding_0: &Question) => {
3417 skip!(_binding_0);
3418 }
3419 }
3420}
3421#[cfg(feature = "full")]
3422#[cfg_attr(docsrs, doc(cfg(feature = "full")))]
3423pub fn visit_trait_item<'ast, V>(v: &mut V, node: &'ast crate::TraitItem)
3424where
3425 V: Visit<'ast> + ?Sized,
3426{
3427 match node {
3428 crate::TraitItem::Const(_binding_0: &TraitItemConst) => {
3429 v.visit_trait_item_const(_binding_0);
3430 }
3431 crate::TraitItem::Fn(_binding_0: &TraitItemFn) => {
3432 v.visit_trait_item_fn(_binding_0);
3433 }
3434 crate::TraitItem::Type(_binding_0: &TraitItemType) => {
3435 v.visit_trait_item_type(_binding_0);
3436 }
3437 crate::TraitItem::Macro(_binding_0: &TraitItemMacro) => {
3438 v.visit_trait_item_macro(_binding_0);
3439 }
3440 crate::TraitItem::Verbatim(_binding_0: &TokenStream) => {
3441 skip!(_binding_0);
3442 }
3443 }
3444}
3445#[cfg(feature = "full")]
3446#[cfg_attr(docsrs, doc(cfg(feature = "full")))]
3447pub fn visit_trait_item_const<'ast, V>(v: &mut V, node: &'ast crate::TraitItemConst)
3448where
3449 V: Visit<'ast> + ?Sized,
3450{
3451 for it: &Attribute 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: &(Eq, Expr)) = &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")))]
3467pub fn visit_trait_item_fn<'ast, V>(v: &mut V, node: &'ast crate::TraitItemFn)
3468where
3469 V: Visit<'ast> + ?Sized,
3470{
3471 for it: &Attribute in &node.attrs {
3472 v.visit_attribute(it);
3473 }
3474 v.visit_signature(&node.sig);
3475 if let Some(it: &Block) = &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")))]
3482pub fn visit_trait_item_macro<'ast, V>(v: &mut V, node: &'ast crate::TraitItemMacro)
3483where
3484 V: Visit<'ast> + ?Sized,
3485{
3486 for it: &Attribute 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")))]
3494pub fn visit_trait_item_type<'ast, V>(v: &mut V, node: &'ast crate::TraitItemType)
3495where
3496 V: Visit<'ast> + ?Sized,
3497{
3498 for it: &Attribute 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: Pair<&TypeParamBound, &Plus> in Punctuated::pairs(&node.bounds) {
3506 let it: &&TypeParamBound = el.value();
3507 v.visit_type_param_bound(it);
3508 }
3509 if let Some(it: &(Eq, Type)) = &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"))))]
3517pub fn visit_type<'ast, V>(v: &mut V, node: &'ast crate::Type)
3518where
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"))))]
3571pub fn visit_type_array<'ast, V>(v: &mut V, node: &'ast crate::TypeArray)
3572where
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"))))]
3582pub fn visit_type_bare_fn<'ast, V>(v: &mut V, node: &'ast crate::TypeBareFn)
3583where
3584 V: Visit<'ast> + ?Sized,
3585{
3586 if let Some(it: &BoundLifetimes) = &node.lifetimes {
3587 v.visit_bound_lifetimes(it);
3588 }
3589 skip!(node.unsafety);
3590 if let Some(it: &Abi) = &node.abi {
3591 v.visit_abi(it);
3592 }
3593 skip!(node.fn_token);
3594 skip!(node.paren_token);
3595 for el: Pair<&BareFnArg, &Comma> in Punctuated::pairs(&node.inputs) {
3596 let it: &&BareFnArg = el.value();
3597 v.visit_bare_fn_arg(it);
3598 }
3599 if let Some(it: &BareVariadic) = &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"))))]
3606pub fn visit_type_group<'ast, V>(v: &mut V, node: &'ast crate::TypeGroup)
3607where
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"))))]
3615pub fn visit_type_impl_trait<'ast, V>(v: &mut V, node: &'ast crate::TypeImplTrait)
3616where
3617 V: Visit<'ast> + ?Sized,
3618{
3619 skip!(node.impl_token);
3620 for el: Pair<&TypeParamBound, &Plus> in Punctuated::pairs(&node.bounds) {
3621 let it: &&TypeParamBound = 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"))))]
3627pub fn visit_type_infer<'ast, V>(v: &mut V, node: &'ast crate::TypeInfer)
3628where
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"))))]
3635pub fn visit_type_macro<'ast, V>(v: &mut V, node: &'ast crate::TypeMacro)
3636where
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"))))]
3643pub fn visit_type_never<'ast, V>(v: &mut V, node: &'ast crate::TypeNever)
3644where
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"))))]
3651pub fn visit_type_param<'ast, V>(v: &mut V, node: &'ast crate::TypeParam)
3652where
3653 V: Visit<'ast> + ?Sized,
3654{
3655 for it: &Attribute in &node.attrs {
3656 v.visit_attribute(it);
3657 }
3658 v.visit_ident(&node.ident);
3659 skip!(node.colon_token);
3660 for el: Pair<&TypeParamBound, &Plus> in Punctuated::pairs(&node.bounds) {
3661 let it: &&TypeParamBound = el.value();
3662 v.visit_type_param_bound(it);
3663 }
3664 skip!(node.eq_token);
3665 if let Some(it: &Type) = &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"))))]
3671pub fn visit_type_param_bound<'ast, V>(v: &mut V, node: &'ast crate::TypeParamBound)
3672where
3673 V: Visit<'ast> + ?Sized,
3674{
3675 match node {
3676 crate::TypeParamBound::Trait(_binding_0: &TraitBound) => {
3677 v.visit_trait_bound(_binding_0);
3678 }
3679 crate::TypeParamBound::Lifetime(_binding_0: &Lifetime) => {
3680 v.visit_lifetime(_binding_0);
3681 }
3682 crate::TypeParamBound::PreciseCapture(_binding_0: &PreciseCapture) => {
3683 full!(v.visit_precise_capture(_binding_0));
3684 }
3685 crate::TypeParamBound::Verbatim(_binding_0: &TokenStream) => {
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"))))]
3692pub fn visit_type_paren<'ast, V>(v: &mut V, node: &'ast crate::TypeParen)
3693where
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"))))]
3701pub fn visit_type_path<'ast, V>(v: &mut V, node: &'ast crate::TypePath)
3702where
3703 V: Visit<'ast> + ?Sized,
3704{
3705 if let Some(it: &QSelf) = &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"))))]
3712pub fn visit_type_ptr<'ast, V>(v: &mut V, node: &'ast crate::TypePtr)
3713where
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"))))]
3723pub fn visit_type_reference<'ast, V>(v: &mut V, node: &'ast crate::TypeReference)
3724where
3725 V: Visit<'ast> + ?Sized,
3726{
3727 skip!(node.and_token);
3728 if let Some(it: &Lifetime) = &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"))))]
3736pub fn visit_type_slice<'ast, V>(v: &mut V, node: &'ast crate::TypeSlice)
3737where
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"))))]
3745pub fn visit_type_trait_object<'ast, V>(v: &mut V, node: &'ast crate::TypeTraitObject)
3746where
3747 V: Visit<'ast> + ?Sized,
3748{
3749 skip!(node.dyn_token);
3750 for el: Pair<&TypeParamBound, &Plus> in Punctuated::pairs(&node.bounds) {
3751 let it: &&TypeParamBound = 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"))))]
3757pub fn visit_type_tuple<'ast, V>(v: &mut V, node: &'ast crate::TypeTuple)
3758where
3759 V: Visit<'ast> + ?Sized,
3760{
3761 skip!(node.paren_token);
3762 for el: Pair<&Type, &Comma> in Punctuated::pairs(&node.elems) {
3763 let it: &&Type = 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"))))]
3769pub fn visit_un_op<'ast, V>(v: &mut V, node: &'ast crate::UnOp)
3770where
3771 V: Visit<'ast> + ?Sized,
3772{
3773 match node {
3774 crate::UnOp::Deref(_binding_0: &Star) => {
3775 skip!(_binding_0);
3776 }
3777 crate::UnOp::Not(_binding_0: &Not) => {
3778 skip!(_binding_0);
3779 }
3780 crate::UnOp::Neg(_binding_0: &Minus) => {
3781 skip!(_binding_0);
3782 }
3783 }
3784}
3785#[cfg(feature = "full")]
3786#[cfg_attr(docsrs, doc(cfg(feature = "full")))]
3787pub fn visit_use_glob<'ast, V>(v: &mut V, node: &'ast crate::UseGlob)
3788where
3789 V: Visit<'ast> + ?Sized,
3790{
3791 skip!(node.star_token);
3792}
3793#[cfg(feature = "full")]
3794#[cfg_attr(docsrs, doc(cfg(feature = "full")))]
3795pub fn visit_use_group<'ast, V>(v: &mut V, node: &'ast crate::UseGroup)
3796where
3797 V: Visit<'ast> + ?Sized,
3798{
3799 skip!(node.brace_token);
3800 for el: Pair<&UseTree, &Comma> in Punctuated::pairs(&node.items) {
3801 let it: &&UseTree = el.value();
3802 v.visit_use_tree(it);
3803 }
3804}
3805#[cfg(feature = "full")]
3806#[cfg_attr(docsrs, doc(cfg(feature = "full")))]
3807pub fn visit_use_name<'ast, V>(v: &mut V, node: &'ast crate::UseName)
3808where
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")))]
3815pub fn visit_use_path<'ast, V>(v: &mut V, node: &'ast crate::UsePath)
3816where
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")))]
3825pub fn visit_use_rename<'ast, V>(v: &mut V, node: &'ast crate::UseRename)
3826where
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")))]
3835pub fn visit_use_tree<'ast, V>(v: &mut V, node: &'ast crate::UseTree)
3836where
3837 V: Visit<'ast> + ?Sized,
3838{
3839 match node {
3840 crate::UseTree::Path(_binding_0: &UsePath) => {
3841 v.visit_use_path(_binding_0);
3842 }
3843 crate::UseTree::Name(_binding_0: &UseName) => {
3844 v.visit_use_name(_binding_0);
3845 }
3846 crate::UseTree::Rename(_binding_0: &UseRename) => {
3847 v.visit_use_rename(_binding_0);
3848 }
3849 crate::UseTree::Glob(_binding_0: &UseGlob) => {
3850 v.visit_use_glob(_binding_0);
3851 }
3852 crate::UseTree::Group(_binding_0: &UseGroup) => {
3853 v.visit_use_group(_binding_0);
3854 }
3855 }
3856}
3857#[cfg(feature = "full")]
3858#[cfg_attr(docsrs, doc(cfg(feature = "full")))]
3859pub fn visit_variadic<'ast, V>(v: &mut V, node: &'ast crate::Variadic)
3860where
3861 V: Visit<'ast> + ?Sized,
3862{
3863 for it: &Attribute in &node.attrs {
3864 v.visit_attribute(it);
3865 }
3866 if let Some(it: &(Box, Colon)) = &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"))))]
3875pub fn visit_variant<'ast, V>(v: &mut V, node: &'ast crate::Variant)
3876where
3877 V: Visit<'ast> + ?Sized,
3878{
3879 for it: &Attribute 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: &(Eq, Expr)) = &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"))))]
3891pub fn visit_vis_restricted<'ast, V>(v: &mut V, node: &'ast crate::VisRestricted)
3892where
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"))))]
3902pub fn visit_visibility<'ast, V>(v: &mut V, node: &'ast crate::Visibility)
3903where
3904 V: Visit<'ast> + ?Sized,
3905{
3906 match node {
3907 crate::Visibility::Public(_binding_0: &Pub) => {
3908 skip!(_binding_0);
3909 }
3910 crate::Visibility::Restricted(_binding_0: &VisRestricted) => {
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"))))]
3918pub fn visit_where_clause<'ast, V>(v: &mut V, node: &'ast crate::WhereClause)
3919where
3920 V: Visit<'ast> + ?Sized,
3921{
3922 skip!(node.where_token);
3923 for el: Pair<&WherePredicate, &Comma> in Punctuated::pairs(&node.predicates) {
3924 let it: &&WherePredicate = 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"))))]
3930pub fn visit_where_predicate<'ast, V>(v: &mut V, node: &'ast crate::WherePredicate)
3931where
3932 V: Visit<'ast> + ?Sized,
3933{
3934 match node {
3935 crate::WherePredicate::Lifetime(_binding_0: &PredicateLifetime) => {
3936 v.visit_predicate_lifetime(_binding_0);
3937 }
3938 crate::WherePredicate::Type(_binding_0: &PredicateType) => {
3939 v.visit_predicate_type(_binding_0);
3940 }
3941 }
3942}
3943