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