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