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