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