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