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