visit_mut.rs source code [crates/syn-2.0.32/src/gen/visit_mut.rs]

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