CoCalc -- visit

GitHub Repository: torvalds/linux
Path: blob/master/rust/syn/gen/visit_mut.rs
³⁸³²⁶ views
1
// SPDX-License-Identifier: Apache-2.0 OR MIT
2

3
// This file is @generated by syn-internal-codegen.
4
// It is not intended for manual editing.
5

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

3763
Product

Resources

Company
