projects/linux·blob master · refs

3943 lines · 122.5 KiB

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