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