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