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