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