Debian Codegraph @

third_party/rust/syn/src/gen/visit_mut.rs

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