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