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"))]
6use crate::gen::helper::visit_mut::*;
7#[cfg(any(feature = "full", feature = "derive"))]
8use crate::punctuated::Punctuated;
9use crate::*;
10use proc_macro2::Span;
11#[cfg(feature = "full")]
12macro_rules! full {
13 ($e:expr) => {
14 $e
15 };
16}
17#[cfg(all(feature = "derive", not(feature = "full")))]
18macro_rules! full {
19 ($e:expr) => {
20 unreachable!()
21 };
22}
23macro_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.*
34pub trait VisitMut {
35 #[cfg(any(feature = "derive", feature = "full"))]
36 fn visit_abi_mut(&mut self, i: &mut Abi) {
37 visit_abi_mut(self, i);
38 }
39 #[cfg(any(feature = "derive", feature = "full"))]
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")]
47 fn visit_arm_mut(&mut self, i: &mut Arm) {
48 visit_arm_mut(self, i);
49 }
50 #[cfg(any(feature = "derive", feature = "full"))]
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"))]
55 fn visit_attribute_mut(&mut self, i: &mut Attribute) {
56 visit_attribute_mut(self, i);
57 }
58 #[cfg(any(feature = "derive", feature = "full"))]
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"))]
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"))]
67 fn visit_binding_mut(&mut self, i: &mut Binding) {
68 visit_binding_mut(self, i);
69 }
70 #[cfg(feature = "full")]
71 fn visit_block_mut(&mut self, i: &mut Block) {
72 visit_block_mut(self, i);
73 }
74 #[cfg(any(feature = "derive", feature = "full"))]
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"))]
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"))]
83 fn visit_constraint_mut(&mut self, i: &mut Constraint) {
84 visit_constraint_mut(self, i);
85 }
86 #[cfg(feature = "derive")]
87 fn visit_data_mut(&mut self, i: &mut Data) {
88 visit_data_mut(self, i);
89 }
90 #[cfg(feature = "derive")]
91 fn visit_data_enum_mut(&mut self, i: &mut DataEnum) {
92 visit_data_enum_mut(self, i);
93 }
94 #[cfg(feature = "derive")]
95 fn visit_data_struct_mut(&mut self, i: &mut DataStruct) {
96 visit_data_struct_mut(self, i);
97 }
98 #[cfg(feature = "derive")]
99 fn visit_data_union_mut(&mut self, i: &mut DataUnion) {
100 visit_data_union_mut(self, i);
101 }
102 #[cfg(feature = "derive")]
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"))]
107 fn visit_expr_mut(&mut self, i: &mut Expr) {
108 visit_expr_mut(self, i);
109 }
110 #[cfg(feature = "full")]
111 fn visit_expr_array_mut(&mut self, i: &mut ExprArray) {
112 visit_expr_array_mut(self, i);
113 }
114 #[cfg(feature = "full")]
115 fn visit_expr_assign_mut(&mut self, i: &mut ExprAssign) {
116 visit_expr_assign_mut(self, i);
117 }
118 #[cfg(feature = "full")]
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")]
123 fn visit_expr_async_mut(&mut self, i: &mut ExprAsync) {
124 visit_expr_async_mut(self, i);
125 }
126 #[cfg(feature = "full")]
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"))]
131 fn visit_expr_binary_mut(&mut self, i: &mut ExprBinary) {
132 visit_expr_binary_mut(self, i);
133 }
134 #[cfg(feature = "full")]
135 fn visit_expr_block_mut(&mut self, i: &mut ExprBlock) {
136 visit_expr_block_mut(self, i);
137 }
138 #[cfg(feature = "full")]
139 fn visit_expr_box_mut(&mut self, i: &mut ExprBox) {
140 visit_expr_box_mut(self, i);
141 }
142 #[cfg(feature = "full")]
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"))]
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"))]
151 fn visit_expr_cast_mut(&mut self, i: &mut ExprCast) {
152 visit_expr_cast_mut(self, i);
153 }
154 #[cfg(feature = "full")]
155 fn visit_expr_closure_mut(&mut self, i: &mut ExprClosure) {
156 visit_expr_closure_mut(self, i);
157 }
158 #[cfg(feature = "full")]
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"))]
163 fn visit_expr_field_mut(&mut self, i: &mut ExprField) {
164 visit_expr_field_mut(self, i);
165 }
166 #[cfg(feature = "full")]
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")]
171 fn visit_expr_group_mut(&mut self, i: &mut ExprGroup) {
172 visit_expr_group_mut(self, i);
173 }
174 #[cfg(feature = "full")]
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"))]
179 fn visit_expr_index_mut(&mut self, i: &mut ExprIndex) {
180 visit_expr_index_mut(self, i);
181 }
182 #[cfg(feature = "full")]
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"))]
187 fn visit_expr_lit_mut(&mut self, i: &mut ExprLit) {
188 visit_expr_lit_mut(self, i);
189 }
190 #[cfg(feature = "full")]
191 fn visit_expr_loop_mut(&mut self, i: &mut ExprLoop) {
192 visit_expr_loop_mut(self, i);
193 }
194 #[cfg(feature = "full")]
195 fn visit_expr_macro_mut(&mut self, i: &mut ExprMacro) {
196 visit_expr_macro_mut(self, i);
197 }
198 #[cfg(feature = "full")]
199 fn visit_expr_match_mut(&mut self, i: &mut ExprMatch) {
200 visit_expr_match_mut(self, i);
201 }
202 #[cfg(feature = "full")]
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"))]
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"))]
211 fn visit_expr_path_mut(&mut self, i: &mut ExprPath) {
212 visit_expr_path_mut(self, i);
213 }
214 #[cfg(feature = "full")]
215 fn visit_expr_range_mut(&mut self, i: &mut ExprRange) {
216 visit_expr_range_mut(self, i);
217 }
218 #[cfg(feature = "full")]
219 fn visit_expr_reference_mut(&mut self, i: &mut ExprReference) {
220 visit_expr_reference_mut(self, i);
221 }
222 #[cfg(feature = "full")]
223 fn visit_expr_repeat_mut(&mut self, i: &mut ExprRepeat) {
224 visit_expr_repeat_mut(self, i);
225 }
226 #[cfg(feature = "full")]
227 fn visit_expr_return_mut(&mut self, i: &mut ExprReturn) {
228 visit_expr_return_mut(self, i);
229 }
230 #[cfg(feature = "full")]
231 fn visit_expr_struct_mut(&mut self, i: &mut ExprStruct) {
232 visit_expr_struct_mut(self, i);
233 }
234 #[cfg(feature = "full")]
235 fn visit_expr_try_mut(&mut self, i: &mut ExprTry) {
236 visit_expr_try_mut(self, i);
237 }
238 #[cfg(feature = "full")]
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")]
243 fn visit_expr_tuple_mut(&mut self, i: &mut ExprTuple) {
244 visit_expr_tuple_mut(self, i);
245 }
246 #[cfg(feature = "full")]
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"))]
251 fn visit_expr_unary_mut(&mut self, i: &mut ExprUnary) {
252 visit_expr_unary_mut(self, i);
253 }
254 #[cfg(feature = "full")]
255 fn visit_expr_unsafe_mut(&mut self, i: &mut ExprUnsafe) {
256 visit_expr_unsafe_mut(self, i);
257 }
258 #[cfg(feature = "full")]
259 fn visit_expr_while_mut(&mut self, i: &mut ExprWhile) {
260 visit_expr_while_mut(self, i);
261 }
262 #[cfg(feature = "full")]
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"))]
267 fn visit_field_mut(&mut self, i: &mut Field) {
268 visit_field_mut(self, i);
269 }
270 #[cfg(feature = "full")]
271 fn visit_field_pat_mut(&mut self, i: &mut FieldPat) {
272 visit_field_pat_mut(self, i);
273 }
274 #[cfg(feature = "full")]
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"))]
279 fn visit_fields_mut(&mut self, i: &mut Fields) {
280 visit_fields_mut(self, i);
281 }
282 #[cfg(any(feature = "derive", feature = "full"))]
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"))]
287 fn visit_fields_unnamed_mut(&mut self, i: &mut FieldsUnnamed) {
288 visit_fields_unnamed_mut(self, i);
289 }
290 #[cfg(feature = "full")]
291 fn visit_file_mut(&mut self, i: &mut File) {
292 visit_file_mut(self, i);
293 }
294 #[cfg(feature = "full")]
295 fn visit_fn_arg_mut(&mut self, i: &mut FnArg) {
296 visit_fn_arg_mut(self, i);
297 }
298 #[cfg(feature = "full")]
299 fn visit_foreign_item_mut(&mut self, i: &mut ForeignItem) {
300 visit_foreign_item_mut(self, i);
301 }
302 #[cfg(feature = "full")]
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")]
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")]
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")]
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"))]
319 fn visit_generic_argument_mut(&mut self, i: &mut GenericArgument) {
320 visit_generic_argument_mut(self, i);
321 }
322 #[cfg(feature = "full")]
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"))]
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"))]
331 fn visit_generics_mut(&mut self, i: &mut Generics) {
332 visit_generics_mut(self, i);
333 }
334 fn visit_ident_mut(&mut self, i: &mut Ident) {
335 visit_ident_mut(self, i);
336 }
337 #[cfg(feature = "full")]
338 fn visit_impl_item_mut(&mut self, i: &mut ImplItem) {
339 visit_impl_item_mut(self, i);
340 }
341 #[cfg(feature = "full")]
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")]
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")]
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")]
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"))]
358 fn visit_index_mut(&mut self, i: &mut Index) {
359 visit_index_mut(self, i);
360 }
361 #[cfg(feature = "full")]
362 fn visit_item_mut(&mut self, i: &mut Item) {
363 visit_item_mut(self, i);
364 }
365 #[cfg(feature = "full")]
366 fn visit_item_const_mut(&mut self, i: &mut ItemConst) {
367 visit_item_const_mut(self, i);
368 }
369 #[cfg(feature = "full")]
370 fn visit_item_enum_mut(&mut self, i: &mut ItemEnum) {
371 visit_item_enum_mut(self, i);
372 }
373 #[cfg(feature = "full")]
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")]
378 fn visit_item_fn_mut(&mut self, i: &mut ItemFn) {
379 visit_item_fn_mut(self, i);
380 }
381 #[cfg(feature = "full")]
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")]
386 fn visit_item_impl_mut(&mut self, i: &mut ItemImpl) {
387 visit_item_impl_mut(self, i);
388 }
389 #[cfg(feature = "full")]
390 fn visit_item_macro_mut(&mut self, i: &mut ItemMacro) {
391 visit_item_macro_mut(self, i);
392 }
393 #[cfg(feature = "full")]
394 fn visit_item_macro2_mut(&mut self, i: &mut ItemMacro2) {
395 visit_item_macro2_mut(self, i);
396 }
397 #[cfg(feature = "full")]
398 fn visit_item_mod_mut(&mut self, i: &mut ItemMod) {
399 visit_item_mod_mut(self, i);
400 }
401 #[cfg(feature = "full")]
402 fn visit_item_static_mut(&mut self, i: &mut ItemStatic) {
403 visit_item_static_mut(self, i);
404 }
405 #[cfg(feature = "full")]
406 fn visit_item_struct_mut(&mut self, i: &mut ItemStruct) {
407 visit_item_struct_mut(self, i);
408 }
409 #[cfg(feature = "full")]
410 fn visit_item_trait_mut(&mut self, i: &mut ItemTrait) {
411 visit_item_trait_mut(self, i);
412 }
413 #[cfg(feature = "full")]
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")]
418 fn visit_item_type_mut(&mut self, i: &mut ItemType) {
419 visit_item_type_mut(self, i);
420 }
421 #[cfg(feature = "full")]
422 fn visit_item_union_mut(&mut self, i: &mut ItemUnion) {
423 visit_item_union_mut(self, i);
424 }
425 #[cfg(feature = "full")]
426 fn visit_item_use_mut(&mut self, i: &mut ItemUse) {
427 visit_item_use_mut(self, i);
428 }
429 #[cfg(feature = "full")]
430 fn visit_label_mut(&mut self, i: &mut Label) {
431 visit_label_mut(self, i);
432 }
433 fn visit_lifetime_mut(&mut self, i: &mut Lifetime) {
434 visit_lifetime_mut(self, i);
435 }
436 #[cfg(any(feature = "derive", feature = "full"))]
437 fn visit_lifetime_def_mut(&mut self, i: &mut LifetimeDef) {
438 visit_lifetime_def_mut(self, i);
439 }
440 fn visit_lit_mut(&mut self, i: &mut Lit) {
441 visit_lit_mut(self, i);
442 }
443 fn visit_lit_bool_mut(&mut self, i: &mut LitBool) {
444 visit_lit_bool_mut(self, i);
445 }
446 fn visit_lit_byte_mut(&mut self, i: &mut LitByte) {
447 visit_lit_byte_mut(self, i);
448 }
449 fn visit_lit_byte_str_mut(&mut self, i: &mut LitByteStr) {
450 visit_lit_byte_str_mut(self, i);
451 }
452 fn visit_lit_char_mut(&mut self, i: &mut LitChar) {
453 visit_lit_char_mut(self, i);
454 }
455 fn visit_lit_float_mut(&mut self, i: &mut LitFloat) {
456 visit_lit_float_mut(self, i);
457 }
458 fn visit_lit_int_mut(&mut self, i: &mut LitInt) {
459 visit_lit_int_mut(self, i);
460 }
461 fn visit_lit_str_mut(&mut self, i: &mut LitStr) {
462 visit_lit_str_mut(self, i);
463 }
464 #[cfg(feature = "full")]
465 fn visit_local_mut(&mut self, i: &mut Local) {
466 visit_local_mut(self, i);
467 }
468 #[cfg(any(feature = "derive", feature = "full"))]
469 fn visit_macro_mut(&mut self, i: &mut Macro) {
470 visit_macro_mut(self, i);
471 }
472 #[cfg(any(feature = "derive", feature = "full"))]
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"))]
477 fn visit_member_mut(&mut self, i: &mut Member) {
478 visit_member_mut(self, i);
479 }
480 #[cfg(any(feature = "derive", feature = "full"))]
481 fn visit_meta_mut(&mut self, i: &mut Meta) {
482 visit_meta_mut(self, i);
483 }
484 #[cfg(any(feature = "derive", feature = "full"))]
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"))]
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")]
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"))]
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"))]
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")]
508 fn visit_pat_mut(&mut self, i: &mut Pat) {
509 visit_pat_mut(self, i);
510 }
511 #[cfg(feature = "full")]
512 fn visit_pat_box_mut(&mut self, i: &mut PatBox) {
513 visit_pat_box_mut(self, i);
514 }
515 #[cfg(feature = "full")]
516 fn visit_pat_ident_mut(&mut self, i: &mut PatIdent) {
517 visit_pat_ident_mut(self, i);
518 }
519 #[cfg(feature = "full")]
520 fn visit_pat_lit_mut(&mut self, i: &mut PatLit) {
521 visit_pat_lit_mut(self, i);
522 }
523 #[cfg(feature = "full")]
524 fn visit_pat_macro_mut(&mut self, i: &mut PatMacro) {
525 visit_pat_macro_mut(self, i);
526 }
527 #[cfg(feature = "full")]
528 fn visit_pat_or_mut(&mut self, i: &mut PatOr) {
529 visit_pat_or_mut(self, i);
530 }
531 #[cfg(feature = "full")]
532 fn visit_pat_path_mut(&mut self, i: &mut PatPath) {
533 visit_pat_path_mut(self, i);
534 }
535 #[cfg(feature = "full")]
536 fn visit_pat_range_mut(&mut self, i: &mut PatRange) {
537 visit_pat_range_mut(self, i);
538 }
539 #[cfg(feature = "full")]
540 fn visit_pat_reference_mut(&mut self, i: &mut PatReference) {
541 visit_pat_reference_mut(self, i);
542 }
543 #[cfg(feature = "full")]
544 fn visit_pat_rest_mut(&mut self, i: &mut PatRest) {
545 visit_pat_rest_mut(self, i);
546 }
547 #[cfg(feature = "full")]
548 fn visit_pat_slice_mut(&mut self, i: &mut PatSlice) {
549 visit_pat_slice_mut(self, i);
550 }
551 #[cfg(feature = "full")]
552 fn visit_pat_struct_mut(&mut self, i: &mut PatStruct) {
553 visit_pat_struct_mut(self, i);
554 }
555 #[cfg(feature = "full")]
556 fn visit_pat_tuple_mut(&mut self, i: &mut PatTuple) {
557 visit_pat_tuple_mut(self, i);
558 }
559 #[cfg(feature = "full")]
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")]
564 fn visit_pat_type_mut(&mut self, i: &mut PatType) {
565 visit_pat_type_mut(self, i);
566 }
567 #[cfg(feature = "full")]
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"))]
572 fn visit_path_mut(&mut self, i: &mut Path) {
573 visit_path_mut(self, i);
574 }
575 #[cfg(any(feature = "derive", feature = "full"))]
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"))]
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"))]
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"))]
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"))]
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"))]
596 fn visit_qself_mut(&mut self, i: &mut QSelf) {
597 visit_qself_mut(self, i);
598 }
599 #[cfg(feature = "full")]
600 fn visit_range_limits_mut(&mut self, i: &mut RangeLimits) {
601 visit_range_limits_mut(self, i);
602 }
603 #[cfg(feature = "full")]
604 fn visit_receiver_mut(&mut self, i: &mut Receiver) {
605 visit_receiver_mut(self, i);
606 }
607 #[cfg(any(feature = "derive", feature = "full"))]
608 fn visit_return_type_mut(&mut self, i: &mut ReturnType) {
609 visit_return_type_mut(self, i);
610 }
611 #[cfg(feature = "full")]
612 fn visit_signature_mut(&mut self, i: &mut Signature) {
613 visit_signature_mut(self, i);
614 }
615 fn visit_span_mut(&mut self, i: &mut Span) {
616 visit_span_mut(self, i);
617 }
618 #[cfg(feature = "full")]
619 fn visit_stmt_mut(&mut self, i: &mut Stmt) {
620 visit_stmt_mut(self, i);
621 }
622 #[cfg(any(feature = "derive", feature = "full"))]
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"))]
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")]
631 fn visit_trait_item_mut(&mut self, i: &mut TraitItem) {
632 visit_trait_item_mut(self, i);
633 }
634 #[cfg(feature = "full")]
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")]
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")]
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")]
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"))]
651 fn visit_type_mut(&mut self, i: &mut Type) {
652 visit_type_mut(self, i);
653 }
654 #[cfg(any(feature = "derive", feature = "full"))]
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"))]
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"))]
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"))]
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"))]
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"))]
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"))]
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"))]
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"))]
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"))]
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"))]
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"))]
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"))]
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"))]
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"))]
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"))]
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"))]
719 fn visit_un_op_mut(&mut self, i: &mut UnOp) {
720 visit_un_op_mut(self, i);
721 }
722 #[cfg(feature = "full")]
723 fn visit_use_glob_mut(&mut self, i: &mut UseGlob) {
724 visit_use_glob_mut(self, i);
725 }
726 #[cfg(feature = "full")]
727 fn visit_use_group_mut(&mut self, i: &mut UseGroup) {
728 visit_use_group_mut(self, i);
729 }
730 #[cfg(feature = "full")]
731 fn visit_use_name_mut(&mut self, i: &mut UseName) {
732 visit_use_name_mut(self, i);
733 }
734 #[cfg(feature = "full")]
735 fn visit_use_path_mut(&mut self, i: &mut UsePath) {
736 visit_use_path_mut(self, i);
737 }
738 #[cfg(feature = "full")]
739 fn visit_use_rename_mut(&mut self, i: &mut UseRename) {
740 visit_use_rename_mut(self, i);
741 }
742 #[cfg(feature = "full")]
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"))]
747 fn visit_variadic_mut(&mut self, i: &mut Variadic) {
748 visit_variadic_mut(self, i);
749 }
750 #[cfg(any(feature = "derive", feature = "full"))]
751 fn visit_variant_mut(&mut self, i: &mut Variant) {
752 visit_variant_mut(self, i);
753 }
754 #[cfg(any(feature = "derive", feature = "full"))]
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"))]
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"))]
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"))]
767 fn visit_visibility_mut(&mut self, i: &mut Visibility) {
768 visit_visibility_mut(self, i);
769 }
770 #[cfg(any(feature = "derive", feature = "full"))]
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"))]
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"))]
780pub fn visit_abi_mut<V>(v: &mut V, node: &mut Abi)
781where
782 V: VisitMut + ?Sized,
783{
784 tokens_helper(visitor:v, &mut node.extern_token.span);
785 if let Some(it: &mut LitStr) = &mut node.name {
786 v.visit_lit_str_mut(it);
787 }
788}
789#[cfg(any(feature = "derive", feature = "full"))]
790pub fn visit_angle_bracketed_generic_arguments_mut<V>(
791 v: &mut V,
792 node: &mut AngleBracketedGenericArguments,
793)
794where
795 V: VisitMut + ?Sized,
796{
797 if let Some(it: &mut Colon2) = &mut node.colon2_token {
798 tokens_helper(visitor:v, &mut it.spans);
799 }
800 tokens_helper(visitor:v, &mut node.lt_token.spans);
801 for el: Pair<&mut GenericArgument, …> in Punctuated::pairs_mut(&mut node.args) {
802 let (it: &mut GenericArgument, p: Option<&mut Comma>) = el.into_tuple();
803 v.visit_generic_argument_mut(it);
804 if let Some(p: &mut Comma) = p {
805 tokens_helper(visitor:v, &mut p.spans);
806 }
807 }
808 tokens_helper(visitor:v, &mut node.gt_token.spans);
809}
810#[cfg(feature = "full")]
811pub fn visit_arm_mut<V>(v: &mut V, node: &mut Arm)
812where
813 V: VisitMut + ?Sized,
814{
815 for it: &mut Attribute 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 (If, Box)) = &mut node.guard {
820 tokens_helper(visitor:v, &mut (it).0.span);
821 v.visit_expr_mut(&mut *(it).1);
822 }
823 tokens_helper(visitor:v, &mut node.fat_arrow_token.spans);
824 v.visit_expr_mut(&mut *node.body);
825 if let Some(it: &mut Comma) = &mut node.comma {
826 tokens_helper(visitor:v, &mut it.spans);
827 }
828}
829#[cfg(any(feature = "derive", feature = "full"))]
830pub fn visit_attr_style_mut<V>(v: &mut V, node: &mut AttrStyle)
831where
832 V: VisitMut + ?Sized,
833{
834 match node {
835 AttrStyle::Outer => {}
836 AttrStyle::Inner(_binding_0: &mut Bang) => {
837 tokens_helper(visitor:v, &mut _binding_0.spans);
838 }
839 }
840}
841#[cfg(any(feature = "derive", feature = "full"))]
842pub fn visit_attribute_mut<V>(v: &mut V, node: &mut Attribute)
843where
844 V: VisitMut + ?Sized,
845{
846 tokens_helper(visitor:v, &mut node.pound_token.spans);
847 v.visit_attr_style_mut(&mut node.style);
848 tokens_helper(visitor: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"))]
853pub fn visit_bare_fn_arg_mut<V>(v: &mut V, node: &mut BareFnArg)
854where
855 V: VisitMut + ?Sized,
856{
857 for it: &mut Attribute in &mut node.attrs {
858 v.visit_attribute_mut(it);
859 }
860 if let Some(it: &mut (Ident, Colon)) = &mut node.name {
861 v.visit_ident_mut(&mut (it).0);
862 tokens_helper(visitor:v, &mut (it).1.spans);
863 }
864 v.visit_type_mut(&mut node.ty);
865}
866#[cfg(any(feature = "derive", feature = "full"))]
867pub fn visit_bin_op_mut<V>(v: &mut V, node: &mut BinOp)
868where
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"))]
959pub fn visit_binding_mut<V>(v: &mut V, node: &mut Binding)
960where
961 V: VisitMut + ?Sized,
962{
963 v.visit_ident_mut(&mut node.ident);
964 tokens_helper(visitor:v, &mut node.eq_token.spans);
965 v.visit_type_mut(&mut node.ty);
966}
967#[cfg(feature = "full")]
968pub fn visit_block_mut<V>(v: &mut V, node: &mut Block)
969where
970 V: VisitMut + ?Sized,
971{
972 tokens_helper(visitor:v, &mut node.brace_token.span);
973 for it: &mut Stmt in &mut node.stmts {
974 v.visit_stmt_mut(it);
975 }
976}
977#[cfg(any(feature = "derive", feature = "full"))]
978pub fn visit_bound_lifetimes_mut<V>(v: &mut V, node: &mut BoundLifetimes)
979where
980 V: VisitMut + ?Sized,
981{
982 tokens_helper(visitor:v, &mut node.for_token.span);
983 tokens_helper(visitor:v, &mut node.lt_token.spans);
984 for el: Pair<&mut LifetimeDef, &mut …> in Punctuated::pairs_mut(&mut node.lifetimes) {
985 let (it: &mut LifetimeDef, p: Option<&mut Comma>) = el.into_tuple();
986 v.visit_lifetime_def_mut(it);
987 if let Some(p: &mut Comma) = p {
988 tokens_helper(visitor:v, &mut p.spans);
989 }
990 }
991 tokens_helper(visitor:v, &mut node.gt_token.spans);
992}
993#[cfg(any(feature = "derive", feature = "full"))]
994pub fn visit_const_param_mut<V>(v: &mut V, node: &mut ConstParam)
995where
996 V: VisitMut + ?Sized,
997{
998 for it: &mut Attribute in &mut node.attrs {
999 v.visit_attribute_mut(it);
1000 }
1001 tokens_helper(visitor:v, &mut node.const_token.span);
1002 v.visit_ident_mut(&mut node.ident);
1003 tokens_helper(visitor:v, &mut node.colon_token.spans);
1004 v.visit_type_mut(&mut node.ty);
1005 if let Some(it: &mut Eq) = &mut node.eq_token {
1006 tokens_helper(visitor:v, &mut it.spans);
1007 }
1008 if let Some(it: &mut Expr) = &mut node.default {
1009 v.visit_expr_mut(it);
1010 }
1011}
1012#[cfg(any(feature = "derive", feature = "full"))]
1013pub fn visit_constraint_mut<V>(v: &mut V, node: &mut Constraint)
1014where
1015 V: VisitMut + ?Sized,
1016{
1017 v.visit_ident_mut(&mut node.ident);
1018 tokens_helper(visitor:v, &mut node.colon_token.spans);
1019 for el: Pair<&mut TypeParamBound, …> in Punctuated::pairs_mut(&mut node.bounds) {
1020 let (it: &mut TypeParamBound, p: Option<&mut Add>) = el.into_tuple();
1021 v.visit_type_param_bound_mut(it);
1022 if let Some(p: &mut Add) = p {
1023 tokens_helper(visitor:v, &mut p.spans);
1024 }
1025 }
1026}
1027#[cfg(feature = "derive")]
1028pub fn visit_data_mut<V>(v: &mut V, node: &mut Data)
1029where
1030 V: VisitMut + ?Sized,
1031{
1032 match node {
1033 Data::Struct(_binding_0: &mut DataStruct) => {
1034 v.visit_data_struct_mut(_binding_0);
1035 }
1036 Data::Enum(_binding_0: &mut DataEnum) => {
1037 v.visit_data_enum_mut(_binding_0);
1038 }
1039 Data::Union(_binding_0: &mut DataUnion) => {
1040 v.visit_data_union_mut(_binding_0);
1041 }
1042 }
1043}
1044#[cfg(feature = "derive")]
1045pub fn visit_data_enum_mut<V>(v: &mut V, node: &mut DataEnum)
1046where
1047 V: VisitMut + ?Sized,
1048{
1049 tokens_helper(visitor:v, &mut node.enum_token.span);
1050 tokens_helper(visitor:v, &mut node.brace_token.span);
1051 for el: Pair<&mut Variant, &mut Comma> in Punctuated::pairs_mut(&mut node.variants) {
1052 let (it: &mut Variant, p: Option<&mut Comma>) = el.into_tuple();
1053 v.visit_variant_mut(it);
1054 if let Some(p: &mut Comma) = p {
1055 tokens_helper(visitor:v, &mut p.spans);
1056 }
1057 }
1058}
1059#[cfg(feature = "derive")]
1060pub fn visit_data_struct_mut<V>(v: &mut V, node: &mut DataStruct)
1061where
1062 V: VisitMut + ?Sized,
1063{
1064 tokens_helper(visitor:v, &mut node.struct_token.span);
1065 v.visit_fields_mut(&mut node.fields);
1066 if let Some(it: &mut Semi) = &mut node.semi_token {
1067 tokens_helper(visitor:v, &mut it.spans);
1068 }
1069}
1070#[cfg(feature = "derive")]
1071pub fn visit_data_union_mut<V>(v: &mut V, node: &mut DataUnion)
1072where
1073 V: VisitMut + ?Sized,
1074{
1075 tokens_helper(visitor:v, &mut node.union_token.span);
1076 v.visit_fields_named_mut(&mut node.fields);
1077}
1078#[cfg(feature = "derive")]
1079pub fn visit_derive_input_mut<V>(v: &mut V, node: &mut DeriveInput)
1080where
1081 V: VisitMut + ?Sized,
1082{
1083 for it: &mut Attribute 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"))]
1092pub fn visit_expr_mut<V>(v: &mut V, node: &mut Expr)
1093where
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")]
1222pub fn visit_expr_array_mut<V>(v: &mut V, node: &mut ExprArray)
1223where
1224 V: VisitMut + ?Sized,
1225{
1226 for it: &mut Attribute in &mut node.attrs {
1227 v.visit_attribute_mut(it);
1228 }
1229 tokens_helper(visitor:v, &mut node.bracket_token.span);
1230 for el: Pair<&mut Expr, &mut Comma> in Punctuated::pairs_mut(&mut node.elems) {
1231 let (it: &mut Expr, p: Option<&mut Comma>) = el.into_tuple();
1232 v.visit_expr_mut(it);
1233 if let Some(p: &mut Comma) = p {
1234 tokens_helper(visitor:v, &mut p.spans);
1235 }
1236 }
1237}
1238#[cfg(feature = "full")]
1239pub fn visit_expr_assign_mut<V>(v: &mut V, node: &mut ExprAssign)
1240where
1241 V: VisitMut + ?Sized,
1242{
1243 for it: &mut Attribute in &mut node.attrs {
1244 v.visit_attribute_mut(it);
1245 }
1246 v.visit_expr_mut(&mut *node.left);
1247 tokens_helper(visitor:v, &mut node.eq_token.spans);
1248 v.visit_expr_mut(&mut *node.right);
1249}
1250#[cfg(feature = "full")]
1251pub fn visit_expr_assign_op_mut<V>(v: &mut V, node: &mut ExprAssignOp)
1252where
1253 V: VisitMut + ?Sized,
1254{
1255 for it: &mut Attribute 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")]
1263pub fn visit_expr_async_mut<V>(v: &mut V, node: &mut ExprAsync)
1264where
1265 V: VisitMut + ?Sized,
1266{
1267 for it: &mut Attribute in &mut node.attrs {
1268 v.visit_attribute_mut(it);
1269 }
1270 tokens_helper(visitor:v, &mut node.async_token.span);
1271 if let Some(it: &mut Move) = &mut node.capture {
1272 tokens_helper(visitor:v, &mut it.span);
1273 }
1274 v.visit_block_mut(&mut node.block);
1275}
1276#[cfg(feature = "full")]
1277pub fn visit_expr_await_mut<V>(v: &mut V, node: &mut ExprAwait)
1278where
1279 V: VisitMut + ?Sized,
1280{
1281 for it: &mut Attribute in &mut node.attrs {
1282 v.visit_attribute_mut(it);
1283 }
1284 v.visit_expr_mut(&mut *node.base);
1285 tokens_helper(visitor:v, &mut node.dot_token.spans);
1286 tokens_helper(visitor:v, &mut node.await_token.span);
1287}
1288#[cfg(any(feature = "derive", feature = "full"))]
1289pub fn visit_expr_binary_mut<V>(v: &mut V, node: &mut ExprBinary)
1290where
1291 V: VisitMut + ?Sized,
1292{
1293 for it: &mut Attribute 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")]
1301pub fn visit_expr_block_mut<V>(v: &mut V, node: &mut ExprBlock)
1302where
1303 V: VisitMut + ?Sized,
1304{
1305 for it: &mut Attribute in &mut node.attrs {
1306 v.visit_attribute_mut(it);
1307 }
1308 if let Some(it: &mut Label) = &mut node.label {
1309 v.visit_label_mut(it);
1310 }
1311 v.visit_block_mut(&mut node.block);
1312}
1313#[cfg(feature = "full")]
1314pub fn visit_expr_box_mut<V>(v: &mut V, node: &mut ExprBox)
1315where
1316 V: VisitMut + ?Sized,
1317{
1318 for it: &mut Attribute in &mut node.attrs {
1319 v.visit_attribute_mut(it);
1320 }
1321 tokens_helper(visitor:v, &mut node.box_token.span);
1322 v.visit_expr_mut(&mut *node.expr);
1323}
1324#[cfg(feature = "full")]
1325pub fn visit_expr_break_mut<V>(v: &mut V, node: &mut ExprBreak)
1326where
1327 V: VisitMut + ?Sized,
1328{
1329 for it: &mut Attribute in &mut node.attrs {
1330 v.visit_attribute_mut(it);
1331 }
1332 tokens_helper(visitor:v, &mut node.break_token.span);
1333 if let Some(it: &mut Lifetime) = &mut node.label {
1334 v.visit_lifetime_mut(it);
1335 }
1336 if let Some(it: &mut Box) = &mut node.expr {
1337 v.visit_expr_mut(&mut **it);
1338 }
1339}
1340#[cfg(any(feature = "derive", feature = "full"))]
1341pub fn visit_expr_call_mut<V>(v: &mut V, node: &mut ExprCall)
1342where
1343 V: VisitMut + ?Sized,
1344{
1345 for it: &mut Attribute in &mut node.attrs {
1346 v.visit_attribute_mut(it);
1347 }
1348 v.visit_expr_mut(&mut *node.func);
1349 tokens_helper(visitor:v, &mut node.paren_token.span);
1350 for el: Pair<&mut Expr, &mut Comma> in Punctuated::pairs_mut(&mut node.args) {
1351 let (it: &mut Expr, p: Option<&mut Comma>) = el.into_tuple();
1352 v.visit_expr_mut(it);
1353 if let Some(p: &mut Comma) = p {
1354 tokens_helper(visitor:v, &mut p.spans);
1355 }
1356 }
1357}
1358#[cfg(any(feature = "derive", feature = "full"))]
1359pub fn visit_expr_cast_mut<V>(v: &mut V, node: &mut ExprCast)
1360where
1361 V: VisitMut + ?Sized,
1362{
1363 for it: &mut Attribute in &mut node.attrs {
1364 v.visit_attribute_mut(it);
1365 }
1366 v.visit_expr_mut(&mut *node.expr);
1367 tokens_helper(visitor:v, &mut node.as_token.span);
1368 v.visit_type_mut(&mut *node.ty);
1369}
1370#[cfg(feature = "full")]
1371pub fn visit_expr_closure_mut<V>(v: &mut V, node: &mut ExprClosure)
1372where
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")]
1400pub fn visit_expr_continue_mut<V>(v: &mut V, node: &mut ExprContinue)
1401where
1402 V: VisitMut + ?Sized,
1403{
1404 for it: &mut Attribute in &mut node.attrs {
1405 v.visit_attribute_mut(it);
1406 }
1407 tokens_helper(visitor:v, &mut node.continue_token.span);
1408 if let Some(it: &mut Lifetime) = &mut node.label {
1409 v.visit_lifetime_mut(it);
1410 }
1411}
1412#[cfg(any(feature = "derive", feature = "full"))]
1413pub fn visit_expr_field_mut<V>(v: &mut V, node: &mut ExprField)
1414where
1415 V: VisitMut + ?Sized,
1416{
1417 for it: &mut Attribute in &mut node.attrs {
1418 v.visit_attribute_mut(it);
1419 }
1420 v.visit_expr_mut(&mut *node.base);
1421 tokens_helper(visitor:v, &mut node.dot_token.spans);
1422 v.visit_member_mut(&mut node.member);
1423}
1424#[cfg(feature = "full")]
1425pub fn visit_expr_for_loop_mut<V>(v: &mut V, node: &mut ExprForLoop)
1426where
1427 V: VisitMut + ?Sized,
1428{
1429 for it: &mut Attribute in &mut node.attrs {
1430 v.visit_attribute_mut(it);
1431 }
1432 if let Some(it: &mut Label) = &mut node.label {
1433 v.visit_label_mut(it);
1434 }
1435 tokens_helper(visitor:v, &mut node.for_token.span);
1436 v.visit_pat_mut(&mut node.pat);
1437 tokens_helper(visitor: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")]
1442pub fn visit_expr_group_mut<V>(v: &mut V, node: &mut ExprGroup)
1443where
1444 V: VisitMut + ?Sized,
1445{
1446 for it: &mut Attribute in &mut node.attrs {
1447 v.visit_attribute_mut(it);
1448 }
1449 tokens_helper(visitor:v, &mut node.group_token.span);
1450 v.visit_expr_mut(&mut *node.expr);
1451}
1452#[cfg(feature = "full")]
1453pub fn visit_expr_if_mut<V>(v: &mut V, node: &mut ExprIf)
1454where
1455 V: VisitMut + ?Sized,
1456{
1457 for it: &mut Attribute in &mut node.attrs {
1458 v.visit_attribute_mut(it);
1459 }
1460 tokens_helper(visitor: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 (Else, Box)) = &mut node.else_branch {
1464 tokens_helper(visitor:v, &mut (it).0.span);
1465 v.visit_expr_mut(&mut *(it).1);
1466 }
1467}
1468#[cfg(any(feature = "derive", feature = "full"))]
1469pub fn visit_expr_index_mut<V>(v: &mut V, node: &mut ExprIndex)
1470where
1471 V: VisitMut + ?Sized,
1472{
1473 for it: &mut Attribute in &mut node.attrs {
1474 v.visit_attribute_mut(it);
1475 }
1476 v.visit_expr_mut(&mut *node.expr);
1477 tokens_helper(visitor:v, &mut node.bracket_token.span);
1478 v.visit_expr_mut(&mut *node.index);
1479}
1480#[cfg(feature = "full")]
1481pub fn visit_expr_let_mut<V>(v: &mut V, node: &mut ExprLet)
1482where
1483 V: VisitMut + ?Sized,
1484{
1485 for it: &mut Attribute in &mut node.attrs {
1486 v.visit_attribute_mut(it);
1487 }
1488 tokens_helper(visitor:v, &mut node.let_token.span);
1489 v.visit_pat_mut(&mut node.pat);
1490 tokens_helper(visitor:v, &mut node.eq_token.spans);
1491 v.visit_expr_mut(&mut *node.expr);
1492}
1493#[cfg(any(feature = "derive", feature = "full"))]
1494pub fn visit_expr_lit_mut<V>(v: &mut V, node: &mut ExprLit)
1495where
1496 V: VisitMut + ?Sized,
1497{
1498 for it: &mut Attribute in &mut node.attrs {
1499 v.visit_attribute_mut(it);
1500 }
1501 v.visit_lit_mut(&mut node.lit);
1502}
1503#[cfg(feature = "full")]
1504pub fn visit_expr_loop_mut<V>(v: &mut V, node: &mut ExprLoop)
1505where
1506 V: VisitMut + ?Sized,
1507{
1508 for it: &mut Attribute in &mut node.attrs {
1509 v.visit_attribute_mut(it);
1510 }
1511 if let Some(it: &mut Label) = &mut node.label {
1512 v.visit_label_mut(it);
1513 }
1514 tokens_helper(visitor:v, &mut node.loop_token.span);
1515 v.visit_block_mut(&mut node.body);
1516}
1517#[cfg(feature = "full")]
1518pub fn visit_expr_macro_mut<V>(v: &mut V, node: &mut ExprMacro)
1519where
1520 V: VisitMut + ?Sized,
1521{
1522 for it: &mut Attribute in &mut node.attrs {
1523 v.visit_attribute_mut(it);
1524 }
1525 v.visit_macro_mut(&mut node.mac);
1526}
1527#[cfg(feature = "full")]
1528pub fn visit_expr_match_mut<V>(v: &mut V, node: &mut ExprMatch)
1529where
1530 V: VisitMut + ?Sized,
1531{
1532 for it: &mut Attribute in &mut node.attrs {
1533 v.visit_attribute_mut(it);
1534 }
1535 tokens_helper(visitor:v, &mut node.match_token.span);
1536 v.visit_expr_mut(&mut *node.expr);
1537 tokens_helper(visitor:v, &mut node.brace_token.span);
1538 for it: &mut Arm in &mut node.arms {
1539 v.visit_arm_mut(it);
1540 }
1541}
1542#[cfg(feature = "full")]
1543pub fn visit_expr_method_call_mut<V>(v: &mut V, node: &mut ExprMethodCall)
1544where
1545 V: VisitMut + ?Sized,
1546{
1547 for it: &mut Attribute in &mut node.attrs {
1548 v.visit_attribute_mut(it);
1549 }
1550 v.visit_expr_mut(&mut *node.receiver);
1551 tokens_helper(visitor:v, &mut node.dot_token.spans);
1552 v.visit_ident_mut(&mut node.method);
1553 if let Some(it: &mut MethodTurbofish) = &mut node.turbofish {
1554 v.visit_method_turbofish_mut(it);
1555 }
1556 tokens_helper(visitor:v, &mut node.paren_token.span);
1557 for el: Pair<&mut Expr, &mut Comma> in Punctuated::pairs_mut(&mut node.args) {
1558 let (it: &mut Expr, p: Option<&mut Comma>) = el.into_tuple();
1559 v.visit_expr_mut(it);
1560 if let Some(p: &mut Comma) = p {
1561 tokens_helper(visitor:v, &mut p.spans);
1562 }
1563 }
1564}
1565#[cfg(any(feature = "derive", feature = "full"))]
1566pub fn visit_expr_paren_mut<V>(v: &mut V, node: &mut ExprParen)
1567where
1568 V: VisitMut + ?Sized,
1569{
1570 for it: &mut Attribute in &mut node.attrs {
1571 v.visit_attribute_mut(it);
1572 }
1573 tokens_helper(visitor:v, &mut node.paren_token.span);
1574 v.visit_expr_mut(&mut *node.expr);
1575}
1576#[cfg(any(feature = "derive", feature = "full"))]
1577pub fn visit_expr_path_mut<V>(v: &mut V, node: &mut ExprPath)
1578where
1579 V: VisitMut + ?Sized,
1580{
1581 for it: &mut Attribute in &mut node.attrs {
1582 v.visit_attribute_mut(it);
1583 }
1584 if let Some(it: &mut QSelf) = &mut node.qself {
1585 v.visit_qself_mut(it);
1586 }
1587 v.visit_path_mut(&mut node.path);
1588}
1589#[cfg(feature = "full")]
1590pub fn visit_expr_range_mut<V>(v: &mut V, node: &mut ExprRange)
1591where
1592 V: VisitMut + ?Sized,
1593{
1594 for it: &mut Attribute in &mut node.attrs {
1595 v.visit_attribute_mut(it);
1596 }
1597 if let Some(it: &mut Box) = &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 Box) = &mut node.to {
1602 v.visit_expr_mut(&mut **it);
1603 }
1604}
1605#[cfg(feature = "full")]
1606pub fn visit_expr_reference_mut<V>(v: &mut V, node: &mut ExprReference)
1607where
1608 V: VisitMut + ?Sized,
1609{
1610 for it: &mut Attribute in &mut node.attrs {
1611 v.visit_attribute_mut(it);
1612 }
1613 tokens_helper(visitor:v, &mut node.and_token.spans);
1614 if let Some(it: &mut Mut) = &mut node.mutability {
1615 tokens_helper(visitor:v, &mut it.span);
1616 }
1617 v.visit_expr_mut(&mut *node.expr);
1618}
1619#[cfg(feature = "full")]
1620pub fn visit_expr_repeat_mut<V>(v: &mut V, node: &mut ExprRepeat)
1621where
1622 V: VisitMut + ?Sized,
1623{
1624 for it: &mut Attribute in &mut node.attrs {
1625 v.visit_attribute_mut(it);
1626 }
1627 tokens_helper(visitor:v, &mut node.bracket_token.span);
1628 v.visit_expr_mut(&mut *node.expr);
1629 tokens_helper(visitor:v, &mut node.semi_token.spans);
1630 v.visit_expr_mut(&mut *node.len);
1631}
1632#[cfg(feature = "full")]
1633pub fn visit_expr_return_mut<V>(v: &mut V, node: &mut ExprReturn)
1634where
1635 V: VisitMut + ?Sized,
1636{
1637 for it: &mut Attribute in &mut node.attrs {
1638 v.visit_attribute_mut(it);
1639 }
1640 tokens_helper(visitor:v, &mut node.return_token.span);
1641 if let Some(it: &mut Box) = &mut node.expr {
1642 v.visit_expr_mut(&mut **it);
1643 }
1644}
1645#[cfg(feature = "full")]
1646pub fn visit_expr_struct_mut<V>(v: &mut V, node: &mut ExprStruct)
1647where
1648 V: VisitMut + ?Sized,
1649{
1650 for it: &mut Attribute in &mut node.attrs {
1651 v.visit_attribute_mut(it);
1652 }
1653 v.visit_path_mut(&mut node.path);
1654 tokens_helper(visitor:v, &mut node.brace_token.span);
1655 for el: Pair<&mut FieldValue, &mut …> in Punctuated::pairs_mut(&mut node.fields) {
1656 let (it: &mut FieldValue, p: Option<&mut Comma>) = el.into_tuple();
1657 v.visit_field_value_mut(it);
1658 if let Some(p: &mut Comma) = p {
1659 tokens_helper(visitor:v, &mut p.spans);
1660 }
1661 }
1662 if let Some(it: &mut Dot2) = &mut node.dot2_token {
1663 tokens_helper(visitor:v, &mut it.spans);
1664 }
1665 if let Some(it: &mut Box) = &mut node.rest {
1666 v.visit_expr_mut(&mut **it);
1667 }
1668}
1669#[cfg(feature = "full")]
1670pub fn visit_expr_try_mut<V>(v: &mut V, node: &mut ExprTry)
1671where
1672 V: VisitMut + ?Sized,
1673{
1674 for it: &mut Attribute in &mut node.attrs {
1675 v.visit_attribute_mut(it);
1676 }
1677 v.visit_expr_mut(&mut *node.expr);
1678 tokens_helper(visitor:v, &mut node.question_token.spans);
1679}
1680#[cfg(feature = "full")]
1681pub fn visit_expr_try_block_mut<V>(v: &mut V, node: &mut ExprTryBlock)
1682where
1683 V: VisitMut + ?Sized,
1684{
1685 for it: &mut Attribute in &mut node.attrs {
1686 v.visit_attribute_mut(it);
1687 }
1688 tokens_helper(visitor:v, &mut node.try_token.span);
1689 v.visit_block_mut(&mut node.block);
1690}
1691#[cfg(feature = "full")]
1692pub fn visit_expr_tuple_mut<V>(v: &mut V, node: &mut ExprTuple)
1693where
1694 V: VisitMut + ?Sized,
1695{
1696 for it: &mut Attribute in &mut node.attrs {
1697 v.visit_attribute_mut(it);
1698 }
1699 tokens_helper(visitor:v, &mut node.paren_token.span);
1700 for el: Pair<&mut Expr, &mut Comma> in Punctuated::pairs_mut(&mut node.elems) {
1701 let (it: &mut Expr, p: Option<&mut Comma>) = el.into_tuple();
1702 v.visit_expr_mut(it);
1703 if let Some(p: &mut Comma) = p {
1704 tokens_helper(visitor:v, &mut p.spans);
1705 }
1706 }
1707}
1708#[cfg(feature = "full")]
1709pub fn visit_expr_type_mut<V>(v: &mut V, node: &mut ExprType)
1710where
1711 V: VisitMut + ?Sized,
1712{
1713 for it: &mut Attribute in &mut node.attrs {
1714 v.visit_attribute_mut(it);
1715 }
1716 v.visit_expr_mut(&mut *node.expr);
1717 tokens_helper(visitor:v, &mut node.colon_token.spans);
1718 v.visit_type_mut(&mut *node.ty);
1719}
1720#[cfg(any(feature = "derive", feature = "full"))]
1721pub fn visit_expr_unary_mut<V>(v: &mut V, node: &mut ExprUnary)
1722where
1723 V: VisitMut + ?Sized,
1724{
1725 for it: &mut Attribute 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")]
1732pub fn visit_expr_unsafe_mut<V>(v: &mut V, node: &mut ExprUnsafe)
1733where
1734 V: VisitMut + ?Sized,
1735{
1736 for it: &mut Attribute in &mut node.attrs {
1737 v.visit_attribute_mut(it);
1738 }
1739 tokens_helper(visitor:v, &mut node.unsafe_token.span);
1740 v.visit_block_mut(&mut node.block);
1741}
1742#[cfg(feature = "full")]
1743pub fn visit_expr_while_mut<V>(v: &mut V, node: &mut ExprWhile)
1744where
1745 V: VisitMut + ?Sized,
1746{
1747 for it: &mut Attribute in &mut node.attrs {
1748 v.visit_attribute_mut(it);
1749 }
1750 if let Some(it: &mut Label) = &mut node.label {
1751 v.visit_label_mut(it);
1752 }
1753 tokens_helper(visitor: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")]
1758pub fn visit_expr_yield_mut<V>(v: &mut V, node: &mut ExprYield)
1759where
1760 V: VisitMut + ?Sized,
1761{
1762 for it: &mut Attribute in &mut node.attrs {
1763 v.visit_attribute_mut(it);
1764 }
1765 tokens_helper(visitor:v, &mut node.yield_token.span);
1766 if let Some(it: &mut Box) = &mut node.expr {
1767 v.visit_expr_mut(&mut **it);
1768 }
1769}
1770#[cfg(any(feature = "derive", feature = "full"))]
1771pub fn visit_field_mut<V>(v: &mut V, node: &mut Field)
1772where
1773 V: VisitMut + ?Sized,
1774{
1775 for it: &mut Attribute 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 Ident) = &mut node.ident {
1780 v.visit_ident_mut(it);
1781 }
1782 if let Some(it: &mut Colon) = &mut node.colon_token {
1783 tokens_helper(visitor:v, &mut it.spans);
1784 }
1785 v.visit_type_mut(&mut node.ty);
1786}
1787#[cfg(feature = "full")]
1788pub fn visit_field_pat_mut<V>(v: &mut V, node: &mut FieldPat)
1789where
1790 V: VisitMut + ?Sized,
1791{
1792 for it: &mut Attribute 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 Colon) = &mut node.colon_token {
1797 tokens_helper(visitor:v, &mut it.spans);
1798 }
1799 v.visit_pat_mut(&mut *node.pat);
1800}
1801#[cfg(feature = "full")]
1802pub fn visit_field_value_mut<V>(v: &mut V, node: &mut FieldValue)
1803where
1804 V: VisitMut + ?Sized,
1805{
1806 for it: &mut Attribute 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 Colon) = &mut node.colon_token {
1811 tokens_helper(visitor:v, &mut it.spans);
1812 }
1813 v.visit_expr_mut(&mut node.expr);
1814}
1815#[cfg(any(feature = "derive", feature = "full"))]
1816pub fn visit_fields_mut<V>(v: &mut V, node: &mut Fields)
1817where
1818 V: VisitMut + ?Sized,
1819{
1820 match node {
1821 Fields::Named(_binding_0: &mut FieldsNamed) => {
1822 v.visit_fields_named_mut(_binding_0);
1823 }
1824 Fields::Unnamed(_binding_0: &mut FieldsUnnamed) => {
1825 v.visit_fields_unnamed_mut(_binding_0);
1826 }
1827 Fields::Unit => {}
1828 }
1829}
1830#[cfg(any(feature = "derive", feature = "full"))]
1831pub fn visit_fields_named_mut<V>(v: &mut V, node: &mut FieldsNamed)
1832where
1833 V: VisitMut + ?Sized,
1834{
1835 tokens_helper(visitor:v, &mut node.brace_token.span);
1836 for el: Pair<&mut Field, &mut Comma> in Punctuated::pairs_mut(&mut node.named) {
1837 let (it: &mut Field, p: Option<&mut Comma>) = el.into_tuple();
1838 v.visit_field_mut(it);
1839 if let Some(p: &mut Comma) = p {
1840 tokens_helper(visitor:v, &mut p.spans);
1841 }
1842 }
1843}
1844#[cfg(any(feature = "derive", feature = "full"))]
1845pub fn visit_fields_unnamed_mut<V>(v: &mut V, node: &mut FieldsUnnamed)
1846where
1847 V: VisitMut + ?Sized,
1848{
1849 tokens_helper(visitor:v, &mut node.paren_token.span);
1850 for el: Pair<&mut Field, &mut Comma> in Punctuated::pairs_mut(&mut node.unnamed) {
1851 let (it: &mut Field, p: Option<&mut Comma>) = el.into_tuple();
1852 v.visit_field_mut(it);
1853 if let Some(p: &mut Comma) = p {
1854 tokens_helper(visitor:v, &mut p.spans);
1855 }
1856 }
1857}
1858#[cfg(feature = "full")]
1859pub fn visit_file_mut<V>(v: &mut V, node: &mut File)
1860where
1861 V: VisitMut + ?Sized,
1862{
1863 skip!(node.shebang);
1864 for it: &mut Attribute in &mut node.attrs {
1865 v.visit_attribute_mut(it);
1866 }
1867 for it: &mut Item in &mut node.items {
1868 v.visit_item_mut(it);
1869 }
1870}
1871#[cfg(feature = "full")]
1872pub fn visit_fn_arg_mut<V>(v: &mut V, node: &mut FnArg)
1873where
1874 V: VisitMut + ?Sized,
1875{
1876 match node {
1877 FnArg::Receiver(_binding_0: &mut Receiver) => {
1878 v.visit_receiver_mut(_binding_0);
1879 }
1880 FnArg::Typed(_binding_0: &mut PatType) => {
1881 v.visit_pat_type_mut(_binding_0);
1882 }
1883 }
1884}
1885#[cfg(feature = "full")]
1886pub fn visit_foreign_item_mut<V>(v: &mut V, node: &mut ForeignItem)
1887where
1888 V: VisitMut + ?Sized,
1889{
1890 match node {
1891 ForeignItem::Fn(_binding_0: &mut ForeignItemFn) => {
1892 v.visit_foreign_item_fn_mut(_binding_0);
1893 }
1894 ForeignItem::Static(_binding_0: &mut ForeignItemStatic) => {
1895 v.visit_foreign_item_static_mut(_binding_0);
1896 }
1897 ForeignItem::Type(_binding_0: &mut ForeignItemType) => {
1898 v.visit_foreign_item_type_mut(_binding_0);
1899 }
1900 ForeignItem::Macro(_binding_0: &mut ForeignItemMacro) => {
1901 v.visit_foreign_item_macro_mut(_binding_0);
1902 }
1903 ForeignItem::Verbatim(_binding_0: &mut TokenStream) => {
1904 skip!(_binding_0);
1905 }
1906 #[cfg(syn_no_non_exhaustive)]
1907 _ => unreachable!(),
1908 }
1909}
1910#[cfg(feature = "full")]
1911pub fn visit_foreign_item_fn_mut<V>(v: &mut V, node: &mut ForeignItemFn)
1912where
1913 V: VisitMut + ?Sized,
1914{
1915 for it: &mut Attribute 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(visitor:v, &mut node.semi_token.spans);
1921}
1922#[cfg(feature = "full")]
1923pub fn visit_foreign_item_macro_mut<V>(v: &mut V, node: &mut ForeignItemMacro)
1924where
1925 V: VisitMut + ?Sized,
1926{
1927 for it: &mut Attribute 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 Semi) = &mut node.semi_token {
1932 tokens_helper(visitor:v, &mut it.spans);
1933 }
1934}
1935#[cfg(feature = "full")]
1936pub fn visit_foreign_item_static_mut<V>(v: &mut V, node: &mut ForeignItemStatic)
1937where
1938 V: VisitMut + ?Sized,
1939{
1940 for it: &mut Attribute in &mut node.attrs {
1941 v.visit_attribute_mut(it);
1942 }
1943 v.visit_visibility_mut(&mut node.vis);
1944 tokens_helper(visitor:v, &mut node.static_token.span);
1945 if let Some(it: &mut Mut) = &mut node.mutability {
1946 tokens_helper(visitor:v, &mut it.span);
1947 }
1948 v.visit_ident_mut(&mut node.ident);
1949 tokens_helper(visitor:v, &mut node.colon_token.spans);
1950 v.visit_type_mut(&mut *node.ty);
1951 tokens_helper(visitor:v, &mut node.semi_token.spans);
1952}
1953#[cfg(feature = "full")]
1954pub fn visit_foreign_item_type_mut<V>(v: &mut V, node: &mut ForeignItemType)
1955where
1956 V: VisitMut + ?Sized,
1957{
1958 for it: &mut Attribute in &mut node.attrs {
1959 v.visit_attribute_mut(it);
1960 }
1961 v.visit_visibility_mut(&mut node.vis);
1962 tokens_helper(visitor:v, &mut node.type_token.span);
1963 v.visit_ident_mut(&mut node.ident);
1964 tokens_helper(visitor:v, &mut node.semi_token.spans);
1965}
1966#[cfg(any(feature = "derive", feature = "full"))]
1967pub fn visit_generic_argument_mut<V>(v: &mut V, node: &mut GenericArgument)
1968where
1969 V: VisitMut + ?Sized,
1970{
1971 match node {
1972 GenericArgument::Lifetime(_binding_0: &mut Lifetime) => {
1973 v.visit_lifetime_mut(_binding_0);
1974 }
1975 GenericArgument::Type(_binding_0: &mut Type) => {
1976 v.visit_type_mut(_binding_0);
1977 }
1978 GenericArgument::Const(_binding_0: &mut Expr) => {
1979 v.visit_expr_mut(_binding_0);
1980 }
1981 GenericArgument::Binding(_binding_0: &mut Binding) => {
1982 v.visit_binding_mut(_binding_0);
1983 }
1984 GenericArgument::Constraint(_binding_0: &mut Constraint) => {
1985 v.visit_constraint_mut(_binding_0);
1986 }
1987 }
1988}
1989#[cfg(feature = "full")]
1990pub fn visit_generic_method_argument_mut<V>(v: &mut V, node: &mut GenericMethodArgument)
1991where
1992 V: VisitMut + ?Sized,
1993{
1994 match node {
1995 GenericMethodArgument::Type(_binding_0: &mut Type) => {
1996 v.visit_type_mut(_binding_0);
1997 }
1998 GenericMethodArgument::Const(_binding_0: &mut Expr) => {
1999 v.visit_expr_mut(_binding_0);
2000 }
2001 }
2002}
2003#[cfg(any(feature = "derive", feature = "full"))]
2004pub fn visit_generic_param_mut<V>(v: &mut V, node: &mut GenericParam)
2005where
2006 V: VisitMut + ?Sized,
2007{
2008 match node {
2009 GenericParam::Type(_binding_0: &mut TypeParam) => {
2010 v.visit_type_param_mut(_binding_0);
2011 }
2012 GenericParam::Lifetime(_binding_0: &mut LifetimeDef) => {
2013 v.visit_lifetime_def_mut(_binding_0);
2014 }
2015 GenericParam::Const(_binding_0: &mut ConstParam) => {
2016 v.visit_const_param_mut(_binding_0);
2017 }
2018 }
2019}
2020#[cfg(any(feature = "derive", feature = "full"))]
2021pub fn visit_generics_mut<V>(v: &mut V, node: &mut Generics)
2022where
2023 V: VisitMut + ?Sized,
2024{
2025 if let Some(it: &mut Lt) = &mut node.lt_token {
2026 tokens_helper(visitor:v, &mut it.spans);
2027 }
2028 for el: Pair<&mut GenericParam, &mut …> in Punctuated::pairs_mut(&mut node.params) {
2029 let (it: &mut GenericParam, p: Option<&mut Comma>) = el.into_tuple();
2030 v.visit_generic_param_mut(it);
2031 if let Some(p: &mut Comma) = p {
2032 tokens_helper(visitor:v, &mut p.spans);
2033 }
2034 }
2035 if let Some(it: &mut Gt) = &mut node.gt_token {
2036 tokens_helper(visitor:v, &mut it.spans);
2037 }
2038 if let Some(it: &mut WhereClause) = &mut node.where_clause {
2039 v.visit_where_clause_mut(it);
2040 }
2041}
2042pub fn visit_ident_mut<V>(v: &mut V, node: &mut Ident)
2043where
2044 V: VisitMut + ?Sized,
2045{
2046 let mut span: Span = node.span();
2047 v.visit_span_mut(&mut span);
2048 node.set_span(span);
2049}
2050#[cfg(feature = "full")]
2051pub fn visit_impl_item_mut<V>(v: &mut V, node: &mut ImplItem)
2052where
2053 V: VisitMut + ?Sized,
2054{
2055 match node {
2056 ImplItem::Const(_binding_0: &mut ImplItemConst) => {
2057 v.visit_impl_item_const_mut(_binding_0);
2058 }
2059 ImplItem::Method(_binding_0: &mut ImplItemMethod) => {
2060 v.visit_impl_item_method_mut(_binding_0);
2061 }
2062 ImplItem::Type(_binding_0: &mut ImplItemType) => {
2063 v.visit_impl_item_type_mut(_binding_0);
2064 }
2065 ImplItem::Macro(_binding_0: &mut ImplItemMacro) => {
2066 v.visit_impl_item_macro_mut(_binding_0);
2067 }
2068 ImplItem::Verbatim(_binding_0: &mut TokenStream) => {
2069 skip!(_binding_0);
2070 }
2071 #[cfg(syn_no_non_exhaustive)]
2072 _ => unreachable!(),
2073 }
2074}
2075#[cfg(feature = "full")]
2076pub fn visit_impl_item_const_mut<V>(v: &mut V, node: &mut ImplItemConst)
2077where
2078 V: VisitMut + ?Sized,
2079{
2080 for it: &mut Attribute 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 Default) = &mut node.defaultness {
2085 tokens_helper(visitor:v, &mut it.span);
2086 }
2087 tokens_helper(visitor:v, &mut node.const_token.span);
2088 v.visit_ident_mut(&mut node.ident);
2089 tokens_helper(visitor:v, &mut node.colon_token.spans);
2090 v.visit_type_mut(&mut node.ty);
2091 tokens_helper(visitor:v, &mut node.eq_token.spans);
2092 v.visit_expr_mut(&mut node.expr);
2093 tokens_helper(visitor:v, &mut node.semi_token.spans);
2094}
2095#[cfg(feature = "full")]
2096pub fn visit_impl_item_macro_mut<V>(v: &mut V, node: &mut ImplItemMacro)
2097where
2098 V: VisitMut + ?Sized,
2099{
2100 for it: &mut Attribute 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 Semi) = &mut node.semi_token {
2105 tokens_helper(visitor:v, &mut it.spans);
2106 }
2107}
2108#[cfg(feature = "full")]
2109pub fn visit_impl_item_method_mut<V>(v: &mut V, node: &mut ImplItemMethod)
2110where
2111 V: VisitMut + ?Sized,
2112{
2113 for it: &mut Attribute 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 Default) = &mut node.defaultness {
2118 tokens_helper(visitor: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")]
2124pub fn visit_impl_item_type_mut<V>(v: &mut V, node: &mut ImplItemType)
2125where
2126 V: VisitMut + ?Sized,
2127{
2128 for it: &mut Attribute 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 Default) = &mut node.defaultness {
2133 tokens_helper(visitor:v, &mut it.span);
2134 }
2135 tokens_helper(visitor: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(visitor:v, &mut node.eq_token.spans);
2139 v.visit_type_mut(&mut node.ty);
2140 tokens_helper(visitor:v, &mut node.semi_token.spans);
2141}
2142#[cfg(any(feature = "derive", feature = "full"))]
2143pub fn visit_index_mut<V>(v: &mut V, node: &mut Index)
2144where
2145 V: VisitMut + ?Sized,
2146{
2147 skip!(node.index);
2148 v.visit_span_mut(&mut node.span);
2149}
2150#[cfg(feature = "full")]
2151pub fn visit_item_mut<V>(v: &mut V, node: &mut Item)
2152where
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")]
2212pub fn visit_item_const_mut<V>(v: &mut V, node: &mut ItemConst)
2213where
2214 V: VisitMut + ?Sized,
2215{
2216 for it: &mut Attribute in &mut node.attrs {
2217 v.visit_attribute_mut(it);
2218 }
2219 v.visit_visibility_mut(&mut node.vis);
2220 tokens_helper(visitor:v, &mut node.const_token.span);
2221 v.visit_ident_mut(&mut node.ident);
2222 tokens_helper(visitor:v, &mut node.colon_token.spans);
2223 v.visit_type_mut(&mut *node.ty);
2224 tokens_helper(visitor:v, &mut node.eq_token.spans);
2225 v.visit_expr_mut(&mut *node.expr);
2226 tokens_helper(visitor:v, &mut node.semi_token.spans);
2227}
2228#[cfg(feature = "full")]
2229pub fn visit_item_enum_mut<V>(v: &mut V, node: &mut ItemEnum)
2230where
2231 V: VisitMut + ?Sized,
2232{
2233 for it: &mut Attribute in &mut node.attrs {
2234 v.visit_attribute_mut(it);
2235 }
2236 v.visit_visibility_mut(&mut node.vis);
2237 tokens_helper(visitor: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(visitor:v, &mut node.brace_token.span);
2241 for el: Pair<&mut Variant, &mut Comma> in Punctuated::pairs_mut(&mut node.variants) {
2242 let (it: &mut Variant, p: Option<&mut Comma>) = el.into_tuple();
2243 v.visit_variant_mut(it);
2244 if let Some(p: &mut Comma) = p {
2245 tokens_helper(visitor:v, &mut p.spans);
2246 }
2247 }
2248}
2249#[cfg(feature = "full")]
2250pub fn visit_item_extern_crate_mut<V>(v: &mut V, node: &mut ItemExternCrate)
2251where
2252 V: VisitMut + ?Sized,
2253{
2254 for it: &mut Attribute in &mut node.attrs {
2255 v.visit_attribute_mut(it);
2256 }
2257 v.visit_visibility_mut(&mut node.vis);
2258 tokens_helper(visitor:v, &mut node.extern_token.span);
2259 tokens_helper(visitor:v, &mut node.crate_token.span);
2260 v.visit_ident_mut(&mut node.ident);
2261 if let Some(it: &mut (As, Ident)) = &mut node.rename {
2262 tokens_helper(visitor:v, &mut (it).0.span);
2263 v.visit_ident_mut(&mut (it).1);
2264 }
2265 tokens_helper(visitor:v, &mut node.semi_token.spans);
2266}
2267#[cfg(feature = "full")]
2268pub fn visit_item_fn_mut<V>(v: &mut V, node: &mut ItemFn)
2269where
2270 V: VisitMut + ?Sized,
2271{
2272 for it: &mut Attribute 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")]
2280pub fn visit_item_foreign_mod_mut<V>(v: &mut V, node: &mut ItemForeignMod)
2281where
2282 V: VisitMut + ?Sized,
2283{
2284 for it: &mut Attribute in &mut node.attrs {
2285 v.visit_attribute_mut(it);
2286 }
2287 v.visit_abi_mut(&mut node.abi);
2288 tokens_helper(visitor:v, &mut node.brace_token.span);
2289 for it: &mut ForeignItem in &mut node.items {
2290 v.visit_foreign_item_mut(it);
2291 }
2292}
2293#[cfg(feature = "full")]
2294pub fn visit_item_impl_mut<V>(v: &mut V, node: &mut ItemImpl)
2295where
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")]
2323pub fn visit_item_macro_mut<V>(v: &mut V, node: &mut ItemMacro)
2324where
2325 V: VisitMut + ?Sized,
2326{
2327 for it: &mut Attribute in &mut node.attrs {
2328 v.visit_attribute_mut(it);
2329 }
2330 if let Some(it: &mut Ident) = &mut node.ident {
2331 v.visit_ident_mut(it);
2332 }
2333 v.visit_macro_mut(&mut node.mac);
2334 if let Some(it: &mut Semi) = &mut node.semi_token {
2335 tokens_helper(visitor:v, &mut it.spans);
2336 }
2337}
2338#[cfg(feature = "full")]
2339pub fn visit_item_macro2_mut<V>(v: &mut V, node: &mut ItemMacro2)
2340where
2341 V: VisitMut + ?Sized,
2342{
2343 for it: &mut Attribute in &mut node.attrs {
2344 v.visit_attribute_mut(it);
2345 }
2346 v.visit_visibility_mut(&mut node.vis);
2347 tokens_helper(visitor:v, &mut node.macro_token.span);
2348 v.visit_ident_mut(&mut node.ident);
2349 skip!(node.rules);
2350}
2351#[cfg(feature = "full")]
2352pub fn visit_item_mod_mut<V>(v: &mut V, node: &mut ItemMod)
2353where
2354 V: VisitMut + ?Sized,
2355{
2356 for it: &mut Attribute in &mut node.attrs {
2357 v.visit_attribute_mut(it);
2358 }
2359 v.visit_visibility_mut(&mut node.vis);
2360 tokens_helper(visitor:v, &mut node.mod_token.span);
2361 v.visit_ident_mut(&mut node.ident);
2362 if let Some(it: &mut (Brace, Vec)) = &mut node.content {
2363 tokens_helper(visitor:v, &mut (it).0.span);
2364 for it: &mut Item in &mut (it).1 {
2365 v.visit_item_mut(it);
2366 }
2367 }
2368 if let Some(it: &mut Semi) = &mut node.semi {
2369 tokens_helper(visitor:v, &mut it.spans);
2370 }
2371}
2372#[cfg(feature = "full")]
2373pub fn visit_item_static_mut<V>(v: &mut V, node: &mut ItemStatic)
2374where
2375 V: VisitMut + ?Sized,
2376{
2377 for it: &mut Attribute in &mut node.attrs {
2378 v.visit_attribute_mut(it);
2379 }
2380 v.visit_visibility_mut(&mut node.vis);
2381 tokens_helper(visitor:v, &mut node.static_token.span);
2382 if let Some(it: &mut Mut) = &mut node.mutability {
2383 tokens_helper(visitor:v, &mut it.span);
2384 }
2385 v.visit_ident_mut(&mut node.ident);
2386 tokens_helper(visitor:v, &mut node.colon_token.spans);
2387 v.visit_type_mut(&mut *node.ty);
2388 tokens_helper(visitor:v, &mut node.eq_token.spans);
2389 v.visit_expr_mut(&mut *node.expr);
2390 tokens_helper(visitor:v, &mut node.semi_token.spans);
2391}
2392#[cfg(feature = "full")]
2393pub fn visit_item_struct_mut<V>(v: &mut V, node: &mut ItemStruct)
2394where
2395 V: VisitMut + ?Sized,
2396{
2397 for it: &mut Attribute in &mut node.attrs {
2398 v.visit_attribute_mut(it);
2399 }
2400 v.visit_visibility_mut(&mut node.vis);
2401 tokens_helper(visitor: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 Semi) = &mut node.semi_token {
2406 tokens_helper(visitor:v, &mut it.spans);
2407 }
2408}
2409#[cfg(feature = "full")]
2410pub fn visit_item_trait_mut<V>(v: &mut V, node: &mut ItemTrait)
2411where
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")]
2443pub fn visit_item_trait_alias_mut<V>(v: &mut V, node: &mut ItemTraitAlias)
2444where
2445 V: VisitMut + ?Sized,
2446{
2447 for it: &mut Attribute in &mut node.attrs {
2448 v.visit_attribute_mut(it);
2449 }
2450 v.visit_visibility_mut(&mut node.vis);
2451 tokens_helper(visitor: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(visitor:v, &mut node.eq_token.spans);
2455 for el: Pair<&mut TypeParamBound, …> in Punctuated::pairs_mut(&mut node.bounds) {
2456 let (it: &mut TypeParamBound, p: Option<&mut Add>) = el.into_tuple();
2457 v.visit_type_param_bound_mut(it);
2458 if let Some(p: &mut Add) = p {
2459 tokens_helper(visitor:v, &mut p.spans);
2460 }
2461 }
2462 tokens_helper(visitor:v, &mut node.semi_token.spans);
2463}
2464#[cfg(feature = "full")]
2465pub fn visit_item_type_mut<V>(v: &mut V, node: &mut ItemType)
2466where
2467 V: VisitMut + ?Sized,
2468{
2469 for it: &mut Attribute in &mut node.attrs {
2470 v.visit_attribute_mut(it);
2471 }
2472 v.visit_visibility_mut(&mut node.vis);
2473 tokens_helper(visitor: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(visitor:v, &mut node.eq_token.spans);
2477 v.visit_type_mut(&mut *node.ty);
2478 tokens_helper(visitor:v, &mut node.semi_token.spans);
2479}
2480#[cfg(feature = "full")]
2481pub fn visit_item_union_mut<V>(v: &mut V, node: &mut ItemUnion)
2482where
2483 V: VisitMut + ?Sized,
2484{
2485 for it: &mut Attribute in &mut node.attrs {
2486 v.visit_attribute_mut(it);
2487 }
2488 v.visit_visibility_mut(&mut node.vis);
2489 tokens_helper(visitor: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")]
2495pub fn visit_item_use_mut<V>(v: &mut V, node: &mut ItemUse)
2496where
2497 V: VisitMut + ?Sized,
2498{
2499 for it: &mut Attribute in &mut node.attrs {
2500 v.visit_attribute_mut(it);
2501 }
2502 v.visit_visibility_mut(&mut node.vis);
2503 tokens_helper(visitor:v, &mut node.use_token.span);
2504 if let Some(it: &mut Colon2) = &mut node.leading_colon {
2505 tokens_helper(visitor:v, &mut it.spans);
2506 }
2507 v.visit_use_tree_mut(&mut node.tree);
2508 tokens_helper(visitor:v, &mut node.semi_token.spans);
2509}
2510#[cfg(feature = "full")]
2511pub fn visit_label_mut<V>(v: &mut V, node: &mut Label)
2512where
2513 V: VisitMut + ?Sized,
2514{
2515 v.visit_lifetime_mut(&mut node.name);
2516 tokens_helper(visitor:v, &mut node.colon_token.spans);
2517}
2518pub fn visit_lifetime_mut<V>(v: &mut V, node: &mut Lifetime)
2519where
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"))]
2526pub fn visit_lifetime_def_mut<V>(v: &mut V, node: &mut LifetimeDef)
2527where
2528 V: VisitMut + ?Sized,
2529{
2530 for it: &mut Attribute 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 Colon) = &mut node.colon_token {
2535 tokens_helper(visitor:v, &mut it.spans);
2536 }
2537 for el: Pair<&mut Lifetime, &mut …> in Punctuated::pairs_mut(&mut node.bounds) {
2538 let (it: &mut Lifetime, p: Option<&mut Add>) = el.into_tuple();
2539 v.visit_lifetime_mut(it);
2540 if let Some(p: &mut Add) = p {
2541 tokens_helper(visitor:v, &mut p.spans);
2542 }
2543 }
2544}
2545pub fn visit_lit_mut<V>(v: &mut V, node: &mut Lit)
2546where
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}
2576pub fn visit_lit_bool_mut<V>(v: &mut V, node: &mut LitBool)
2577where
2578 V: VisitMut + ?Sized,
2579{
2580 skip!(node.value);
2581 v.visit_span_mut(&mut node.span);
2582}
2583pub fn visit_lit_byte_mut<V>(v: &mut V, node: &mut LitByte)
2584where
2585 V: VisitMut + ?Sized,
2586{}
2587pub fn visit_lit_byte_str_mut<V>(v: &mut V, node: &mut LitByteStr)
2588where
2589 V: VisitMut + ?Sized,
2590{}
2591pub fn visit_lit_char_mut<V>(v: &mut V, node: &mut LitChar)
2592where
2593 V: VisitMut + ?Sized,
2594{}
2595pub fn visit_lit_float_mut<V>(v: &mut V, node: &mut LitFloat)
2596where
2597 V: VisitMut + ?Sized,
2598{}
2599pub fn visit_lit_int_mut<V>(v: &mut V, node: &mut LitInt)
2600where
2601 V: VisitMut + ?Sized,
2602{}
2603pub fn visit_lit_str_mut<V>(v: &mut V, node: &mut LitStr)
2604where
2605 V: VisitMut + ?Sized,
2606{}
2607#[cfg(feature = "full")]
2608pub fn visit_local_mut<V>(v: &mut V, node: &mut Local)
2609where
2610 V: VisitMut + ?Sized,
2611{
2612 for it: &mut Attribute in &mut node.attrs {
2613 v.visit_attribute_mut(it);
2614 }
2615 tokens_helper(visitor:v, &mut node.let_token.span);
2616 v.visit_pat_mut(&mut node.pat);
2617 if let Some(it: &mut (Eq, Box)) = &mut node.init {
2618 tokens_helper(visitor:v, &mut (it).0.spans);
2619 v.visit_expr_mut(&mut *(it).1);
2620 }
2621 tokens_helper(visitor:v, &mut node.semi_token.spans);
2622}
2623#[cfg(any(feature = "derive", feature = "full"))]
2624pub fn visit_macro_mut<V>(v: &mut V, node: &mut Macro)
2625where
2626 V: VisitMut + ?Sized,
2627{
2628 v.visit_path_mut(&mut node.path);
2629 tokens_helper(visitor: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"))]
2634pub fn visit_macro_delimiter_mut<V>(v: &mut V, node: &mut MacroDelimiter)
2635where
2636 V: VisitMut + ?Sized,
2637{
2638 match node {
2639 MacroDelimiter::Paren(_binding_0: &mut Paren) => {
2640 tokens_helper(visitor:v, &mut _binding_0.span);
2641 }
2642 MacroDelimiter::Brace(_binding_0: &mut Brace) => {
2643 tokens_helper(visitor:v, &mut _binding_0.span);
2644 }
2645 MacroDelimiter::Bracket(_binding_0: &mut Bracket) => {
2646 tokens_helper(visitor:v, &mut _binding_0.span);
2647 }
2648 }
2649}
2650#[cfg(any(feature = "derive", feature = "full"))]
2651pub fn visit_member_mut<V>(v: &mut V, node: &mut Member)
2652where
2653 V: VisitMut + ?Sized,
2654{
2655 match node {
2656 Member::Named(_binding_0: &mut Ident) => {
2657 v.visit_ident_mut(_binding_0);
2658 }
2659 Member::Unnamed(_binding_0: &mut Index) => {
2660 v.visit_index_mut(_binding_0);
2661 }
2662 }
2663}
2664#[cfg(any(feature = "derive", feature = "full"))]
2665pub fn visit_meta_mut<V>(v: &mut V, node: &mut Meta)
2666where
2667 V: VisitMut + ?Sized,
2668{
2669 match node {
2670 Meta::Path(_binding_0: &mut Path) => {
2671 v.visit_path_mut(_binding_0);
2672 }
2673 Meta::List(_binding_0: &mut MetaList) => {
2674 v.visit_meta_list_mut(_binding_0);
2675 }
2676 Meta::NameValue(_binding_0: &mut MetaNameValue) => {
2677 v.visit_meta_name_value_mut(_binding_0);
2678 }
2679 }
2680}
2681#[cfg(any(feature = "derive", feature = "full"))]
2682pub fn visit_meta_list_mut<V>(v: &mut V, node: &mut MetaList)
2683where
2684 V: VisitMut + ?Sized,
2685{
2686 v.visit_path_mut(&mut node.path);
2687 tokens_helper(visitor:v, &mut node.paren_token.span);
2688 for el: Pair<&mut NestedMeta, &mut …> in Punctuated::pairs_mut(&mut node.nested) {
2689 let (it: &mut NestedMeta, p: Option<&mut Comma>) = el.into_tuple();
2690 v.visit_nested_meta_mut(it);
2691 if let Some(p: &mut Comma) = p {
2692 tokens_helper(visitor:v, &mut p.spans);
2693 }
2694 }
2695}
2696#[cfg(any(feature = "derive", feature = "full"))]
2697pub fn visit_meta_name_value_mut<V>(v: &mut V, node: &mut MetaNameValue)
2698where
2699 V: VisitMut + ?Sized,
2700{
2701 v.visit_path_mut(&mut node.path);
2702 tokens_helper(visitor:v, &mut node.eq_token.spans);
2703 v.visit_lit_mut(&mut node.lit);
2704}
2705#[cfg(feature = "full")]
2706pub fn visit_method_turbofish_mut<V>(v: &mut V, node: &mut MethodTurbofish)
2707where
2708 V: VisitMut + ?Sized,
2709{
2710 tokens_helper(visitor:v, &mut node.colon2_token.spans);
2711 tokens_helper(visitor:v, &mut node.lt_token.spans);
2712 for el: Pair<&mut GenericMethodArgument, …> in Punctuated::pairs_mut(&mut node.args) {
2713 let (it: &mut GenericMethodArgument, p: Option<&mut Comma>) = el.into_tuple();
2714 v.visit_generic_method_argument_mut(it);
2715 if let Some(p: &mut Comma) = p {
2716 tokens_helper(visitor:v, &mut p.spans);
2717 }
2718 }
2719 tokens_helper(visitor:v, &mut node.gt_token.spans);
2720}
2721#[cfg(any(feature = "derive", feature = "full"))]
2722pub fn visit_nested_meta_mut<V>(v: &mut V, node: &mut NestedMeta)
2723where
2724 V: VisitMut + ?Sized,
2725{
2726 match node {
2727 NestedMeta::Meta(_binding_0: &mut Meta) => {
2728 v.visit_meta_mut(_binding_0);
2729 }
2730 NestedMeta::Lit(_binding_0: &mut Lit) => {
2731 v.visit_lit_mut(_binding_0);
2732 }
2733 }
2734}
2735#[cfg(any(feature = "derive", feature = "full"))]
2736pub fn visit_parenthesized_generic_arguments_mut<V>(
2737 v: &mut V,
2738 node: &mut ParenthesizedGenericArguments,
2739)
2740where
2741 V: VisitMut + ?Sized,
2742{
2743 tokens_helper(visitor:v, &mut node.paren_token.span);
2744 for el: Pair<&mut Type, &mut Comma> in Punctuated::pairs_mut(&mut node.inputs) {
2745 let (it: &mut Type, p: Option<&mut Comma>) = el.into_tuple();
2746 v.visit_type_mut(it);
2747 if let Some(p: &mut Comma) = p {
2748 tokens_helper(visitor:v, &mut p.spans);
2749 }
2750 }
2751 v.visit_return_type_mut(&mut node.output);
2752}
2753#[cfg(feature = "full")]
2754pub fn visit_pat_mut<V>(v: &mut V, node: &mut Pat)
2755where
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")]
2812pub fn visit_pat_box_mut<V>(v: &mut V, node: &mut PatBox)
2813where
2814 V: VisitMut + ?Sized,
2815{
2816 for it: &mut Attribute in &mut node.attrs {
2817 v.visit_attribute_mut(it);
2818 }
2819 tokens_helper(visitor:v, &mut node.box_token.span);
2820 v.visit_pat_mut(&mut *node.pat);
2821}
2822#[cfg(feature = "full")]
2823pub fn visit_pat_ident_mut<V>(v: &mut V, node: &mut PatIdent)
2824where
2825 V: VisitMut + ?Sized,
2826{
2827 for it: &mut Attribute in &mut node.attrs {
2828 v.visit_attribute_mut(it);
2829 }
2830 if let Some(it: &mut Ref) = &mut node.by_ref {
2831 tokens_helper(visitor:v, &mut it.span);
2832 }
2833 if let Some(it: &mut Mut) = &mut node.mutability {
2834 tokens_helper(visitor:v, &mut it.span);
2835 }
2836 v.visit_ident_mut(&mut node.ident);
2837 if let Some(it: &mut (At, Box)) = &mut node.subpat {
2838 tokens_helper(visitor:v, &mut (it).0.spans);
2839 v.visit_pat_mut(&mut *(it).1);
2840 }
2841}
2842#[cfg(feature = "full")]
2843pub fn visit_pat_lit_mut<V>(v: &mut V, node: &mut PatLit)
2844where
2845 V: VisitMut + ?Sized,
2846{
2847 for it: &mut Attribute in &mut node.attrs {
2848 v.visit_attribute_mut(it);
2849 }
2850 v.visit_expr_mut(&mut *node.expr);
2851}
2852#[cfg(feature = "full")]
2853pub fn visit_pat_macro_mut<V>(v: &mut V, node: &mut PatMacro)
2854where
2855 V: VisitMut + ?Sized,
2856{
2857 for it: &mut Attribute in &mut node.attrs {
2858 v.visit_attribute_mut(it);
2859 }
2860 v.visit_macro_mut(&mut node.mac);
2861}
2862#[cfg(feature = "full")]
2863pub fn visit_pat_or_mut<V>(v: &mut V, node: &mut PatOr)
2864where
2865 V: VisitMut + ?Sized,
2866{
2867 for it: &mut Attribute in &mut node.attrs {
2868 v.visit_attribute_mut(it);
2869 }
2870 if let Some(it: &mut Or) = &mut node.leading_vert {
2871 tokens_helper(visitor:v, &mut it.spans);
2872 }
2873 for el: Pair<&mut Pat, &mut Or> in Punctuated::pairs_mut(&mut node.cases) {
2874 let (it: &mut Pat, p: Option<&mut Or>) = el.into_tuple();
2875 v.visit_pat_mut(it);
2876 if let Some(p: &mut Or) = p {
2877 tokens_helper(visitor:v, &mut p.spans);
2878 }
2879 }
2880}
2881#[cfg(feature = "full")]
2882pub fn visit_pat_path_mut<V>(v: &mut V, node: &mut PatPath)
2883where
2884 V: VisitMut + ?Sized,
2885{
2886 for it: &mut Attribute in &mut node.attrs {
2887 v.visit_attribute_mut(it);
2888 }
2889 if let Some(it: &mut QSelf) = &mut node.qself {
2890 v.visit_qself_mut(it);
2891 }
2892 v.visit_path_mut(&mut node.path);
2893}
2894#[cfg(feature = "full")]
2895pub fn visit_pat_range_mut<V>(v: &mut V, node: &mut PatRange)
2896where
2897 V: VisitMut + ?Sized,
2898{
2899 for it: &mut Attribute 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")]
2907pub fn visit_pat_reference_mut<V>(v: &mut V, node: &mut PatReference)
2908where
2909 V: VisitMut + ?Sized,
2910{
2911 for it: &mut Attribute in &mut node.attrs {
2912 v.visit_attribute_mut(it);
2913 }
2914 tokens_helper(visitor:v, &mut node.and_token.spans);
2915 if let Some(it: &mut Mut) = &mut node.mutability {
2916 tokens_helper(visitor:v, &mut it.span);
2917 }
2918 v.visit_pat_mut(&mut *node.pat);
2919}
2920#[cfg(feature = "full")]
2921pub fn visit_pat_rest_mut<V>(v: &mut V, node: &mut PatRest)
2922where
2923 V: VisitMut + ?Sized,
2924{
2925 for it: &mut Attribute in &mut node.attrs {
2926 v.visit_attribute_mut(it);
2927 }
2928 tokens_helper(visitor:v, &mut node.dot2_token.spans);
2929}
2930#[cfg(feature = "full")]
2931pub fn visit_pat_slice_mut<V>(v: &mut V, node: &mut PatSlice)
2932where
2933 V: VisitMut + ?Sized,
2934{
2935 for it: &mut Attribute in &mut node.attrs {
2936 v.visit_attribute_mut(it);
2937 }
2938 tokens_helper(visitor:v, &mut node.bracket_token.span);
2939 for el: Pair<&mut Pat, &mut Comma> in Punctuated::pairs_mut(&mut node.elems) {
2940 let (it: &mut Pat, p: Option<&mut Comma>) = el.into_tuple();
2941 v.visit_pat_mut(it);
2942 if let Some(p: &mut Comma) = p {
2943 tokens_helper(visitor:v, &mut p.spans);
2944 }
2945 }
2946}
2947#[cfg(feature = "full")]
2948pub fn visit_pat_struct_mut<V>(v: &mut V, node: &mut PatStruct)
2949where
2950 V: VisitMut + ?Sized,
2951{
2952 for it: &mut Attribute in &mut node.attrs {
2953 v.visit_attribute_mut(it);
2954 }
2955 v.visit_path_mut(&mut node.path);
2956 tokens_helper(visitor:v, &mut node.brace_token.span);
2957 for el: Pair<&mut FieldPat, &mut …> in Punctuated::pairs_mut(&mut node.fields) {
2958 let (it: &mut FieldPat, p: Option<&mut Comma>) = el.into_tuple();
2959 v.visit_field_pat_mut(it);
2960 if let Some(p: &mut Comma) = p {
2961 tokens_helper(visitor:v, &mut p.spans);
2962 }
2963 }
2964 if let Some(it: &mut Dot2) = &mut node.dot2_token {
2965 tokens_helper(visitor:v, &mut it.spans);
2966 }
2967}
2968#[cfg(feature = "full")]
2969pub fn visit_pat_tuple_mut<V>(v: &mut V, node: &mut PatTuple)
2970where
2971 V: VisitMut + ?Sized,
2972{
2973 for it: &mut Attribute in &mut node.attrs {
2974 v.visit_attribute_mut(it);
2975 }
2976 tokens_helper(visitor:v, &mut node.paren_token.span);
2977 for el: Pair<&mut Pat, &mut Comma> in Punctuated::pairs_mut(&mut node.elems) {
2978 let (it: &mut Pat, p: Option<&mut Comma>) = el.into_tuple();
2979 v.visit_pat_mut(it);
2980 if let Some(p: &mut Comma) = p {
2981 tokens_helper(visitor:v, &mut p.spans);
2982 }
2983 }
2984}
2985#[cfg(feature = "full")]
2986pub fn visit_pat_tuple_struct_mut<V>(v: &mut V, node: &mut PatTupleStruct)
2987where
2988 V: VisitMut + ?Sized,
2989{
2990 for it: &mut Attribute 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")]
2997pub fn visit_pat_type_mut<V>(v: &mut V, node: &mut PatType)
2998where
2999 V: VisitMut + ?Sized,
3000{
3001 for it: &mut Attribute in &mut node.attrs {
3002 v.visit_attribute_mut(it);
3003 }
3004 v.visit_pat_mut(&mut *node.pat);
3005 tokens_helper(visitor:v, &mut node.colon_token.spans);
3006 v.visit_type_mut(&mut *node.ty);
3007}
3008#[cfg(feature = "full")]
3009pub fn visit_pat_wild_mut<V>(v: &mut V, node: &mut PatWild)
3010where
3011 V: VisitMut + ?Sized,
3012{
3013 for it: &mut Attribute in &mut node.attrs {
3014 v.visit_attribute_mut(it);
3015 }
3016 tokens_helper(visitor:v, &mut node.underscore_token.spans);
3017}
3018#[cfg(any(feature = "derive", feature = "full"))]
3019pub fn visit_path_mut<V>(v: &mut V, node: &mut Path)
3020where
3021 V: VisitMut + ?Sized,
3022{
3023 if let Some(it: &mut Colon2) = &mut node.leading_colon {
3024 tokens_helper(visitor:v, &mut it.spans);
3025 }
3026 for el: Pair<&mut PathSegment, &mut …> in Punctuated::pairs_mut(&mut node.segments) {
3027 let (it: &mut PathSegment, p: Option<&mut Colon2>) = el.into_tuple();
3028 v.visit_path_segment_mut(it);
3029 if let Some(p: &mut Colon2) = p {
3030 tokens_helper(visitor:v, &mut p.spans);
3031 }
3032 }
3033}
3034#[cfg(any(feature = "derive", feature = "full"))]
3035pub fn visit_path_arguments_mut<V>(v: &mut V, node: &mut PathArguments)
3036where
3037 V: VisitMut + ?Sized,
3038{
3039 match node {
3040 PathArguments::None => {}
3041 PathArguments::AngleBracketed(_binding_0: &mut AngleBracketedGenericArguments) => {
3042 v.visit_angle_bracketed_generic_arguments_mut(_binding_0);
3043 }
3044 PathArguments::Parenthesized(_binding_0: &mut ParenthesizedGenericArguments) => {
3045 v.visit_parenthesized_generic_arguments_mut(_binding_0);
3046 }
3047 }
3048}
3049#[cfg(any(feature = "derive", feature = "full"))]
3050pub fn visit_path_segment_mut<V>(v: &mut V, node: &mut PathSegment)
3051where
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"))]
3058pub fn visit_predicate_eq_mut<V>(v: &mut V, node: &mut PredicateEq)
3059where
3060 V: VisitMut + ?Sized,
3061{
3062 v.visit_type_mut(&mut node.lhs_ty);
3063 tokens_helper(visitor:v, &mut node.eq_token.spans);
3064 v.visit_type_mut(&mut node.rhs_ty);
3065}
3066#[cfg(any(feature = "derive", feature = "full"))]
3067pub fn visit_predicate_lifetime_mut<V>(v: &mut V, node: &mut PredicateLifetime)
3068where
3069 V: VisitMut + ?Sized,
3070{
3071 v.visit_lifetime_mut(&mut node.lifetime);
3072 tokens_helper(visitor:v, &mut node.colon_token.spans);
3073 for el: Pair<&mut Lifetime, &mut …> in Punctuated::pairs_mut(&mut node.bounds) {
3074 let (it: &mut Lifetime, p: Option<&mut Add>) = el.into_tuple();
3075 v.visit_lifetime_mut(it);
3076 if let Some(p: &mut Add) = p {
3077 tokens_helper(visitor:v, &mut p.spans);
3078 }
3079 }
3080}
3081#[cfg(any(feature = "derive", feature = "full"))]
3082pub fn visit_predicate_type_mut<V>(v: &mut V, node: &mut PredicateType)
3083where
3084 V: VisitMut + ?Sized,
3085{
3086 if let Some(it: &mut BoundLifetimes) = &mut node.lifetimes {
3087 v.visit_bound_lifetimes_mut(it);
3088 }
3089 v.visit_type_mut(&mut node.bounded_ty);
3090 tokens_helper(visitor:v, &mut node.colon_token.spans);
3091 for el: Pair<&mut TypeParamBound, …> in Punctuated::pairs_mut(&mut node.bounds) {
3092 let (it: &mut TypeParamBound, p: Option<&mut Add>) = el.into_tuple();
3093 v.visit_type_param_bound_mut(it);
3094 if let Some(p: &mut Add) = p {
3095 tokens_helper(visitor:v, &mut p.spans);
3096 }
3097 }
3098}
3099#[cfg(any(feature = "derive", feature = "full"))]
3100pub fn visit_qself_mut<V>(v: &mut V, node: &mut QSelf)
3101where
3102 V: VisitMut + ?Sized,
3103{
3104 tokens_helper(visitor:v, &mut node.lt_token.spans);
3105 v.visit_type_mut(&mut *node.ty);
3106 skip!(node.position);
3107 if let Some(it: &mut As) = &mut node.as_token {
3108 tokens_helper(visitor:v, &mut it.span);
3109 }
3110 tokens_helper(visitor:v, &mut node.gt_token.spans);
3111}
3112#[cfg(feature = "full")]
3113pub fn visit_range_limits_mut<V>(v: &mut V, node: &mut RangeLimits)
3114where
3115 V: VisitMut + ?Sized,
3116{
3117 match node {
3118 RangeLimits::HalfOpen(_binding_0: &mut Dot2) => {
3119 tokens_helper(visitor:v, &mut _binding_0.spans);
3120 }
3121 RangeLimits::Closed(_binding_0: &mut DotDotEq) => {
3122 tokens_helper(visitor:v, &mut _binding_0.spans);
3123 }
3124 }
3125}
3126#[cfg(feature = "full")]
3127pub fn visit_receiver_mut<V>(v: &mut V, node: &mut Receiver)
3128where
3129 V: VisitMut + ?Sized,
3130{
3131 for it: &mut Attribute in &mut node.attrs {
3132 v.visit_attribute_mut(it);
3133 }
3134 if let Some(it: &mut (And, Option)) = &mut node.reference {
3135 tokens_helper(visitor:v, &mut (it).0.spans);
3136 if let Some(it: &mut Lifetime) = &mut (it).1 {
3137 v.visit_lifetime_mut(it);
3138 }
3139 }
3140 if let Some(it: &mut Mut) = &mut node.mutability {
3141 tokens_helper(visitor:v, &mut it.span);
3142 }
3143 tokens_helper(visitor:v, &mut node.self_token.span);
3144}
3145#[cfg(any(feature = "derive", feature = "full"))]
3146pub fn visit_return_type_mut<V>(v: &mut V, node: &mut ReturnType)
3147where
3148 V: VisitMut + ?Sized,
3149{
3150 match node {
3151 ReturnType::Default => {}
3152 ReturnType::Type(_binding_0: &mut RArrow, _binding_1: &mut Box) => {
3153 tokens_helper(visitor:v, &mut _binding_0.spans);
3154 v.visit_type_mut(&mut **_binding_1);
3155 }
3156 }
3157}
3158#[cfg(feature = "full")]
3159pub fn visit_signature_mut<V>(v: &mut V, node: &mut Signature)
3160where
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}
3191pub fn visit_span_mut<V>(v: &mut V, node: &mut Span)
3192where
3193 V: VisitMut + ?Sized,
3194{}
3195#[cfg(feature = "full")]
3196pub fn visit_stmt_mut<V>(v: &mut V, node: &mut Stmt)
3197where
3198 V: VisitMut + ?Sized,
3199{
3200 match node {
3201 Stmt::Local(_binding_0: &mut Local) => {
3202 v.visit_local_mut(_binding_0);
3203 }
3204 Stmt::Item(_binding_0: &mut Item) => {
3205 v.visit_item_mut(_binding_0);
3206 }
3207 Stmt::Expr(_binding_0: &mut Expr) => {
3208 v.visit_expr_mut(_binding_0);
3209 }
3210 Stmt::Semi(_binding_0: &mut Expr, _binding_1: &mut Semi) => {
3211 v.visit_expr_mut(_binding_0);
3212 tokens_helper(visitor:v, &mut _binding_1.spans);
3213 }
3214 }
3215}
3216#[cfg(any(feature = "derive", feature = "full"))]
3217pub fn visit_trait_bound_mut<V>(v: &mut V, node: &mut TraitBound)
3218where
3219 V: VisitMut + ?Sized,
3220{
3221 if let Some(it: &mut Paren) = &mut node.paren_token {
3222 tokens_helper(visitor:v, &mut it.span);
3223 }
3224 v.visit_trait_bound_modifier_mut(&mut node.modifier);
3225 if let Some(it: &mut BoundLifetimes) = &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"))]
3231pub fn visit_trait_bound_modifier_mut<V>(v: &mut V, node: &mut TraitBoundModifier)
3232where
3233 V: VisitMut + ?Sized,
3234{
3235 match node {
3236 TraitBoundModifier::None => {}
3237 TraitBoundModifier::Maybe(_binding_0: &mut Question) => {
3238 tokens_helper(visitor:v, &mut _binding_0.spans);
3239 }
3240 }
3241}
3242#[cfg(feature = "full")]
3243pub fn visit_trait_item_mut<V>(v: &mut V, node: &mut TraitItem)
3244where
3245 V: VisitMut + ?Sized,
3246{
3247 match node {
3248 TraitItem::Const(_binding_0: &mut TraitItemConst) => {
3249 v.visit_trait_item_const_mut(_binding_0);
3250 }
3251 TraitItem::Method(_binding_0: &mut TraitItemMethod) => {
3252 v.visit_trait_item_method_mut(_binding_0);
3253 }
3254 TraitItem::Type(_binding_0: &mut TraitItemType) => {
3255 v.visit_trait_item_type_mut(_binding_0);
3256 }
3257 TraitItem::Macro(_binding_0: &mut TraitItemMacro) => {
3258 v.visit_trait_item_macro_mut(_binding_0);
3259 }
3260 TraitItem::Verbatim(_binding_0: &mut TokenStream) => {
3261 skip!(_binding_0);
3262 }
3263 #[cfg(syn_no_non_exhaustive)]
3264 _ => unreachable!(),
3265 }
3266}
3267#[cfg(feature = "full")]
3268pub fn visit_trait_item_const_mut<V>(v: &mut V, node: &mut TraitItemConst)
3269where
3270 V: VisitMut + ?Sized,
3271{
3272 for it: &mut Attribute in &mut node.attrs {
3273 v.visit_attribute_mut(it);
3274 }
3275 tokens_helper(visitor:v, &mut node.const_token.span);
3276 v.visit_ident_mut(&mut node.ident);
3277 tokens_helper(visitor:v, &mut node.colon_token.spans);
3278 v.visit_type_mut(&mut node.ty);
3279 if let Some(it: &mut (Eq, Expr)) = &mut node.default {
3280 tokens_helper(visitor:v, &mut (it).0.spans);
3281 v.visit_expr_mut(&mut (it).1);
3282 }
3283 tokens_helper(visitor:v, &mut node.semi_token.spans);
3284}
3285#[cfg(feature = "full")]
3286pub fn visit_trait_item_macro_mut<V>(v: &mut V, node: &mut TraitItemMacro)
3287where
3288 V: VisitMut + ?Sized,
3289{
3290 for it: &mut Attribute 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 Semi) = &mut node.semi_token {
3295 tokens_helper(visitor:v, &mut it.spans);
3296 }
3297}
3298#[cfg(feature = "full")]
3299pub fn visit_trait_item_method_mut<V>(v: &mut V, node: &mut TraitItemMethod)
3300where
3301 V: VisitMut + ?Sized,
3302{
3303 for it: &mut Attribute 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 Block) = &mut node.default {
3308 v.visit_block_mut(it);
3309 }
3310 if let Some(it: &mut Semi) = &mut node.semi_token {
3311 tokens_helper(visitor:v, &mut it.spans);
3312 }
3313}
3314#[cfg(feature = "full")]
3315pub fn visit_trait_item_type_mut<V>(v: &mut V, node: &mut TraitItemType)
3316where
3317 V: VisitMut + ?Sized,
3318{
3319 for it: &mut Attribute in &mut node.attrs {
3320 v.visit_attribute_mut(it);
3321 }
3322 tokens_helper(visitor: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 Colon) = &mut node.colon_token {
3326 tokens_helper(visitor:v, &mut it.spans);
3327 }
3328 for el: Pair<&mut TypeParamBound, …> in Punctuated::pairs_mut(&mut node.bounds) {
3329 let (it: &mut TypeParamBound, p: Option<&mut Add>) = el.into_tuple();
3330 v.visit_type_param_bound_mut(it);
3331 if let Some(p: &mut Add) = p {
3332 tokens_helper(visitor:v, &mut p.spans);
3333 }
3334 }
3335 if let Some(it: &mut (Eq, Type)) = &mut node.default {
3336 tokens_helper(visitor:v, &mut (it).0.spans);
3337 v.visit_type_mut(&mut (it).1);
3338 }
3339 tokens_helper(visitor:v, &mut node.semi_token.spans);
3340}
3341#[cfg(any(feature = "derive", feature = "full"))]
3342pub fn visit_type_mut<V>(v: &mut V, node: &mut Type)
3343where
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"))]
3397pub fn visit_type_array_mut<V>(v: &mut V, node: &mut TypeArray)
3398where
3399 V: VisitMut + ?Sized,
3400{
3401 tokens_helper(visitor:v, &mut node.bracket_token.span);
3402 v.visit_type_mut(&mut *node.elem);
3403 tokens_helper(visitor:v, &mut node.semi_token.spans);
3404 v.visit_expr_mut(&mut node.len);
3405}
3406#[cfg(any(feature = "derive", feature = "full"))]
3407pub fn visit_type_bare_fn_mut<V>(v: &mut V, node: &mut TypeBareFn)
3408where
3409 V: VisitMut + ?Sized,
3410{
3411 if let Some(it: &mut BoundLifetimes) = &mut node.lifetimes {
3412 v.visit_bound_lifetimes_mut(it);
3413 }
3414 if let Some(it: &mut Unsafe) = &mut node.unsafety {
3415 tokens_helper(visitor:v, &mut it.span);
3416 }
3417 if let Some(it: &mut Abi) = &mut node.abi {
3418 v.visit_abi_mut(it);
3419 }
3420 tokens_helper(visitor:v, &mut node.fn_token.span);
3421 tokens_helper(visitor:v, &mut node.paren_token.span);
3422 for el: Pair<&mut BareFnArg, &mut …> in Punctuated::pairs_mut(&mut node.inputs) {
3423 let (it: &mut BareFnArg, p: Option<&mut Comma>) = el.into_tuple();
3424 v.visit_bare_fn_arg_mut(it);
3425 if let Some(p: &mut Comma) = p {
3426 tokens_helper(visitor:v, &mut p.spans);
3427 }
3428 }
3429 if let Some(it: &mut Variadic) = &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"))]
3435pub fn visit_type_group_mut<V>(v: &mut V, node: &mut TypeGroup)
3436where
3437 V: VisitMut + ?Sized,
3438{
3439 tokens_helper(visitor:v, &mut node.group_token.span);
3440 v.visit_type_mut(&mut *node.elem);
3441}
3442#[cfg(any(feature = "derive", feature = "full"))]
3443pub fn visit_type_impl_trait_mut<V>(v: &mut V, node: &mut TypeImplTrait)
3444where
3445 V: VisitMut + ?Sized,
3446{
3447 tokens_helper(visitor:v, &mut node.impl_token.span);
3448 for el: Pair<&mut TypeParamBound, …> in Punctuated::pairs_mut(&mut node.bounds) {
3449 let (it: &mut TypeParamBound, p: Option<&mut Add>) = el.into_tuple();
3450 v.visit_type_param_bound_mut(it);
3451 if let Some(p: &mut Add) = p {
3452 tokens_helper(visitor:v, &mut p.spans);
3453 }
3454 }
3455}
3456#[cfg(any(feature = "derive", feature = "full"))]
3457pub fn visit_type_infer_mut<V>(v: &mut V, node: &mut TypeInfer)
3458where
3459 V: VisitMut + ?Sized,
3460{
3461 tokens_helper(visitor:v, &mut node.underscore_token.spans);
3462}
3463#[cfg(any(feature = "derive", feature = "full"))]
3464pub fn visit_type_macro_mut<V>(v: &mut V, node: &mut TypeMacro)
3465where
3466 V: VisitMut + ?Sized,
3467{
3468 v.visit_macro_mut(&mut node.mac);
3469}
3470#[cfg(any(feature = "derive", feature = "full"))]
3471pub fn visit_type_never_mut<V>(v: &mut V, node: &mut TypeNever)
3472where
3473 V: VisitMut + ?Sized,
3474{
3475 tokens_helper(visitor:v, &mut node.bang_token.spans);
3476}
3477#[cfg(any(feature = "derive", feature = "full"))]
3478pub fn visit_type_param_mut<V>(v: &mut V, node: &mut TypeParam)
3479where
3480 V: VisitMut + ?Sized,
3481{
3482 for it: &mut Attribute 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 Colon) = &mut node.colon_token {
3487 tokens_helper(visitor:v, &mut it.spans);
3488 }
3489 for el: Pair<&mut TypeParamBound, …> in Punctuated::pairs_mut(&mut node.bounds) {
3490 let (it: &mut TypeParamBound, p: Option<&mut Add>) = el.into_tuple();
3491 v.visit_type_param_bound_mut(it);
3492 if let Some(p: &mut Add) = p {
3493 tokens_helper(visitor:v, &mut p.spans);
3494 }
3495 }
3496 if let Some(it: &mut Eq) = &mut node.eq_token {
3497 tokens_helper(visitor:v, &mut it.spans);
3498 }
3499 if let Some(it: &mut Type) = &mut node.default {
3500 v.visit_type_mut(it);
3501 }
3502}
3503#[cfg(any(feature = "derive", feature = "full"))]
3504pub fn visit_type_param_bound_mut<V>(v: &mut V, node: &mut TypeParamBound)
3505where
3506 V: VisitMut + ?Sized,
3507{
3508 match node {
3509 TypeParamBound::Trait(_binding_0: &mut TraitBound) => {
3510 v.visit_trait_bound_mut(_binding_0);
3511 }
3512 TypeParamBound::Lifetime(_binding_0: &mut Lifetime) => {
3513 v.visit_lifetime_mut(_binding_0);
3514 }
3515 }
3516}
3517#[cfg(any(feature = "derive", feature = "full"))]
3518pub fn visit_type_paren_mut<V>(v: &mut V, node: &mut TypeParen)
3519where
3520 V: VisitMut + ?Sized,
3521{
3522 tokens_helper(visitor:v, &mut node.paren_token.span);
3523 v.visit_type_mut(&mut *node.elem);
3524}
3525#[cfg(any(feature = "derive", feature = "full"))]
3526pub fn visit_type_path_mut<V>(v: &mut V, node: &mut TypePath)
3527where
3528 V: VisitMut + ?Sized,
3529{
3530 if let Some(it: &mut QSelf) = &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"))]
3536pub fn visit_type_ptr_mut<V>(v: &mut V, node: &mut TypePtr)
3537where
3538 V: VisitMut + ?Sized,
3539{
3540 tokens_helper(visitor:v, &mut node.star_token.spans);
3541 if let Some(it: &mut Const) = &mut node.const_token {
3542 tokens_helper(visitor:v, &mut it.span);
3543 }
3544 if let Some(it: &mut Mut) = &mut node.mutability {
3545 tokens_helper(visitor:v, &mut it.span);
3546 }
3547 v.visit_type_mut(&mut *node.elem);
3548}
3549#[cfg(any(feature = "derive", feature = "full"))]
3550pub fn visit_type_reference_mut<V>(v: &mut V, node: &mut TypeReference)
3551where
3552 V: VisitMut + ?Sized,
3553{
3554 tokens_helper(visitor:v, &mut node.and_token.spans);
3555 if let Some(it: &mut Lifetime) = &mut node.lifetime {
3556 v.visit_lifetime_mut(it);
3557 }
3558 if let Some(it: &mut Mut) = &mut node.mutability {
3559 tokens_helper(visitor:v, &mut it.span);
3560 }
3561 v.visit_type_mut(&mut *node.elem);
3562}
3563#[cfg(any(feature = "derive", feature = "full"))]
3564pub fn visit_type_slice_mut<V>(v: &mut V, node: &mut TypeSlice)
3565where
3566 V: VisitMut + ?Sized,
3567{
3568 tokens_helper(visitor:v, &mut node.bracket_token.span);
3569 v.visit_type_mut(&mut *node.elem);
3570}
3571#[cfg(any(feature = "derive", feature = "full"))]
3572pub fn visit_type_trait_object_mut<V>(v: &mut V, node: &mut TypeTraitObject)
3573where
3574 V: VisitMut + ?Sized,
3575{
3576 if let Some(it: &mut Dyn) = &mut node.dyn_token {
3577 tokens_helper(visitor:v, &mut it.span);
3578 }
3579 for el: Pair<&mut TypeParamBound, …> in Punctuated::pairs_mut(&mut node.bounds) {
3580 let (it: &mut TypeParamBound, p: Option<&mut Add>) = el.into_tuple();
3581 v.visit_type_param_bound_mut(it);
3582 if let Some(p: &mut Add) = p {
3583 tokens_helper(visitor:v, &mut p.spans);
3584 }
3585 }
3586}
3587#[cfg(any(feature = "derive", feature = "full"))]
3588pub fn visit_type_tuple_mut<V>(v: &mut V, node: &mut TypeTuple)
3589where
3590 V: VisitMut + ?Sized,
3591{
3592 tokens_helper(visitor:v, &mut node.paren_token.span);
3593 for el: Pair<&mut Type, &mut Comma> in Punctuated::pairs_mut(&mut node.elems) {
3594 let (it: &mut Type, p: Option<&mut Comma>) = el.into_tuple();
3595 v.visit_type_mut(it);
3596 if let Some(p: &mut Comma) = p {
3597 tokens_helper(visitor:v, &mut p.spans);
3598 }
3599 }
3600}
3601#[cfg(any(feature = "derive", feature = "full"))]
3602pub fn visit_un_op_mut<V>(v: &mut V, node: &mut UnOp)
3603where
3604 V: VisitMut + ?Sized,
3605{
3606 match node {
3607 UnOp::Deref(_binding_0: &mut Star) => {
3608 tokens_helper(visitor:v, &mut _binding_0.spans);
3609 }
3610 UnOp::Not(_binding_0: &mut Bang) => {
3611 tokens_helper(visitor:v, &mut _binding_0.spans);
3612 }
3613 UnOp::Neg(_binding_0: &mut Sub) => {
3614 tokens_helper(visitor:v, &mut _binding_0.spans);
3615 }
3616 }
3617}
3618#[cfg(feature = "full")]
3619pub fn visit_use_glob_mut<V>(v: &mut V, node: &mut UseGlob)
3620where
3621 V: VisitMut + ?Sized,
3622{
3623 tokens_helper(visitor:v, &mut node.star_token.spans);
3624}
3625#[cfg(feature = "full")]
3626pub fn visit_use_group_mut<V>(v: &mut V, node: &mut UseGroup)
3627where
3628 V: VisitMut + ?Sized,
3629{
3630 tokens_helper(visitor:v, &mut node.brace_token.span);
3631 for el: Pair<&mut UseTree, &mut Comma> in Punctuated::pairs_mut(&mut node.items) {
3632 let (it: &mut UseTree, p: Option<&mut Comma>) = el.into_tuple();
3633 v.visit_use_tree_mut(it);
3634 if let Some(p: &mut Comma) = p {
3635 tokens_helper(visitor:v, &mut p.spans);
3636 }
3637 }
3638}
3639#[cfg(feature = "full")]
3640pub fn visit_use_name_mut<V>(v: &mut V, node: &mut UseName)
3641where
3642 V: VisitMut + ?Sized,
3643{
3644 v.visit_ident_mut(&mut node.ident);
3645}
3646#[cfg(feature = "full")]
3647pub fn visit_use_path_mut<V>(v: &mut V, node: &mut UsePath)
3648where
3649 V: VisitMut + ?Sized,
3650{
3651 v.visit_ident_mut(&mut node.ident);
3652 tokens_helper(visitor:v, &mut node.colon2_token.spans);
3653 v.visit_use_tree_mut(&mut *node.tree);
3654}
3655#[cfg(feature = "full")]
3656pub fn visit_use_rename_mut<V>(v: &mut V, node: &mut UseRename)
3657where
3658 V: VisitMut + ?Sized,
3659{
3660 v.visit_ident_mut(&mut node.ident);
3661 tokens_helper(visitor:v, &mut node.as_token.span);
3662 v.visit_ident_mut(&mut node.rename);
3663}
3664#[cfg(feature = "full")]
3665pub fn visit_use_tree_mut<V>(v: &mut V, node: &mut UseTree)
3666where
3667 V: VisitMut + ?Sized,
3668{
3669 match node {
3670 UseTree::Path(_binding_0: &mut UsePath) => {
3671 v.visit_use_path_mut(_binding_0);
3672 }
3673 UseTree::Name(_binding_0: &mut UseName) => {
3674 v.visit_use_name_mut(_binding_0);
3675 }
3676 UseTree::Rename(_binding_0: &mut UseRename) => {
3677 v.visit_use_rename_mut(_binding_0);
3678 }
3679 UseTree::Glob(_binding_0: &mut UseGlob) => {
3680 v.visit_use_glob_mut(_binding_0);
3681 }
3682 UseTree::Group(_binding_0: &mut UseGroup) => {
3683 v.visit_use_group_mut(_binding_0);
3684 }
3685 }
3686}
3687#[cfg(any(feature = "derive", feature = "full"))]
3688pub fn visit_variadic_mut<V>(v: &mut V, node: &mut Variadic)
3689where
3690 V: VisitMut + ?Sized,
3691{
3692 for it: &mut Attribute in &mut node.attrs {
3693 v.visit_attribute_mut(it);
3694 }
3695 tokens_helper(visitor:v, &mut node.dots.spans);
3696}
3697#[cfg(any(feature = "derive", feature = "full"))]
3698pub fn visit_variant_mut<V>(v: &mut V, node: &mut Variant)
3699where
3700 V: VisitMut + ?Sized,
3701{
3702 for it: &mut Attribute 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 (Eq, Expr)) = &mut node.discriminant {
3708 tokens_helper(visitor:v, &mut (it).0.spans);
3709 v.visit_expr_mut(&mut (it).1);
3710 }
3711}
3712#[cfg(any(feature = "derive", feature = "full"))]
3713pub fn visit_vis_crate_mut<V>(v: &mut V, node: &mut VisCrate)
3714where
3715 V: VisitMut + ?Sized,
3716{
3717 tokens_helper(visitor:v, &mut node.crate_token.span);
3718}
3719#[cfg(any(feature = "derive", feature = "full"))]
3720pub fn visit_vis_public_mut<V>(v: &mut V, node: &mut VisPublic)
3721where
3722 V: VisitMut + ?Sized,
3723{
3724 tokens_helper(visitor:v, &mut node.pub_token.span);
3725}
3726#[cfg(any(feature = "derive", feature = "full"))]
3727pub fn visit_vis_restricted_mut<V>(v: &mut V, node: &mut VisRestricted)
3728where
3729 V: VisitMut + ?Sized,
3730{
3731 tokens_helper(visitor:v, &mut node.pub_token.span);
3732 tokens_helper(visitor:v, &mut node.paren_token.span);
3733 if let Some(it: &mut In) = &mut node.in_token {
3734 tokens_helper(visitor:v, &mut it.span);
3735 }
3736 v.visit_path_mut(&mut *node.path);
3737}
3738#[cfg(any(feature = "derive", feature = "full"))]
3739pub fn visit_visibility_mut<V>(v: &mut V, node: &mut Visibility)
3740where
3741 V: VisitMut + ?Sized,
3742{
3743 match node {
3744 Visibility::Public(_binding_0: &mut VisPublic) => {
3745 v.visit_vis_public_mut(_binding_0);
3746 }
3747 Visibility::Crate(_binding_0: &mut VisCrate) => {
3748 v.visit_vis_crate_mut(_binding_0);
3749 }
3750 Visibility::Restricted(_binding_0: &mut VisRestricted) => {
3751 v.visit_vis_restricted_mut(_binding_0);
3752 }
3753 Visibility::Inherited => {}
3754 }
3755}
3756#[cfg(any(feature = "derive", feature = "full"))]
3757pub fn visit_where_clause_mut<V>(v: &mut V, node: &mut WhereClause)
3758where
3759 V: VisitMut + ?Sized,
3760{
3761 tokens_helper(visitor:v, &mut node.where_token.span);
3762 for el: Pair<&mut WherePredicate, …> in Punctuated::pairs_mut(&mut node.predicates) {
3763 let (it: &mut WherePredicate, p: Option<&mut Comma>) = el.into_tuple();
3764 v.visit_where_predicate_mut(it);
3765 if let Some(p: &mut Comma) = p {
3766 tokens_helper(visitor:v, &mut p.spans);
3767 }
3768 }
3769}
3770#[cfg(any(feature = "derive", feature = "full"))]
3771pub fn visit_where_predicate_mut<V>(v: &mut V, node: &mut WherePredicate)
3772where
3773 V: VisitMut + ?Sized,
3774{
3775 match node {
3776 WherePredicate::Type(_binding_0: &mut PredicateType) => {
3777 v.visit_predicate_type_mut(_binding_0);
3778 }
3779 WherePredicate::Lifetime(_binding_0: &mut PredicateLifetime) => {
3780 v.visit_predicate_lifetime_mut(_binding_0);
3781 }
3782 WherePredicate::Eq(_binding_0: &mut PredicateEq) => {
3783 v.visit_predicate_eq_mut(_binding_0);
3784 }
3785 }
3786}
3787