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