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