1 // This file is @generated by syn-internal-codegen.
2 // It is not intended for manual editing.
4 #![allow(unused_variables)]
5 #![allow(clippy::needless_pass_by_ref_mut)]
6 #[cfg(any(feature = "full", feature = "derive"))]
7 use crate::punctuated
::Punctuated
;
10 #[cfg(feature = "full")]
16 #[cfg(all(feature = "derive", not(feature = "full")))]
25 /// Syntax tree traversal to mutate an exclusive borrow of a syntax tree in
28 /// See the [module documentation] for details.
30 /// [module documentation]: self
32 #[cfg(any(feature = "derive", feature = "full"))]
33 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
34 fn visit_abi_mut(&mut self, i
: &mut Abi
) {
35 visit_abi_mut(self, i
);
37 #[cfg(any(feature = "derive", feature = "full"))]
38 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
39 fn visit_angle_bracketed_generic_arguments_mut(
41 i
: &mut AngleBracketedGenericArguments
,
43 visit_angle_bracketed_generic_arguments_mut(self, i
);
45 #[cfg(feature = "full")]
46 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
47 fn visit_arm_mut(&mut self, i
: &mut Arm
) {
48 visit_arm_mut(self, i
);
50 #[cfg(any(feature = "derive", feature = "full"))]
51 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
52 fn visit_assoc_const_mut(&mut self, i
: &mut AssocConst
) {
53 visit_assoc_const_mut(self, i
);
55 #[cfg(any(feature = "derive", feature = "full"))]
56 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
57 fn visit_assoc_type_mut(&mut self, i
: &mut AssocType
) {
58 visit_assoc_type_mut(self, i
);
60 #[cfg(any(feature = "derive", feature = "full"))]
61 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
62 fn visit_attr_style_mut(&mut self, i
: &mut AttrStyle
) {
63 visit_attr_style_mut(self, i
);
65 #[cfg(any(feature = "derive", feature = "full"))]
66 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
67 fn visit_attribute_mut(&mut self, i
: &mut Attribute
) {
68 visit_attribute_mut(self, i
);
70 #[cfg(any(feature = "derive", feature = "full"))]
71 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
72 fn visit_bare_fn_arg_mut(&mut self, i
: &mut BareFnArg
) {
73 visit_bare_fn_arg_mut(self, i
);
75 #[cfg(any(feature = "derive", feature = "full"))]
76 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
77 fn visit_bare_variadic_mut(&mut self, i
: &mut BareVariadic
) {
78 visit_bare_variadic_mut(self, i
);
80 #[cfg(any(feature = "derive", feature = "full"))]
81 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
82 fn visit_bin_op_mut(&mut self, i
: &mut BinOp
) {
83 visit_bin_op_mut(self, i
);
85 #[cfg(feature = "full")]
86 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
87 fn visit_block_mut(&mut self, i
: &mut Block
) {
88 visit_block_mut(self, i
);
90 #[cfg(any(feature = "derive", feature = "full"))]
91 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
92 fn visit_bound_lifetimes_mut(&mut self, i
: &mut BoundLifetimes
) {
93 visit_bound_lifetimes_mut(self, i
);
95 #[cfg(any(feature = "derive", feature = "full"))]
96 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
97 fn visit_const_param_mut(&mut self, i
: &mut ConstParam
) {
98 visit_const_param_mut(self, i
);
100 #[cfg(any(feature = "derive", feature = "full"))]
101 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
102 fn visit_constraint_mut(&mut self, i
: &mut Constraint
) {
103 visit_constraint_mut(self, i
);
105 #[cfg(feature = "derive")]
106 #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
107 fn visit_data_mut(&mut self, i
: &mut Data
) {
108 visit_data_mut(self, i
);
110 #[cfg(feature = "derive")]
111 #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
112 fn visit_data_enum_mut(&mut self, i
: &mut DataEnum
) {
113 visit_data_enum_mut(self, i
);
115 #[cfg(feature = "derive")]
116 #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
117 fn visit_data_struct_mut(&mut self, i
: &mut DataStruct
) {
118 visit_data_struct_mut(self, i
);
120 #[cfg(feature = "derive")]
121 #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
122 fn visit_data_union_mut(&mut self, i
: &mut DataUnion
) {
123 visit_data_union_mut(self, i
);
125 #[cfg(feature = "derive")]
126 #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
127 fn visit_derive_input_mut(&mut self, i
: &mut DeriveInput
) {
128 visit_derive_input_mut(self, i
);
130 #[cfg(any(feature = "derive", feature = "full"))]
131 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
132 fn visit_expr_mut(&mut self, i
: &mut Expr
) {
133 visit_expr_mut(self, i
);
135 #[cfg(feature = "full")]
136 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
137 fn visit_expr_array_mut(&mut self, i
: &mut ExprArray
) {
138 visit_expr_array_mut(self, i
);
140 #[cfg(feature = "full")]
141 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
142 fn visit_expr_assign_mut(&mut self, i
: &mut ExprAssign
) {
143 visit_expr_assign_mut(self, i
);
145 #[cfg(feature = "full")]
146 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
147 fn visit_expr_async_mut(&mut self, i
: &mut ExprAsync
) {
148 visit_expr_async_mut(self, i
);
150 #[cfg(feature = "full")]
151 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
152 fn visit_expr_await_mut(&mut self, i
: &mut ExprAwait
) {
153 visit_expr_await_mut(self, i
);
155 #[cfg(any(feature = "derive", feature = "full"))]
156 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
157 fn visit_expr_binary_mut(&mut self, i
: &mut ExprBinary
) {
158 visit_expr_binary_mut(self, i
);
160 #[cfg(feature = "full")]
161 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
162 fn visit_expr_block_mut(&mut self, i
: &mut ExprBlock
) {
163 visit_expr_block_mut(self, i
);
165 #[cfg(feature = "full")]
166 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
167 fn visit_expr_break_mut(&mut self, i
: &mut ExprBreak
) {
168 visit_expr_break_mut(self, i
);
170 #[cfg(any(feature = "derive", feature = "full"))]
171 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
172 fn visit_expr_call_mut(&mut self, i
: &mut ExprCall
) {
173 visit_expr_call_mut(self, i
);
175 #[cfg(any(feature = "derive", feature = "full"))]
176 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
177 fn visit_expr_cast_mut(&mut self, i
: &mut ExprCast
) {
178 visit_expr_cast_mut(self, i
);
180 #[cfg(feature = "full")]
181 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
182 fn visit_expr_closure_mut(&mut self, i
: &mut ExprClosure
) {
183 visit_expr_closure_mut(self, i
);
185 #[cfg(feature = "full")]
186 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
187 fn visit_expr_const_mut(&mut self, i
: &mut ExprConst
) {
188 visit_expr_const_mut(self, i
);
190 #[cfg(feature = "full")]
191 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
192 fn visit_expr_continue_mut(&mut self, i
: &mut ExprContinue
) {
193 visit_expr_continue_mut(self, i
);
195 #[cfg(any(feature = "derive", feature = "full"))]
196 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
197 fn visit_expr_field_mut(&mut self, i
: &mut ExprField
) {
198 visit_expr_field_mut(self, i
);
200 #[cfg(feature = "full")]
201 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
202 fn visit_expr_for_loop_mut(&mut self, i
: &mut ExprForLoop
) {
203 visit_expr_for_loop_mut(self, i
);
205 #[cfg(any(feature = "derive", feature = "full"))]
206 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
207 fn visit_expr_group_mut(&mut self, i
: &mut ExprGroup
) {
208 visit_expr_group_mut(self, i
);
210 #[cfg(feature = "full")]
211 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
212 fn visit_expr_if_mut(&mut self, i
: &mut ExprIf
) {
213 visit_expr_if_mut(self, i
);
215 #[cfg(any(feature = "derive", feature = "full"))]
216 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
217 fn visit_expr_index_mut(&mut self, i
: &mut ExprIndex
) {
218 visit_expr_index_mut(self, i
);
220 #[cfg(feature = "full")]
221 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
222 fn visit_expr_infer_mut(&mut self, i
: &mut ExprInfer
) {
223 visit_expr_infer_mut(self, i
);
225 #[cfg(feature = "full")]
226 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
227 fn visit_expr_let_mut(&mut self, i
: &mut ExprLet
) {
228 visit_expr_let_mut(self, i
);
230 #[cfg(any(feature = "derive", feature = "full"))]
231 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
232 fn visit_expr_lit_mut(&mut self, i
: &mut ExprLit
) {
233 visit_expr_lit_mut(self, i
);
235 #[cfg(feature = "full")]
236 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
237 fn visit_expr_loop_mut(&mut self, i
: &mut ExprLoop
) {
238 visit_expr_loop_mut(self, i
);
240 #[cfg(any(feature = "derive", feature = "full"))]
241 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
242 fn visit_expr_macro_mut(&mut self, i
: &mut ExprMacro
) {
243 visit_expr_macro_mut(self, i
);
245 #[cfg(feature = "full")]
246 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
247 fn visit_expr_match_mut(&mut self, i
: &mut ExprMatch
) {
248 visit_expr_match_mut(self, i
);
250 #[cfg(any(feature = "derive", feature = "full"))]
251 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
252 fn visit_expr_method_call_mut(&mut self, i
: &mut ExprMethodCall
) {
253 visit_expr_method_call_mut(self, i
);
255 #[cfg(any(feature = "derive", feature = "full"))]
256 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
257 fn visit_expr_paren_mut(&mut self, i
: &mut ExprParen
) {
258 visit_expr_paren_mut(self, i
);
260 #[cfg(any(feature = "derive", feature = "full"))]
261 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
262 fn visit_expr_path_mut(&mut self, i
: &mut ExprPath
) {
263 visit_expr_path_mut(self, i
);
265 #[cfg(feature = "full")]
266 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
267 fn visit_expr_range_mut(&mut self, i
: &mut ExprRange
) {
268 visit_expr_range_mut(self, i
);
270 #[cfg(any(feature = "derive", feature = "full"))]
271 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
272 fn visit_expr_reference_mut(&mut self, i
: &mut ExprReference
) {
273 visit_expr_reference_mut(self, i
);
275 #[cfg(feature = "full")]
276 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
277 fn visit_expr_repeat_mut(&mut self, i
: &mut ExprRepeat
) {
278 visit_expr_repeat_mut(self, i
);
280 #[cfg(feature = "full")]
281 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
282 fn visit_expr_return_mut(&mut self, i
: &mut ExprReturn
) {
283 visit_expr_return_mut(self, i
);
285 #[cfg(any(feature = "derive", feature = "full"))]
286 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
287 fn visit_expr_struct_mut(&mut self, i
: &mut ExprStruct
) {
288 visit_expr_struct_mut(self, i
);
290 #[cfg(feature = "full")]
291 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
292 fn visit_expr_try_mut(&mut self, i
: &mut ExprTry
) {
293 visit_expr_try_mut(self, i
);
295 #[cfg(feature = "full")]
296 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
297 fn visit_expr_try_block_mut(&mut self, i
: &mut ExprTryBlock
) {
298 visit_expr_try_block_mut(self, i
);
300 #[cfg(feature = "full")]
301 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
302 fn visit_expr_tuple_mut(&mut self, i
: &mut ExprTuple
) {
303 visit_expr_tuple_mut(self, i
);
305 #[cfg(any(feature = "derive", feature = "full"))]
306 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
307 fn visit_expr_unary_mut(&mut self, i
: &mut ExprUnary
) {
308 visit_expr_unary_mut(self, i
);
310 #[cfg(feature = "full")]
311 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
312 fn visit_expr_unsafe_mut(&mut self, i
: &mut ExprUnsafe
) {
313 visit_expr_unsafe_mut(self, i
);
315 #[cfg(feature = "full")]
316 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
317 fn visit_expr_while_mut(&mut self, i
: &mut ExprWhile
) {
318 visit_expr_while_mut(self, i
);
320 #[cfg(feature = "full")]
321 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
322 fn visit_expr_yield_mut(&mut self, i
: &mut ExprYield
) {
323 visit_expr_yield_mut(self, i
);
325 #[cfg(any(feature = "derive", feature = "full"))]
326 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
327 fn visit_field_mut(&mut self, i
: &mut Field
) {
328 visit_field_mut(self, i
);
330 #[cfg(any(feature = "derive", feature = "full"))]
331 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
332 fn visit_field_mutability_mut(&mut self, i
: &mut FieldMutability
) {
333 visit_field_mutability_mut(self, i
);
335 #[cfg(feature = "full")]
336 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
337 fn visit_field_pat_mut(&mut self, i
: &mut FieldPat
) {
338 visit_field_pat_mut(self, i
);
340 #[cfg(any(feature = "derive", feature = "full"))]
341 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
342 fn visit_field_value_mut(&mut self, i
: &mut FieldValue
) {
343 visit_field_value_mut(self, i
);
345 #[cfg(any(feature = "derive", feature = "full"))]
346 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
347 fn visit_fields_mut(&mut self, i
: &mut Fields
) {
348 visit_fields_mut(self, i
);
350 #[cfg(any(feature = "derive", feature = "full"))]
351 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
352 fn visit_fields_named_mut(&mut self, i
: &mut FieldsNamed
) {
353 visit_fields_named_mut(self, i
);
355 #[cfg(any(feature = "derive", feature = "full"))]
356 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
357 fn visit_fields_unnamed_mut(&mut self, i
: &mut FieldsUnnamed
) {
358 visit_fields_unnamed_mut(self, i
);
360 #[cfg(feature = "full")]
361 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
362 fn visit_file_mut(&mut self, i
: &mut File
) {
363 visit_file_mut(self, i
);
365 #[cfg(feature = "full")]
366 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
367 fn visit_fn_arg_mut(&mut self, i
: &mut FnArg
) {
368 visit_fn_arg_mut(self, i
);
370 #[cfg(feature = "full")]
371 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
372 fn visit_foreign_item_mut(&mut self, i
: &mut ForeignItem
) {
373 visit_foreign_item_mut(self, i
);
375 #[cfg(feature = "full")]
376 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
377 fn visit_foreign_item_fn_mut(&mut self, i
: &mut ForeignItemFn
) {
378 visit_foreign_item_fn_mut(self, i
);
380 #[cfg(feature = "full")]
381 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
382 fn visit_foreign_item_macro_mut(&mut self, i
: &mut ForeignItemMacro
) {
383 visit_foreign_item_macro_mut(self, i
);
385 #[cfg(feature = "full")]
386 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
387 fn visit_foreign_item_static_mut(&mut self, i
: &mut ForeignItemStatic
) {
388 visit_foreign_item_static_mut(self, i
);
390 #[cfg(feature = "full")]
391 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
392 fn visit_foreign_item_type_mut(&mut self, i
: &mut ForeignItemType
) {
393 visit_foreign_item_type_mut(self, i
);
395 #[cfg(any(feature = "derive", feature = "full"))]
396 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
397 fn visit_generic_argument_mut(&mut self, i
: &mut GenericArgument
) {
398 visit_generic_argument_mut(self, i
);
400 #[cfg(any(feature = "derive", feature = "full"))]
401 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
402 fn visit_generic_param_mut(&mut self, i
: &mut GenericParam
) {
403 visit_generic_param_mut(self, i
);
405 #[cfg(any(feature = "derive", feature = "full"))]
406 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
407 fn visit_generics_mut(&mut self, i
: &mut Generics
) {
408 visit_generics_mut(self, i
);
410 fn visit_ident_mut(&mut self, i
: &mut Ident
) {
411 visit_ident_mut(self, i
);
413 #[cfg(feature = "full")]
414 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
415 fn visit_impl_item_mut(&mut self, i
: &mut ImplItem
) {
416 visit_impl_item_mut(self, i
);
418 #[cfg(feature = "full")]
419 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
420 fn visit_impl_item_const_mut(&mut self, i
: &mut ImplItemConst
) {
421 visit_impl_item_const_mut(self, i
);
423 #[cfg(feature = "full")]
424 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
425 fn visit_impl_item_fn_mut(&mut self, i
: &mut ImplItemFn
) {
426 visit_impl_item_fn_mut(self, i
);
428 #[cfg(feature = "full")]
429 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
430 fn visit_impl_item_macro_mut(&mut self, i
: &mut ImplItemMacro
) {
431 visit_impl_item_macro_mut(self, i
);
433 #[cfg(feature = "full")]
434 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
435 fn visit_impl_item_type_mut(&mut self, i
: &mut ImplItemType
) {
436 visit_impl_item_type_mut(self, i
);
438 #[cfg(feature = "full")]
439 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
440 fn visit_impl_restriction_mut(&mut self, i
: &mut ImplRestriction
) {
441 visit_impl_restriction_mut(self, i
);
443 #[cfg(any(feature = "derive", feature = "full"))]
444 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
445 fn visit_index_mut(&mut self, i
: &mut Index
) {
446 visit_index_mut(self, i
);
448 #[cfg(feature = "full")]
449 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
450 fn visit_item_mut(&mut self, i
: &mut Item
) {
451 visit_item_mut(self, i
);
453 #[cfg(feature = "full")]
454 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
455 fn visit_item_const_mut(&mut self, i
: &mut ItemConst
) {
456 visit_item_const_mut(self, i
);
458 #[cfg(feature = "full")]
459 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
460 fn visit_item_enum_mut(&mut self, i
: &mut ItemEnum
) {
461 visit_item_enum_mut(self, i
);
463 #[cfg(feature = "full")]
464 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
465 fn visit_item_extern_crate_mut(&mut self, i
: &mut ItemExternCrate
) {
466 visit_item_extern_crate_mut(self, i
);
468 #[cfg(feature = "full")]
469 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
470 fn visit_item_fn_mut(&mut self, i
: &mut ItemFn
) {
471 visit_item_fn_mut(self, i
);
473 #[cfg(feature = "full")]
474 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
475 fn visit_item_foreign_mod_mut(&mut self, i
: &mut ItemForeignMod
) {
476 visit_item_foreign_mod_mut(self, i
);
478 #[cfg(feature = "full")]
479 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
480 fn visit_item_impl_mut(&mut self, i
: &mut ItemImpl
) {
481 visit_item_impl_mut(self, i
);
483 #[cfg(feature = "full")]
484 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
485 fn visit_item_macro_mut(&mut self, i
: &mut ItemMacro
) {
486 visit_item_macro_mut(self, i
);
488 #[cfg(feature = "full")]
489 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
490 fn visit_item_mod_mut(&mut self, i
: &mut ItemMod
) {
491 visit_item_mod_mut(self, i
);
493 #[cfg(feature = "full")]
494 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
495 fn visit_item_static_mut(&mut self, i
: &mut ItemStatic
) {
496 visit_item_static_mut(self, i
);
498 #[cfg(feature = "full")]
499 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
500 fn visit_item_struct_mut(&mut self, i
: &mut ItemStruct
) {
501 visit_item_struct_mut(self, i
);
503 #[cfg(feature = "full")]
504 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
505 fn visit_item_trait_mut(&mut self, i
: &mut ItemTrait
) {
506 visit_item_trait_mut(self, i
);
508 #[cfg(feature = "full")]
509 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
510 fn visit_item_trait_alias_mut(&mut self, i
: &mut ItemTraitAlias
) {
511 visit_item_trait_alias_mut(self, i
);
513 #[cfg(feature = "full")]
514 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
515 fn visit_item_type_mut(&mut self, i
: &mut ItemType
) {
516 visit_item_type_mut(self, i
);
518 #[cfg(feature = "full")]
519 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
520 fn visit_item_union_mut(&mut self, i
: &mut ItemUnion
) {
521 visit_item_union_mut(self, i
);
523 #[cfg(feature = "full")]
524 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
525 fn visit_item_use_mut(&mut self, i
: &mut ItemUse
) {
526 visit_item_use_mut(self, i
);
528 #[cfg(feature = "full")]
529 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
530 fn visit_label_mut(&mut self, i
: &mut Label
) {
531 visit_label_mut(self, i
);
533 fn visit_lifetime_mut(&mut self, i
: &mut Lifetime
) {
534 visit_lifetime_mut(self, i
);
536 #[cfg(any(feature = "derive", feature = "full"))]
537 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
538 fn visit_lifetime_param_mut(&mut self, i
: &mut LifetimeParam
) {
539 visit_lifetime_param_mut(self, i
);
541 fn visit_lit_mut(&mut self, i
: &mut Lit
) {
542 visit_lit_mut(self, i
);
544 fn visit_lit_bool_mut(&mut self, i
: &mut LitBool
) {
545 visit_lit_bool_mut(self, i
);
547 fn visit_lit_byte_mut(&mut self, i
: &mut LitByte
) {
548 visit_lit_byte_mut(self, i
);
550 fn visit_lit_byte_str_mut(&mut self, i
: &mut LitByteStr
) {
551 visit_lit_byte_str_mut(self, i
);
553 fn visit_lit_char_mut(&mut self, i
: &mut LitChar
) {
554 visit_lit_char_mut(self, i
);
556 fn visit_lit_float_mut(&mut self, i
: &mut LitFloat
) {
557 visit_lit_float_mut(self, i
);
559 fn visit_lit_int_mut(&mut self, i
: &mut LitInt
) {
560 visit_lit_int_mut(self, i
);
562 fn visit_lit_str_mut(&mut self, i
: &mut LitStr
) {
563 visit_lit_str_mut(self, i
);
565 #[cfg(feature = "full")]
566 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
567 fn visit_local_mut(&mut self, i
: &mut Local
) {
568 visit_local_mut(self, i
);
570 #[cfg(feature = "full")]
571 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
572 fn visit_local_init_mut(&mut self, i
: &mut LocalInit
) {
573 visit_local_init_mut(self, i
);
575 #[cfg(any(feature = "derive", feature = "full"))]
576 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
577 fn visit_macro_mut(&mut self, i
: &mut Macro
) {
578 visit_macro_mut(self, i
);
580 #[cfg(any(feature = "derive", feature = "full"))]
581 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
582 fn visit_macro_delimiter_mut(&mut self, i
: &mut MacroDelimiter
) {
583 visit_macro_delimiter_mut(self, i
);
585 #[cfg(any(feature = "derive", feature = "full"))]
586 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
587 fn visit_member_mut(&mut self, i
: &mut Member
) {
588 visit_member_mut(self, i
);
590 #[cfg(any(feature = "derive", feature = "full"))]
591 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
592 fn visit_meta_mut(&mut self, i
: &mut Meta
) {
593 visit_meta_mut(self, i
);
595 #[cfg(any(feature = "derive", feature = "full"))]
596 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
597 fn visit_meta_list_mut(&mut self, i
: &mut MetaList
) {
598 visit_meta_list_mut(self, i
);
600 #[cfg(any(feature = "derive", feature = "full"))]
601 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
602 fn visit_meta_name_value_mut(&mut self, i
: &mut MetaNameValue
) {
603 visit_meta_name_value_mut(self, i
);
605 #[cfg(any(feature = "derive", feature = "full"))]
606 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
607 fn visit_parenthesized_generic_arguments_mut(
609 i
: &mut ParenthesizedGenericArguments
,
611 visit_parenthesized_generic_arguments_mut(self, i
);
613 #[cfg(feature = "full")]
614 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
615 fn visit_pat_mut(&mut self, i
: &mut Pat
) {
616 visit_pat_mut(self, i
);
618 #[cfg(feature = "full")]
619 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
620 fn visit_pat_ident_mut(&mut self, i
: &mut PatIdent
) {
621 visit_pat_ident_mut(self, i
);
623 #[cfg(feature = "full")]
624 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
625 fn visit_pat_or_mut(&mut self, i
: &mut PatOr
) {
626 visit_pat_or_mut(self, i
);
628 #[cfg(feature = "full")]
629 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
630 fn visit_pat_paren_mut(&mut self, i
: &mut PatParen
) {
631 visit_pat_paren_mut(self, i
);
633 #[cfg(feature = "full")]
634 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
635 fn visit_pat_reference_mut(&mut self, i
: &mut PatReference
) {
636 visit_pat_reference_mut(self, i
);
638 #[cfg(feature = "full")]
639 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
640 fn visit_pat_rest_mut(&mut self, i
: &mut PatRest
) {
641 visit_pat_rest_mut(self, i
);
643 #[cfg(feature = "full")]
644 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
645 fn visit_pat_slice_mut(&mut self, i
: &mut PatSlice
) {
646 visit_pat_slice_mut(self, i
);
648 #[cfg(feature = "full")]
649 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
650 fn visit_pat_struct_mut(&mut self, i
: &mut PatStruct
) {
651 visit_pat_struct_mut(self, i
);
653 #[cfg(feature = "full")]
654 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
655 fn visit_pat_tuple_mut(&mut self, i
: &mut PatTuple
) {
656 visit_pat_tuple_mut(self, i
);
658 #[cfg(feature = "full")]
659 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
660 fn visit_pat_tuple_struct_mut(&mut self, i
: &mut PatTupleStruct
) {
661 visit_pat_tuple_struct_mut(self, i
);
663 #[cfg(feature = "full")]
664 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
665 fn visit_pat_type_mut(&mut self, i
: &mut PatType
) {
666 visit_pat_type_mut(self, i
);
668 #[cfg(feature = "full")]
669 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
670 fn visit_pat_wild_mut(&mut self, i
: &mut PatWild
) {
671 visit_pat_wild_mut(self, i
);
673 #[cfg(any(feature = "derive", feature = "full"))]
674 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
675 fn visit_path_mut(&mut self, i
: &mut Path
) {
676 visit_path_mut(self, i
);
678 #[cfg(any(feature = "derive", feature = "full"))]
679 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
680 fn visit_path_arguments_mut(&mut self, i
: &mut PathArguments
) {
681 visit_path_arguments_mut(self, i
);
683 #[cfg(any(feature = "derive", feature = "full"))]
684 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
685 fn visit_path_segment_mut(&mut self, i
: &mut PathSegment
) {
686 visit_path_segment_mut(self, i
);
688 #[cfg(any(feature = "derive", feature = "full"))]
689 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
690 fn visit_predicate_lifetime_mut(&mut self, i
: &mut PredicateLifetime
) {
691 visit_predicate_lifetime_mut(self, i
);
693 #[cfg(any(feature = "derive", feature = "full"))]
694 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
695 fn visit_predicate_type_mut(&mut self, i
: &mut PredicateType
) {
696 visit_predicate_type_mut(self, i
);
698 #[cfg(any(feature = "derive", feature = "full"))]
699 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
700 fn visit_qself_mut(&mut self, i
: &mut QSelf
) {
701 visit_qself_mut(self, i
);
703 #[cfg(feature = "full")]
704 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
705 fn visit_range_limits_mut(&mut self, i
: &mut RangeLimits
) {
706 visit_range_limits_mut(self, i
);
708 #[cfg(feature = "full")]
709 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
710 fn visit_receiver_mut(&mut self, i
: &mut Receiver
) {
711 visit_receiver_mut(self, i
);
713 #[cfg(any(feature = "derive", feature = "full"))]
714 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
715 fn visit_return_type_mut(&mut self, i
: &mut ReturnType
) {
716 visit_return_type_mut(self, i
);
718 #[cfg(feature = "full")]
719 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
720 fn visit_signature_mut(&mut self, i
: &mut Signature
) {
721 visit_signature_mut(self, i
);
723 fn visit_span_mut(&mut self, i
: &mut Span
) {
724 visit_span_mut(self, i
);
726 #[cfg(feature = "full")]
727 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
728 fn visit_static_mutability_mut(&mut self, i
: &mut StaticMutability
) {
729 visit_static_mutability_mut(self, i
);
731 #[cfg(feature = "full")]
732 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
733 fn visit_stmt_mut(&mut self, i
: &mut Stmt
) {
734 visit_stmt_mut(self, i
);
736 #[cfg(feature = "full")]
737 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
738 fn visit_stmt_macro_mut(&mut self, i
: &mut StmtMacro
) {
739 visit_stmt_macro_mut(self, i
);
741 #[cfg(any(feature = "derive", feature = "full"))]
742 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
743 fn visit_trait_bound_mut(&mut self, i
: &mut TraitBound
) {
744 visit_trait_bound_mut(self, i
);
746 #[cfg(any(feature = "derive", feature = "full"))]
747 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
748 fn visit_trait_bound_modifier_mut(&mut self, i
: &mut TraitBoundModifier
) {
749 visit_trait_bound_modifier_mut(self, i
);
751 #[cfg(feature = "full")]
752 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
753 fn visit_trait_item_mut(&mut self, i
: &mut TraitItem
) {
754 visit_trait_item_mut(self, i
);
756 #[cfg(feature = "full")]
757 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
758 fn visit_trait_item_const_mut(&mut self, i
: &mut TraitItemConst
) {
759 visit_trait_item_const_mut(self, i
);
761 #[cfg(feature = "full")]
762 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
763 fn visit_trait_item_fn_mut(&mut self, i
: &mut TraitItemFn
) {
764 visit_trait_item_fn_mut(self, i
);
766 #[cfg(feature = "full")]
767 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
768 fn visit_trait_item_macro_mut(&mut self, i
: &mut TraitItemMacro
) {
769 visit_trait_item_macro_mut(self, i
);
771 #[cfg(feature = "full")]
772 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
773 fn visit_trait_item_type_mut(&mut self, i
: &mut TraitItemType
) {
774 visit_trait_item_type_mut(self, i
);
776 #[cfg(any(feature = "derive", feature = "full"))]
777 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
778 fn visit_type_mut(&mut self, i
: &mut Type
) {
779 visit_type_mut(self, i
);
781 #[cfg(any(feature = "derive", feature = "full"))]
782 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
783 fn visit_type_array_mut(&mut self, i
: &mut TypeArray
) {
784 visit_type_array_mut(self, i
);
786 #[cfg(any(feature = "derive", feature = "full"))]
787 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
788 fn visit_type_bare_fn_mut(&mut self, i
: &mut TypeBareFn
) {
789 visit_type_bare_fn_mut(self, i
);
791 #[cfg(any(feature = "derive", feature = "full"))]
792 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
793 fn visit_type_group_mut(&mut self, i
: &mut TypeGroup
) {
794 visit_type_group_mut(self, i
);
796 #[cfg(any(feature = "derive", feature = "full"))]
797 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
798 fn visit_type_impl_trait_mut(&mut self, i
: &mut TypeImplTrait
) {
799 visit_type_impl_trait_mut(self, i
);
801 #[cfg(any(feature = "derive", feature = "full"))]
802 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
803 fn visit_type_infer_mut(&mut self, i
: &mut TypeInfer
) {
804 visit_type_infer_mut(self, i
);
806 #[cfg(any(feature = "derive", feature = "full"))]
807 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
808 fn visit_type_macro_mut(&mut self, i
: &mut TypeMacro
) {
809 visit_type_macro_mut(self, i
);
811 #[cfg(any(feature = "derive", feature = "full"))]
812 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
813 fn visit_type_never_mut(&mut self, i
: &mut TypeNever
) {
814 visit_type_never_mut(self, i
);
816 #[cfg(any(feature = "derive", feature = "full"))]
817 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
818 fn visit_type_param_mut(&mut self, i
: &mut TypeParam
) {
819 visit_type_param_mut(self, i
);
821 #[cfg(any(feature = "derive", feature = "full"))]
822 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
823 fn visit_type_param_bound_mut(&mut self, i
: &mut TypeParamBound
) {
824 visit_type_param_bound_mut(self, i
);
826 #[cfg(any(feature = "derive", feature = "full"))]
827 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
828 fn visit_type_paren_mut(&mut self, i
: &mut TypeParen
) {
829 visit_type_paren_mut(self, i
);
831 #[cfg(any(feature = "derive", feature = "full"))]
832 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
833 fn visit_type_path_mut(&mut self, i
: &mut TypePath
) {
834 visit_type_path_mut(self, i
);
836 #[cfg(any(feature = "derive", feature = "full"))]
837 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
838 fn visit_type_ptr_mut(&mut self, i
: &mut TypePtr
) {
839 visit_type_ptr_mut(self, i
);
841 #[cfg(any(feature = "derive", feature = "full"))]
842 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
843 fn visit_type_reference_mut(&mut self, i
: &mut TypeReference
) {
844 visit_type_reference_mut(self, i
);
846 #[cfg(any(feature = "derive", feature = "full"))]
847 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
848 fn visit_type_slice_mut(&mut self, i
: &mut TypeSlice
) {
849 visit_type_slice_mut(self, i
);
851 #[cfg(any(feature = "derive", feature = "full"))]
852 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
853 fn visit_type_trait_object_mut(&mut self, i
: &mut TypeTraitObject
) {
854 visit_type_trait_object_mut(self, i
);
856 #[cfg(any(feature = "derive", feature = "full"))]
857 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
858 fn visit_type_tuple_mut(&mut self, i
: &mut TypeTuple
) {
859 visit_type_tuple_mut(self, i
);
861 #[cfg(any(feature = "derive", feature = "full"))]
862 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
863 fn visit_un_op_mut(&mut self, i
: &mut UnOp
) {
864 visit_un_op_mut(self, i
);
866 #[cfg(feature = "full")]
867 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
868 fn visit_use_glob_mut(&mut self, i
: &mut UseGlob
) {
869 visit_use_glob_mut(self, i
);
871 #[cfg(feature = "full")]
872 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
873 fn visit_use_group_mut(&mut self, i
: &mut UseGroup
) {
874 visit_use_group_mut(self, i
);
876 #[cfg(feature = "full")]
877 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
878 fn visit_use_name_mut(&mut self, i
: &mut UseName
) {
879 visit_use_name_mut(self, i
);
881 #[cfg(feature = "full")]
882 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
883 fn visit_use_path_mut(&mut self, i
: &mut UsePath
) {
884 visit_use_path_mut(self, i
);
886 #[cfg(feature = "full")]
887 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
888 fn visit_use_rename_mut(&mut self, i
: &mut UseRename
) {
889 visit_use_rename_mut(self, i
);
891 #[cfg(feature = "full")]
892 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
893 fn visit_use_tree_mut(&mut self, i
: &mut UseTree
) {
894 visit_use_tree_mut(self, i
);
896 #[cfg(feature = "full")]
897 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
898 fn visit_variadic_mut(&mut self, i
: &mut Variadic
) {
899 visit_variadic_mut(self, i
);
901 #[cfg(any(feature = "derive", feature = "full"))]
902 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
903 fn visit_variant_mut(&mut self, i
: &mut Variant
) {
904 visit_variant_mut(self, i
);
906 #[cfg(any(feature = "derive", feature = "full"))]
907 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
908 fn visit_vis_restricted_mut(&mut self, i
: &mut VisRestricted
) {
909 visit_vis_restricted_mut(self, i
);
911 #[cfg(any(feature = "derive", feature = "full"))]
912 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
913 fn visit_visibility_mut(&mut self, i
: &mut Visibility
) {
914 visit_visibility_mut(self, i
);
916 #[cfg(any(feature = "derive", feature = "full"))]
917 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
918 fn visit_where_clause_mut(&mut self, i
: &mut WhereClause
) {
919 visit_where_clause_mut(self, i
);
921 #[cfg(any(feature = "derive", feature = "full"))]
922 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
923 fn visit_where_predicate_mut(&mut self, i
: &mut WherePredicate
) {
924 visit_where_predicate_mut(self, i
);
927 #[cfg(any(feature = "derive", feature = "full"))]
928 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
929 pub fn visit_abi_mut
<V
>(v
: &mut V
, node
: &mut Abi
)
931 V
: VisitMut
+ ?Sized
,
933 skip
!(node
.extern_token
);
934 if let Some(it
) = &mut node
.name
{
935 v
.visit_lit_str_mut(it
);
938 #[cfg(any(feature = "derive", feature = "full"))]
939 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
940 pub fn visit_angle_bracketed_generic_arguments_mut
<V
>(
942 node
: &mut AngleBracketedGenericArguments
,
945 V
: VisitMut
+ ?Sized
,
947 skip
!(node
.colon2_token
);
948 skip
!(node
.lt_token
);
949 for mut el
in Punctuated
::pairs_mut(&mut node
.args
) {
950 let it
= el
.value_mut();
951 v
.visit_generic_argument_mut(it
);
953 skip
!(node
.gt_token
);
955 #[cfg(feature = "full")]
956 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
957 pub fn visit_arm_mut
<V
>(v
: &mut V
, node
: &mut Arm
)
959 V
: VisitMut
+ ?Sized
,
961 for it
in &mut node
.attrs
{
962 v
.visit_attribute_mut(it
);
964 v
.visit_pat_mut(&mut node
.pat
);
965 if let Some(it
) = &mut node
.guard
{
967 v
.visit_expr_mut(&mut *(it
).1);
969 skip
!(node
.fat_arrow_token
);
970 v
.visit_expr_mut(&mut *node
.body
);
973 #[cfg(any(feature = "derive", feature = "full"))]
974 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
975 pub fn visit_assoc_const_mut
<V
>(v
: &mut V
, node
: &mut AssocConst
)
977 V
: VisitMut
+ ?Sized
,
979 v
.visit_ident_mut(&mut node
.ident
);
980 if let Some(it
) = &mut node
.generics
{
981 v
.visit_angle_bracketed_generic_arguments_mut(it
);
983 skip
!(node
.eq_token
);
984 v
.visit_expr_mut(&mut node
.value
);
986 #[cfg(any(feature = "derive", feature = "full"))]
987 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
988 pub fn visit_assoc_type_mut
<V
>(v
: &mut V
, node
: &mut AssocType
)
990 V
: VisitMut
+ ?Sized
,
992 v
.visit_ident_mut(&mut node
.ident
);
993 if let Some(it
) = &mut node
.generics
{
994 v
.visit_angle_bracketed_generic_arguments_mut(it
);
996 skip
!(node
.eq_token
);
997 v
.visit_type_mut(&mut node
.ty
);
999 #[cfg(any(feature = "derive", feature = "full"))]
1000 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
1001 pub fn visit_attr_style_mut
<V
>(v
: &mut V
, node
: &mut AttrStyle
)
1003 V
: VisitMut
+ ?Sized
,
1006 AttrStyle
::Outer
=> {}
1007 AttrStyle
::Inner(_binding_0
) => {
1012 #[cfg(any(feature = "derive", feature = "full"))]
1013 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
1014 pub fn visit_attribute_mut
<V
>(v
: &mut V
, node
: &mut Attribute
)
1016 V
: VisitMut
+ ?Sized
,
1018 skip
!(node
.pound_token
);
1019 v
.visit_attr_style_mut(&mut node
.style
);
1020 skip
!(node
.bracket_token
);
1021 v
.visit_meta_mut(&mut node
.meta
);
1023 #[cfg(any(feature = "derive", feature = "full"))]
1024 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
1025 pub fn visit_bare_fn_arg_mut
<V
>(v
: &mut V
, node
: &mut BareFnArg
)
1027 V
: VisitMut
+ ?Sized
,
1029 for it
in &mut node
.attrs
{
1030 v
.visit_attribute_mut(it
);
1032 if let Some(it
) = &mut node
.name
{
1033 v
.visit_ident_mut(&mut (it
).0);
1036 v
.visit_type_mut(&mut node
.ty
);
1038 #[cfg(any(feature = "derive", feature = "full"))]
1039 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
1040 pub fn visit_bare_variadic_mut
<V
>(v
: &mut V
, node
: &mut BareVariadic
)
1042 V
: VisitMut
+ ?Sized
,
1044 for it
in &mut node
.attrs
{
1045 v
.visit_attribute_mut(it
);
1047 if let Some(it
) = &mut node
.name
{
1048 v
.visit_ident_mut(&mut (it
).0);
1054 #[cfg(any(feature = "derive", feature = "full"))]
1055 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
1056 pub fn visit_bin_op_mut
<V
>(v
: &mut V
, node
: &mut BinOp
)
1058 V
: VisitMut
+ ?Sized
,
1061 BinOp
::Add(_binding_0
) => {
1064 BinOp
::Sub(_binding_0
) => {
1067 BinOp
::Mul(_binding_0
) => {
1070 BinOp
::Div(_binding_0
) => {
1073 BinOp
::Rem(_binding_0
) => {
1076 BinOp
::And(_binding_0
) => {
1079 BinOp
::Or(_binding_0
) => {
1082 BinOp
::BitXor(_binding_0
) => {
1085 BinOp
::BitAnd(_binding_0
) => {
1088 BinOp
::BitOr(_binding_0
) => {
1091 BinOp
::Shl(_binding_0
) => {
1094 BinOp
::Shr(_binding_0
) => {
1097 BinOp
::Eq(_binding_0
) => {
1100 BinOp
::Lt(_binding_0
) => {
1103 BinOp
::Le(_binding_0
) => {
1106 BinOp
::Ne(_binding_0
) => {
1109 BinOp
::Ge(_binding_0
) => {
1112 BinOp
::Gt(_binding_0
) => {
1115 BinOp
::AddAssign(_binding_0
) => {
1118 BinOp
::SubAssign(_binding_0
) => {
1121 BinOp
::MulAssign(_binding_0
) => {
1124 BinOp
::DivAssign(_binding_0
) => {
1127 BinOp
::RemAssign(_binding_0
) => {
1130 BinOp
::BitXorAssign(_binding_0
) => {
1133 BinOp
::BitAndAssign(_binding_0
) => {
1136 BinOp
::BitOrAssign(_binding_0
) => {
1139 BinOp
::ShlAssign(_binding_0
) => {
1142 BinOp
::ShrAssign(_binding_0
) => {
1147 #[cfg(feature = "full")]
1148 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
1149 pub fn visit_block_mut
<V
>(v
: &mut V
, node
: &mut Block
)
1151 V
: VisitMut
+ ?Sized
,
1153 skip
!(node
.brace_token
);
1154 for it
in &mut node
.stmts
{
1155 v
.visit_stmt_mut(it
);
1158 #[cfg(any(feature = "derive", feature = "full"))]
1159 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
1160 pub fn visit_bound_lifetimes_mut
<V
>(v
: &mut V
, node
: &mut BoundLifetimes
)
1162 V
: VisitMut
+ ?Sized
,
1164 skip
!(node
.for_token
);
1165 skip
!(node
.lt_token
);
1166 for mut el
in Punctuated
::pairs_mut(&mut node
.lifetimes
) {
1167 let it
= el
.value_mut();
1168 v
.visit_generic_param_mut(it
);
1170 skip
!(node
.gt_token
);
1172 #[cfg(any(feature = "derive", feature = "full"))]
1173 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
1174 pub fn visit_const_param_mut
<V
>(v
: &mut V
, node
: &mut ConstParam
)
1176 V
: VisitMut
+ ?Sized
,
1178 for it
in &mut node
.attrs
{
1179 v
.visit_attribute_mut(it
);
1181 skip
!(node
.const_token
);
1182 v
.visit_ident_mut(&mut node
.ident
);
1183 skip
!(node
.colon_token
);
1184 v
.visit_type_mut(&mut node
.ty
);
1185 skip
!(node
.eq_token
);
1186 if let Some(it
) = &mut node
.default {
1187 v
.visit_expr_mut(it
);
1190 #[cfg(any(feature = "derive", feature = "full"))]
1191 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
1192 pub fn visit_constraint_mut
<V
>(v
: &mut V
, node
: &mut Constraint
)
1194 V
: VisitMut
+ ?Sized
,
1196 v
.visit_ident_mut(&mut node
.ident
);
1197 if let Some(it
) = &mut node
.generics
{
1198 v
.visit_angle_bracketed_generic_arguments_mut(it
);
1200 skip
!(node
.colon_token
);
1201 for mut el
in Punctuated
::pairs_mut(&mut node
.bounds
) {
1202 let it
= el
.value_mut();
1203 v
.visit_type_param_bound_mut(it
);
1206 #[cfg(feature = "derive")]
1207 #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
1208 pub fn visit_data_mut
<V
>(v
: &mut V
, node
: &mut Data
)
1210 V
: VisitMut
+ ?Sized
,
1213 Data
::Struct(_binding_0
) => {
1214 v
.visit_data_struct_mut(_binding_0
);
1216 Data
::Enum(_binding_0
) => {
1217 v
.visit_data_enum_mut(_binding_0
);
1219 Data
::Union(_binding_0
) => {
1220 v
.visit_data_union_mut(_binding_0
);
1224 #[cfg(feature = "derive")]
1225 #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
1226 pub fn visit_data_enum_mut
<V
>(v
: &mut V
, node
: &mut DataEnum
)
1228 V
: VisitMut
+ ?Sized
,
1230 skip
!(node
.enum_token
);
1231 skip
!(node
.brace_token
);
1232 for mut el
in Punctuated
::pairs_mut(&mut node
.variants
) {
1233 let it
= el
.value_mut();
1234 v
.visit_variant_mut(it
);
1237 #[cfg(feature = "derive")]
1238 #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
1239 pub fn visit_data_struct_mut
<V
>(v
: &mut V
, node
: &mut DataStruct
)
1241 V
: VisitMut
+ ?Sized
,
1243 skip
!(node
.struct_token
);
1244 v
.visit_fields_mut(&mut node
.fields
);
1245 skip
!(node
.semi_token
);
1247 #[cfg(feature = "derive")]
1248 #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
1249 pub fn visit_data_union_mut
<V
>(v
: &mut V
, node
: &mut DataUnion
)
1251 V
: VisitMut
+ ?Sized
,
1253 skip
!(node
.union_token
);
1254 v
.visit_fields_named_mut(&mut node
.fields
);
1256 #[cfg(feature = "derive")]
1257 #[cfg_attr(doc_cfg, doc(cfg(feature = "derive")))]
1258 pub fn visit_derive_input_mut
<V
>(v
: &mut V
, node
: &mut DeriveInput
)
1260 V
: VisitMut
+ ?Sized
,
1262 for it
in &mut node
.attrs
{
1263 v
.visit_attribute_mut(it
);
1265 v
.visit_visibility_mut(&mut node
.vis
);
1266 v
.visit_ident_mut(&mut node
.ident
);
1267 v
.visit_generics_mut(&mut node
.generics
);
1268 v
.visit_data_mut(&mut node
.data
);
1270 #[cfg(any(feature = "derive", feature = "full"))]
1271 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
1272 pub fn visit_expr_mut
<V
>(v
: &mut V
, node
: &mut Expr
)
1274 V
: VisitMut
+ ?Sized
,
1277 Expr
::Array(_binding_0
) => {
1278 full
!(v
.visit_expr_array_mut(_binding_0
));
1280 Expr
::Assign(_binding_0
) => {
1281 full
!(v
.visit_expr_assign_mut(_binding_0
));
1283 Expr
::Async(_binding_0
) => {
1284 full
!(v
.visit_expr_async_mut(_binding_0
));
1286 Expr
::Await(_binding_0
) => {
1287 full
!(v
.visit_expr_await_mut(_binding_0
));
1289 Expr
::Binary(_binding_0
) => {
1290 v
.visit_expr_binary_mut(_binding_0
);
1292 Expr
::Block(_binding_0
) => {
1293 full
!(v
.visit_expr_block_mut(_binding_0
));
1295 Expr
::Break(_binding_0
) => {
1296 full
!(v
.visit_expr_break_mut(_binding_0
));
1298 Expr
::Call(_binding_0
) => {
1299 v
.visit_expr_call_mut(_binding_0
);
1301 Expr
::Cast(_binding_0
) => {
1302 v
.visit_expr_cast_mut(_binding_0
);
1304 Expr
::Closure(_binding_0
) => {
1305 full
!(v
.visit_expr_closure_mut(_binding_0
));
1307 Expr
::Const(_binding_0
) => {
1308 full
!(v
.visit_expr_const_mut(_binding_0
));
1310 Expr
::Continue(_binding_0
) => {
1311 full
!(v
.visit_expr_continue_mut(_binding_0
));
1313 Expr
::Field(_binding_0
) => {
1314 v
.visit_expr_field_mut(_binding_0
);
1316 Expr
::ForLoop(_binding_0
) => {
1317 full
!(v
.visit_expr_for_loop_mut(_binding_0
));
1319 Expr
::Group(_binding_0
) => {
1320 v
.visit_expr_group_mut(_binding_0
);
1322 Expr
::If(_binding_0
) => {
1323 full
!(v
.visit_expr_if_mut(_binding_0
));
1325 Expr
::Index(_binding_0
) => {
1326 v
.visit_expr_index_mut(_binding_0
);
1328 Expr
::Infer(_binding_0
) => {
1329 full
!(v
.visit_expr_infer_mut(_binding_0
));
1331 Expr
::Let(_binding_0
) => {
1332 full
!(v
.visit_expr_let_mut(_binding_0
));
1334 Expr
::Lit(_binding_0
) => {
1335 v
.visit_expr_lit_mut(_binding_0
);
1337 Expr
::Loop(_binding_0
) => {
1338 full
!(v
.visit_expr_loop_mut(_binding_0
));
1340 Expr
::Macro(_binding_0
) => {
1341 v
.visit_expr_macro_mut(_binding_0
);
1343 Expr
::Match(_binding_0
) => {
1344 full
!(v
.visit_expr_match_mut(_binding_0
));
1346 Expr
::MethodCall(_binding_0
) => {
1347 v
.visit_expr_method_call_mut(_binding_0
);
1349 Expr
::Paren(_binding_0
) => {
1350 v
.visit_expr_paren_mut(_binding_0
);
1352 Expr
::Path(_binding_0
) => {
1353 v
.visit_expr_path_mut(_binding_0
);
1355 Expr
::Range(_binding_0
) => {
1356 full
!(v
.visit_expr_range_mut(_binding_0
));
1358 Expr
::Reference(_binding_0
) => {
1359 v
.visit_expr_reference_mut(_binding_0
);
1361 Expr
::Repeat(_binding_0
) => {
1362 full
!(v
.visit_expr_repeat_mut(_binding_0
));
1364 Expr
::Return(_binding_0
) => {
1365 full
!(v
.visit_expr_return_mut(_binding_0
));
1367 Expr
::Struct(_binding_0
) => {
1368 v
.visit_expr_struct_mut(_binding_0
);
1370 Expr
::Try(_binding_0
) => {
1371 full
!(v
.visit_expr_try_mut(_binding_0
));
1373 Expr
::TryBlock(_binding_0
) => {
1374 full
!(v
.visit_expr_try_block_mut(_binding_0
));
1376 Expr
::Tuple(_binding_0
) => {
1377 full
!(v
.visit_expr_tuple_mut(_binding_0
));
1379 Expr
::Unary(_binding_0
) => {
1380 v
.visit_expr_unary_mut(_binding_0
);
1382 Expr
::Unsafe(_binding_0
) => {
1383 full
!(v
.visit_expr_unsafe_mut(_binding_0
));
1385 Expr
::Verbatim(_binding_0
) => {
1388 Expr
::While(_binding_0
) => {
1389 full
!(v
.visit_expr_while_mut(_binding_0
));
1391 Expr
::Yield(_binding_0
) => {
1392 full
!(v
.visit_expr_yield_mut(_binding_0
));
1396 #[cfg(feature = "full")]
1397 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
1398 pub fn visit_expr_array_mut
<V
>(v
: &mut V
, node
: &mut ExprArray
)
1400 V
: VisitMut
+ ?Sized
,
1402 for it
in &mut node
.attrs
{
1403 v
.visit_attribute_mut(it
);
1405 skip
!(node
.bracket_token
);
1406 for mut el
in Punctuated
::pairs_mut(&mut node
.elems
) {
1407 let it
= el
.value_mut();
1408 v
.visit_expr_mut(it
);
1411 #[cfg(feature = "full")]
1412 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
1413 pub fn visit_expr_assign_mut
<V
>(v
: &mut V
, node
: &mut ExprAssign
)
1415 V
: VisitMut
+ ?Sized
,
1417 for it
in &mut node
.attrs
{
1418 v
.visit_attribute_mut(it
);
1420 v
.visit_expr_mut(&mut *node
.left
);
1421 skip
!(node
.eq_token
);
1422 v
.visit_expr_mut(&mut *node
.right
);
1424 #[cfg(feature = "full")]
1425 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
1426 pub fn visit_expr_async_mut
<V
>(v
: &mut V
, node
: &mut ExprAsync
)
1428 V
: VisitMut
+ ?Sized
,
1430 for it
in &mut node
.attrs
{
1431 v
.visit_attribute_mut(it
);
1433 skip
!(node
.async_token
);
1434 skip
!(node
.capture
);
1435 v
.visit_block_mut(&mut node
.block
);
1437 #[cfg(feature = "full")]
1438 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
1439 pub fn visit_expr_await_mut
<V
>(v
: &mut V
, node
: &mut ExprAwait
)
1441 V
: VisitMut
+ ?Sized
,
1443 for it
in &mut node
.attrs
{
1444 v
.visit_attribute_mut(it
);
1446 v
.visit_expr_mut(&mut *node
.base
);
1447 skip
!(node
.dot_token
);
1448 skip
!(node
.await_token
);
1450 #[cfg(any(feature = "derive", feature = "full"))]
1451 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
1452 pub fn visit_expr_binary_mut
<V
>(v
: &mut V
, node
: &mut ExprBinary
)
1454 V
: VisitMut
+ ?Sized
,
1456 for it
in &mut node
.attrs
{
1457 v
.visit_attribute_mut(it
);
1459 v
.visit_expr_mut(&mut *node
.left
);
1460 v
.visit_bin_op_mut(&mut node
.op
);
1461 v
.visit_expr_mut(&mut *node
.right
);
1463 #[cfg(feature = "full")]
1464 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
1465 pub fn visit_expr_block_mut
<V
>(v
: &mut V
, node
: &mut ExprBlock
)
1467 V
: VisitMut
+ ?Sized
,
1469 for it
in &mut node
.attrs
{
1470 v
.visit_attribute_mut(it
);
1472 if let Some(it
) = &mut node
.label
{
1473 v
.visit_label_mut(it
);
1475 v
.visit_block_mut(&mut node
.block
);
1477 #[cfg(feature = "full")]
1478 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
1479 pub fn visit_expr_break_mut
<V
>(v
: &mut V
, node
: &mut ExprBreak
)
1481 V
: VisitMut
+ ?Sized
,
1483 for it
in &mut node
.attrs
{
1484 v
.visit_attribute_mut(it
);
1486 skip
!(node
.break_token
);
1487 if let Some(it
) = &mut node
.label
{
1488 v
.visit_lifetime_mut(it
);
1490 if let Some(it
) = &mut node
.expr
{
1491 v
.visit_expr_mut(&mut **it
);
1494 #[cfg(any(feature = "derive", feature = "full"))]
1495 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
1496 pub fn visit_expr_call_mut
<V
>(v
: &mut V
, node
: &mut ExprCall
)
1498 V
: VisitMut
+ ?Sized
,
1500 for it
in &mut node
.attrs
{
1501 v
.visit_attribute_mut(it
);
1503 v
.visit_expr_mut(&mut *node
.func
);
1504 skip
!(node
.paren_token
);
1505 for mut el
in Punctuated
::pairs_mut(&mut node
.args
) {
1506 let it
= el
.value_mut();
1507 v
.visit_expr_mut(it
);
1510 #[cfg(any(feature = "derive", feature = "full"))]
1511 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
1512 pub fn visit_expr_cast_mut
<V
>(v
: &mut V
, node
: &mut ExprCast
)
1514 V
: VisitMut
+ ?Sized
,
1516 for it
in &mut node
.attrs
{
1517 v
.visit_attribute_mut(it
);
1519 v
.visit_expr_mut(&mut *node
.expr
);
1520 skip
!(node
.as_token
);
1521 v
.visit_type_mut(&mut *node
.ty
);
1523 #[cfg(feature = "full")]
1524 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
1525 pub fn visit_expr_closure_mut
<V
>(v
: &mut V
, node
: &mut ExprClosure
)
1527 V
: VisitMut
+ ?Sized
,
1529 for it
in &mut node
.attrs
{
1530 v
.visit_attribute_mut(it
);
1532 if let Some(it
) = &mut node
.lifetimes
{
1533 v
.visit_bound_lifetimes_mut(it
);
1535 skip
!(node
.constness
);
1536 skip
!(node
.movability
);
1537 skip
!(node
.asyncness
);
1538 skip
!(node
.capture
);
1539 skip
!(node
.or1_token
);
1540 for mut el
in Punctuated
::pairs_mut(&mut node
.inputs
) {
1541 let it
= el
.value_mut();
1542 v
.visit_pat_mut(it
);
1544 skip
!(node
.or2_token
);
1545 v
.visit_return_type_mut(&mut node
.output
);
1546 v
.visit_expr_mut(&mut *node
.body
);
1548 #[cfg(feature = "full")]
1549 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
1550 pub fn visit_expr_const_mut
<V
>(v
: &mut V
, node
: &mut ExprConst
)
1552 V
: VisitMut
+ ?Sized
,
1554 for it
in &mut node
.attrs
{
1555 v
.visit_attribute_mut(it
);
1557 skip
!(node
.const_token
);
1558 v
.visit_block_mut(&mut node
.block
);
1560 #[cfg(feature = "full")]
1561 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
1562 pub fn visit_expr_continue_mut
<V
>(v
: &mut V
, node
: &mut ExprContinue
)
1564 V
: VisitMut
+ ?Sized
,
1566 for it
in &mut node
.attrs
{
1567 v
.visit_attribute_mut(it
);
1569 skip
!(node
.continue_token
);
1570 if let Some(it
) = &mut node
.label
{
1571 v
.visit_lifetime_mut(it
);
1574 #[cfg(any(feature = "derive", feature = "full"))]
1575 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
1576 pub fn visit_expr_field_mut
<V
>(v
: &mut V
, node
: &mut ExprField
)
1578 V
: VisitMut
+ ?Sized
,
1580 for it
in &mut node
.attrs
{
1581 v
.visit_attribute_mut(it
);
1583 v
.visit_expr_mut(&mut *node
.base
);
1584 skip
!(node
.dot_token
);
1585 v
.visit_member_mut(&mut node
.member
);
1587 #[cfg(feature = "full")]
1588 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
1589 pub fn visit_expr_for_loop_mut
<V
>(v
: &mut V
, node
: &mut ExprForLoop
)
1591 V
: VisitMut
+ ?Sized
,
1593 for it
in &mut node
.attrs
{
1594 v
.visit_attribute_mut(it
);
1596 if let Some(it
) = &mut node
.label
{
1597 v
.visit_label_mut(it
);
1599 skip
!(node
.for_token
);
1600 v
.visit_pat_mut(&mut *node
.pat
);
1601 skip
!(node
.in_token
);
1602 v
.visit_expr_mut(&mut *node
.expr
);
1603 v
.visit_block_mut(&mut node
.body
);
1605 #[cfg(any(feature = "derive", feature = "full"))]
1606 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
1607 pub fn visit_expr_group_mut
<V
>(v
: &mut V
, node
: &mut ExprGroup
)
1609 V
: VisitMut
+ ?Sized
,
1611 for it
in &mut node
.attrs
{
1612 v
.visit_attribute_mut(it
);
1614 skip
!(node
.group_token
);
1615 v
.visit_expr_mut(&mut *node
.expr
);
1617 #[cfg(feature = "full")]
1618 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
1619 pub fn visit_expr_if_mut
<V
>(v
: &mut V
, node
: &mut ExprIf
)
1621 V
: VisitMut
+ ?Sized
,
1623 for it
in &mut node
.attrs
{
1624 v
.visit_attribute_mut(it
);
1626 skip
!(node
.if_token
);
1627 v
.visit_expr_mut(&mut *node
.cond
);
1628 v
.visit_block_mut(&mut node
.then_branch
);
1629 if let Some(it
) = &mut node
.else_branch
{
1631 v
.visit_expr_mut(&mut *(it
).1);
1634 #[cfg(any(feature = "derive", feature = "full"))]
1635 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
1636 pub fn visit_expr_index_mut
<V
>(v
: &mut V
, node
: &mut ExprIndex
)
1638 V
: VisitMut
+ ?Sized
,
1640 for it
in &mut node
.attrs
{
1641 v
.visit_attribute_mut(it
);
1643 v
.visit_expr_mut(&mut *node
.expr
);
1644 skip
!(node
.bracket_token
);
1645 v
.visit_expr_mut(&mut *node
.index
);
1647 #[cfg(feature = "full")]
1648 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
1649 pub fn visit_expr_infer_mut
<V
>(v
: &mut V
, node
: &mut ExprInfer
)
1651 V
: VisitMut
+ ?Sized
,
1653 for it
in &mut node
.attrs
{
1654 v
.visit_attribute_mut(it
);
1656 skip
!(node
.underscore_token
);
1658 #[cfg(feature = "full")]
1659 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
1660 pub fn visit_expr_let_mut
<V
>(v
: &mut V
, node
: &mut ExprLet
)
1662 V
: VisitMut
+ ?Sized
,
1664 for it
in &mut node
.attrs
{
1665 v
.visit_attribute_mut(it
);
1667 skip
!(node
.let_token
);
1668 v
.visit_pat_mut(&mut *node
.pat
);
1669 skip
!(node
.eq_token
);
1670 v
.visit_expr_mut(&mut *node
.expr
);
1672 #[cfg(any(feature = "derive", feature = "full"))]
1673 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
1674 pub fn visit_expr_lit_mut
<V
>(v
: &mut V
, node
: &mut ExprLit
)
1676 V
: VisitMut
+ ?Sized
,
1678 for it
in &mut node
.attrs
{
1679 v
.visit_attribute_mut(it
);
1681 v
.visit_lit_mut(&mut node
.lit
);
1683 #[cfg(feature = "full")]
1684 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
1685 pub fn visit_expr_loop_mut
<V
>(v
: &mut V
, node
: &mut ExprLoop
)
1687 V
: VisitMut
+ ?Sized
,
1689 for it
in &mut node
.attrs
{
1690 v
.visit_attribute_mut(it
);
1692 if let Some(it
) = &mut node
.label
{
1693 v
.visit_label_mut(it
);
1695 skip
!(node
.loop_token
);
1696 v
.visit_block_mut(&mut node
.body
);
1698 #[cfg(any(feature = "derive", feature = "full"))]
1699 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
1700 pub fn visit_expr_macro_mut
<V
>(v
: &mut V
, node
: &mut ExprMacro
)
1702 V
: VisitMut
+ ?Sized
,
1704 for it
in &mut node
.attrs
{
1705 v
.visit_attribute_mut(it
);
1707 v
.visit_macro_mut(&mut node
.mac
);
1709 #[cfg(feature = "full")]
1710 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
1711 pub fn visit_expr_match_mut
<V
>(v
: &mut V
, node
: &mut ExprMatch
)
1713 V
: VisitMut
+ ?Sized
,
1715 for it
in &mut node
.attrs
{
1716 v
.visit_attribute_mut(it
);
1718 skip
!(node
.match_token
);
1719 v
.visit_expr_mut(&mut *node
.expr
);
1720 skip
!(node
.brace_token
);
1721 for it
in &mut node
.arms
{
1722 v
.visit_arm_mut(it
);
1725 #[cfg(any(feature = "derive", feature = "full"))]
1726 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
1727 pub fn visit_expr_method_call_mut
<V
>(v
: &mut V
, node
: &mut ExprMethodCall
)
1729 V
: VisitMut
+ ?Sized
,
1731 for it
in &mut node
.attrs
{
1732 v
.visit_attribute_mut(it
);
1734 v
.visit_expr_mut(&mut *node
.receiver
);
1735 skip
!(node
.dot_token
);
1736 v
.visit_ident_mut(&mut node
.method
);
1737 if let Some(it
) = &mut node
.turbofish
{
1738 v
.visit_angle_bracketed_generic_arguments_mut(it
);
1740 skip
!(node
.paren_token
);
1741 for mut el
in Punctuated
::pairs_mut(&mut node
.args
) {
1742 let it
= el
.value_mut();
1743 v
.visit_expr_mut(it
);
1746 #[cfg(any(feature = "derive", feature = "full"))]
1747 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
1748 pub fn visit_expr_paren_mut
<V
>(v
: &mut V
, node
: &mut ExprParen
)
1750 V
: VisitMut
+ ?Sized
,
1752 for it
in &mut node
.attrs
{
1753 v
.visit_attribute_mut(it
);
1755 skip
!(node
.paren_token
);
1756 v
.visit_expr_mut(&mut *node
.expr
);
1758 #[cfg(any(feature = "derive", feature = "full"))]
1759 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
1760 pub fn visit_expr_path_mut
<V
>(v
: &mut V
, node
: &mut ExprPath
)
1762 V
: VisitMut
+ ?Sized
,
1764 for it
in &mut node
.attrs
{
1765 v
.visit_attribute_mut(it
);
1767 if let Some(it
) = &mut node
.qself
{
1768 v
.visit_qself_mut(it
);
1770 v
.visit_path_mut(&mut node
.path
);
1772 #[cfg(feature = "full")]
1773 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
1774 pub fn visit_expr_range_mut
<V
>(v
: &mut V
, node
: &mut ExprRange
)
1776 V
: VisitMut
+ ?Sized
,
1778 for it
in &mut node
.attrs
{
1779 v
.visit_attribute_mut(it
);
1781 if let Some(it
) = &mut node
.start
{
1782 v
.visit_expr_mut(&mut **it
);
1784 v
.visit_range_limits_mut(&mut node
.limits
);
1785 if let Some(it
) = &mut node
.end
{
1786 v
.visit_expr_mut(&mut **it
);
1789 #[cfg(any(feature = "derive", feature = "full"))]
1790 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
1791 pub fn visit_expr_reference_mut
<V
>(v
: &mut V
, node
: &mut ExprReference
)
1793 V
: VisitMut
+ ?Sized
,
1795 for it
in &mut node
.attrs
{
1796 v
.visit_attribute_mut(it
);
1798 skip
!(node
.and_token
);
1799 skip
!(node
.mutability
);
1800 v
.visit_expr_mut(&mut *node
.expr
);
1802 #[cfg(feature = "full")]
1803 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
1804 pub fn visit_expr_repeat_mut
<V
>(v
: &mut V
, node
: &mut ExprRepeat
)
1806 V
: VisitMut
+ ?Sized
,
1808 for it
in &mut node
.attrs
{
1809 v
.visit_attribute_mut(it
);
1811 skip
!(node
.bracket_token
);
1812 v
.visit_expr_mut(&mut *node
.expr
);
1813 skip
!(node
.semi_token
);
1814 v
.visit_expr_mut(&mut *node
.len
);
1816 #[cfg(feature = "full")]
1817 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
1818 pub fn visit_expr_return_mut
<V
>(v
: &mut V
, node
: &mut ExprReturn
)
1820 V
: VisitMut
+ ?Sized
,
1822 for it
in &mut node
.attrs
{
1823 v
.visit_attribute_mut(it
);
1825 skip
!(node
.return_token
);
1826 if let Some(it
) = &mut node
.expr
{
1827 v
.visit_expr_mut(&mut **it
);
1830 #[cfg(any(feature = "derive", feature = "full"))]
1831 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
1832 pub fn visit_expr_struct_mut
<V
>(v
: &mut V
, node
: &mut ExprStruct
)
1834 V
: VisitMut
+ ?Sized
,
1836 for it
in &mut node
.attrs
{
1837 v
.visit_attribute_mut(it
);
1839 if let Some(it
) = &mut node
.qself
{
1840 v
.visit_qself_mut(it
);
1842 v
.visit_path_mut(&mut node
.path
);
1843 skip
!(node
.brace_token
);
1844 for mut el
in Punctuated
::pairs_mut(&mut node
.fields
) {
1845 let it
= el
.value_mut();
1846 v
.visit_field_value_mut(it
);
1848 skip
!(node
.dot2_token
);
1849 if let Some(it
) = &mut node
.rest
{
1850 v
.visit_expr_mut(&mut **it
);
1853 #[cfg(feature = "full")]
1854 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
1855 pub fn visit_expr_try_mut
<V
>(v
: &mut V
, node
: &mut ExprTry
)
1857 V
: VisitMut
+ ?Sized
,
1859 for it
in &mut node
.attrs
{
1860 v
.visit_attribute_mut(it
);
1862 v
.visit_expr_mut(&mut *node
.expr
);
1863 skip
!(node
.question_token
);
1865 #[cfg(feature = "full")]
1866 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
1867 pub fn visit_expr_try_block_mut
<V
>(v
: &mut V
, node
: &mut ExprTryBlock
)
1869 V
: VisitMut
+ ?Sized
,
1871 for it
in &mut node
.attrs
{
1872 v
.visit_attribute_mut(it
);
1874 skip
!(node
.try_token
);
1875 v
.visit_block_mut(&mut node
.block
);
1877 #[cfg(feature = "full")]
1878 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
1879 pub fn visit_expr_tuple_mut
<V
>(v
: &mut V
, node
: &mut ExprTuple
)
1881 V
: VisitMut
+ ?Sized
,
1883 for it
in &mut node
.attrs
{
1884 v
.visit_attribute_mut(it
);
1886 skip
!(node
.paren_token
);
1887 for mut el
in Punctuated
::pairs_mut(&mut node
.elems
) {
1888 let it
= el
.value_mut();
1889 v
.visit_expr_mut(it
);
1892 #[cfg(any(feature = "derive", feature = "full"))]
1893 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
1894 pub fn visit_expr_unary_mut
<V
>(v
: &mut V
, node
: &mut ExprUnary
)
1896 V
: VisitMut
+ ?Sized
,
1898 for it
in &mut node
.attrs
{
1899 v
.visit_attribute_mut(it
);
1901 v
.visit_un_op_mut(&mut node
.op
);
1902 v
.visit_expr_mut(&mut *node
.expr
);
1904 #[cfg(feature = "full")]
1905 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
1906 pub fn visit_expr_unsafe_mut
<V
>(v
: &mut V
, node
: &mut ExprUnsafe
)
1908 V
: VisitMut
+ ?Sized
,
1910 for it
in &mut node
.attrs
{
1911 v
.visit_attribute_mut(it
);
1913 skip
!(node
.unsafe_token
);
1914 v
.visit_block_mut(&mut node
.block
);
1916 #[cfg(feature = "full")]
1917 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
1918 pub fn visit_expr_while_mut
<V
>(v
: &mut V
, node
: &mut ExprWhile
)
1920 V
: VisitMut
+ ?Sized
,
1922 for it
in &mut node
.attrs
{
1923 v
.visit_attribute_mut(it
);
1925 if let Some(it
) = &mut node
.label
{
1926 v
.visit_label_mut(it
);
1928 skip
!(node
.while_token
);
1929 v
.visit_expr_mut(&mut *node
.cond
);
1930 v
.visit_block_mut(&mut node
.body
);
1932 #[cfg(feature = "full")]
1933 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
1934 pub fn visit_expr_yield_mut
<V
>(v
: &mut V
, node
: &mut ExprYield
)
1936 V
: VisitMut
+ ?Sized
,
1938 for it
in &mut node
.attrs
{
1939 v
.visit_attribute_mut(it
);
1941 skip
!(node
.yield_token
);
1942 if let Some(it
) = &mut node
.expr
{
1943 v
.visit_expr_mut(&mut **it
);
1946 #[cfg(any(feature = "derive", feature = "full"))]
1947 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
1948 pub fn visit_field_mut
<V
>(v
: &mut V
, node
: &mut Field
)
1950 V
: VisitMut
+ ?Sized
,
1952 for it
in &mut node
.attrs
{
1953 v
.visit_attribute_mut(it
);
1955 v
.visit_visibility_mut(&mut node
.vis
);
1956 v
.visit_field_mutability_mut(&mut node
.mutability
);
1957 if let Some(it
) = &mut node
.ident
{
1958 v
.visit_ident_mut(it
);
1960 skip
!(node
.colon_token
);
1961 v
.visit_type_mut(&mut node
.ty
);
1963 #[cfg(any(feature = "derive", feature = "full"))]
1964 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
1965 pub fn visit_field_mutability_mut
<V
>(v
: &mut V
, node
: &mut FieldMutability
)
1967 V
: VisitMut
+ ?Sized
,
1970 FieldMutability
::None
=> {}
1973 #[cfg(feature = "full")]
1974 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
1975 pub fn visit_field_pat_mut
<V
>(v
: &mut V
, node
: &mut FieldPat
)
1977 V
: VisitMut
+ ?Sized
,
1979 for it
in &mut node
.attrs
{
1980 v
.visit_attribute_mut(it
);
1982 v
.visit_member_mut(&mut node
.member
);
1983 skip
!(node
.colon_token
);
1984 v
.visit_pat_mut(&mut *node
.pat
);
1986 #[cfg(any(feature = "derive", feature = "full"))]
1987 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
1988 pub fn visit_field_value_mut
<V
>(v
: &mut V
, node
: &mut FieldValue
)
1990 V
: VisitMut
+ ?Sized
,
1992 for it
in &mut node
.attrs
{
1993 v
.visit_attribute_mut(it
);
1995 v
.visit_member_mut(&mut node
.member
);
1996 skip
!(node
.colon_token
);
1997 v
.visit_expr_mut(&mut node
.expr
);
1999 #[cfg(any(feature = "derive", feature = "full"))]
2000 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
2001 pub fn visit_fields_mut
<V
>(v
: &mut V
, node
: &mut Fields
)
2003 V
: VisitMut
+ ?Sized
,
2006 Fields
::Named(_binding_0
) => {
2007 v
.visit_fields_named_mut(_binding_0
);
2009 Fields
::Unnamed(_binding_0
) => {
2010 v
.visit_fields_unnamed_mut(_binding_0
);
2015 #[cfg(any(feature = "derive", feature = "full"))]
2016 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
2017 pub fn visit_fields_named_mut
<V
>(v
: &mut V
, node
: &mut FieldsNamed
)
2019 V
: VisitMut
+ ?Sized
,
2021 skip
!(node
.brace_token
);
2022 for mut el
in Punctuated
::pairs_mut(&mut node
.named
) {
2023 let it
= el
.value_mut();
2024 v
.visit_field_mut(it
);
2027 #[cfg(any(feature = "derive", feature = "full"))]
2028 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
2029 pub fn visit_fields_unnamed_mut
<V
>(v
: &mut V
, node
: &mut FieldsUnnamed
)
2031 V
: VisitMut
+ ?Sized
,
2033 skip
!(node
.paren_token
);
2034 for mut el
in Punctuated
::pairs_mut(&mut node
.unnamed
) {
2035 let it
= el
.value_mut();
2036 v
.visit_field_mut(it
);
2039 #[cfg(feature = "full")]
2040 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2041 pub fn visit_file_mut
<V
>(v
: &mut V
, node
: &mut File
)
2043 V
: VisitMut
+ ?Sized
,
2045 skip
!(node
.shebang
);
2046 for it
in &mut node
.attrs
{
2047 v
.visit_attribute_mut(it
);
2049 for it
in &mut node
.items
{
2050 v
.visit_item_mut(it
);
2053 #[cfg(feature = "full")]
2054 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2055 pub fn visit_fn_arg_mut
<V
>(v
: &mut V
, node
: &mut FnArg
)
2057 V
: VisitMut
+ ?Sized
,
2060 FnArg
::Receiver(_binding_0
) => {
2061 v
.visit_receiver_mut(_binding_0
);
2063 FnArg
::Typed(_binding_0
) => {
2064 v
.visit_pat_type_mut(_binding_0
);
2068 #[cfg(feature = "full")]
2069 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2070 pub fn visit_foreign_item_mut
<V
>(v
: &mut V
, node
: &mut ForeignItem
)
2072 V
: VisitMut
+ ?Sized
,
2075 ForeignItem
::Fn(_binding_0
) => {
2076 v
.visit_foreign_item_fn_mut(_binding_0
);
2078 ForeignItem
::Static(_binding_0
) => {
2079 v
.visit_foreign_item_static_mut(_binding_0
);
2081 ForeignItem
::Type(_binding_0
) => {
2082 v
.visit_foreign_item_type_mut(_binding_0
);
2084 ForeignItem
::Macro(_binding_0
) => {
2085 v
.visit_foreign_item_macro_mut(_binding_0
);
2087 ForeignItem
::Verbatim(_binding_0
) => {
2092 #[cfg(feature = "full")]
2093 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2094 pub fn visit_foreign_item_fn_mut
<V
>(v
: &mut V
, node
: &mut ForeignItemFn
)
2096 V
: VisitMut
+ ?Sized
,
2098 for it
in &mut node
.attrs
{
2099 v
.visit_attribute_mut(it
);
2101 v
.visit_visibility_mut(&mut node
.vis
);
2102 v
.visit_signature_mut(&mut node
.sig
);
2103 skip
!(node
.semi_token
);
2105 #[cfg(feature = "full")]
2106 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2107 pub fn visit_foreign_item_macro_mut
<V
>(v
: &mut V
, node
: &mut ForeignItemMacro
)
2109 V
: VisitMut
+ ?Sized
,
2111 for it
in &mut node
.attrs
{
2112 v
.visit_attribute_mut(it
);
2114 v
.visit_macro_mut(&mut node
.mac
);
2115 skip
!(node
.semi_token
);
2117 #[cfg(feature = "full")]
2118 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2119 pub fn visit_foreign_item_static_mut
<V
>(v
: &mut V
, node
: &mut ForeignItemStatic
)
2121 V
: VisitMut
+ ?Sized
,
2123 for it
in &mut node
.attrs
{
2124 v
.visit_attribute_mut(it
);
2126 v
.visit_visibility_mut(&mut node
.vis
);
2127 skip
!(node
.static_token
);
2128 v
.visit_static_mutability_mut(&mut node
.mutability
);
2129 v
.visit_ident_mut(&mut node
.ident
);
2130 skip
!(node
.colon_token
);
2131 v
.visit_type_mut(&mut *node
.ty
);
2132 skip
!(node
.semi_token
);
2134 #[cfg(feature = "full")]
2135 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2136 pub fn visit_foreign_item_type_mut
<V
>(v
: &mut V
, node
: &mut ForeignItemType
)
2138 V
: VisitMut
+ ?Sized
,
2140 for it
in &mut node
.attrs
{
2141 v
.visit_attribute_mut(it
);
2143 v
.visit_visibility_mut(&mut node
.vis
);
2144 skip
!(node
.type_token
);
2145 v
.visit_ident_mut(&mut node
.ident
);
2146 v
.visit_generics_mut(&mut node
.generics
);
2147 skip
!(node
.semi_token
);
2149 #[cfg(any(feature = "derive", feature = "full"))]
2150 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
2151 pub fn visit_generic_argument_mut
<V
>(v
: &mut V
, node
: &mut GenericArgument
)
2153 V
: VisitMut
+ ?Sized
,
2156 GenericArgument
::Lifetime(_binding_0
) => {
2157 v
.visit_lifetime_mut(_binding_0
);
2159 GenericArgument
::Type(_binding_0
) => {
2160 v
.visit_type_mut(_binding_0
);
2162 GenericArgument
::Const(_binding_0
) => {
2163 v
.visit_expr_mut(_binding_0
);
2165 GenericArgument
::AssocType(_binding_0
) => {
2166 v
.visit_assoc_type_mut(_binding_0
);
2168 GenericArgument
::AssocConst(_binding_0
) => {
2169 v
.visit_assoc_const_mut(_binding_0
);
2171 GenericArgument
::Constraint(_binding_0
) => {
2172 v
.visit_constraint_mut(_binding_0
);
2176 #[cfg(any(feature = "derive", feature = "full"))]
2177 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
2178 pub fn visit_generic_param_mut
<V
>(v
: &mut V
, node
: &mut GenericParam
)
2180 V
: VisitMut
+ ?Sized
,
2183 GenericParam
::Lifetime(_binding_0
) => {
2184 v
.visit_lifetime_param_mut(_binding_0
);
2186 GenericParam
::Type(_binding_0
) => {
2187 v
.visit_type_param_mut(_binding_0
);
2189 GenericParam
::Const(_binding_0
) => {
2190 v
.visit_const_param_mut(_binding_0
);
2194 #[cfg(any(feature = "derive", feature = "full"))]
2195 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
2196 pub fn visit_generics_mut
<V
>(v
: &mut V
, node
: &mut Generics
)
2198 V
: VisitMut
+ ?Sized
,
2200 skip
!(node
.lt_token
);
2201 for mut el
in Punctuated
::pairs_mut(&mut node
.params
) {
2202 let it
= el
.value_mut();
2203 v
.visit_generic_param_mut(it
);
2205 skip
!(node
.gt_token
);
2206 if let Some(it
) = &mut node
.where_clause
{
2207 v
.visit_where_clause_mut(it
);
2210 pub fn visit_ident_mut
<V
>(v
: &mut V
, node
: &mut Ident
)
2212 V
: VisitMut
+ ?Sized
,
2214 let mut span
= node
.span();
2215 v
.visit_span_mut(&mut span
);
2216 node
.set_span(span
);
2218 #[cfg(feature = "full")]
2219 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2220 pub fn visit_impl_item_mut
<V
>(v
: &mut V
, node
: &mut ImplItem
)
2222 V
: VisitMut
+ ?Sized
,
2225 ImplItem
::Const(_binding_0
) => {
2226 v
.visit_impl_item_const_mut(_binding_0
);
2228 ImplItem
::Fn(_binding_0
) => {
2229 v
.visit_impl_item_fn_mut(_binding_0
);
2231 ImplItem
::Type(_binding_0
) => {
2232 v
.visit_impl_item_type_mut(_binding_0
);
2234 ImplItem
::Macro(_binding_0
) => {
2235 v
.visit_impl_item_macro_mut(_binding_0
);
2237 ImplItem
::Verbatim(_binding_0
) => {
2242 #[cfg(feature = "full")]
2243 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2244 pub fn visit_impl_item_const_mut
<V
>(v
: &mut V
, node
: &mut ImplItemConst
)
2246 V
: VisitMut
+ ?Sized
,
2248 for it
in &mut node
.attrs
{
2249 v
.visit_attribute_mut(it
);
2251 v
.visit_visibility_mut(&mut node
.vis
);
2252 skip
!(node
.defaultness
);
2253 skip
!(node
.const_token
);
2254 v
.visit_ident_mut(&mut node
.ident
);
2255 v
.visit_generics_mut(&mut node
.generics
);
2256 skip
!(node
.colon_token
);
2257 v
.visit_type_mut(&mut node
.ty
);
2258 skip
!(node
.eq_token
);
2259 v
.visit_expr_mut(&mut node
.expr
);
2260 skip
!(node
.semi_token
);
2262 #[cfg(feature = "full")]
2263 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2264 pub fn visit_impl_item_fn_mut
<V
>(v
: &mut V
, node
: &mut ImplItemFn
)
2266 V
: VisitMut
+ ?Sized
,
2268 for it
in &mut node
.attrs
{
2269 v
.visit_attribute_mut(it
);
2271 v
.visit_visibility_mut(&mut node
.vis
);
2272 skip
!(node
.defaultness
);
2273 v
.visit_signature_mut(&mut node
.sig
);
2274 v
.visit_block_mut(&mut node
.block
);
2276 #[cfg(feature = "full")]
2277 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2278 pub fn visit_impl_item_macro_mut
<V
>(v
: &mut V
, node
: &mut ImplItemMacro
)
2280 V
: VisitMut
+ ?Sized
,
2282 for it
in &mut node
.attrs
{
2283 v
.visit_attribute_mut(it
);
2285 v
.visit_macro_mut(&mut node
.mac
);
2286 skip
!(node
.semi_token
);
2288 #[cfg(feature = "full")]
2289 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2290 pub fn visit_impl_item_type_mut
<V
>(v
: &mut V
, node
: &mut ImplItemType
)
2292 V
: VisitMut
+ ?Sized
,
2294 for it
in &mut node
.attrs
{
2295 v
.visit_attribute_mut(it
);
2297 v
.visit_visibility_mut(&mut node
.vis
);
2298 skip
!(node
.defaultness
);
2299 skip
!(node
.type_token
);
2300 v
.visit_ident_mut(&mut node
.ident
);
2301 v
.visit_generics_mut(&mut node
.generics
);
2302 skip
!(node
.eq_token
);
2303 v
.visit_type_mut(&mut node
.ty
);
2304 skip
!(node
.semi_token
);
2306 #[cfg(feature = "full")]
2307 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2308 pub fn visit_impl_restriction_mut
<V
>(v
: &mut V
, node
: &mut ImplRestriction
)
2310 V
: VisitMut
+ ?Sized
,
2314 #[cfg(any(feature = "derive", feature = "full"))]
2315 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
2316 pub fn visit_index_mut
<V
>(v
: &mut V
, node
: &mut Index
)
2318 V
: VisitMut
+ ?Sized
,
2321 v
.visit_span_mut(&mut node
.span
);
2323 #[cfg(feature = "full")]
2324 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2325 pub fn visit_item_mut
<V
>(v
: &mut V
, node
: &mut Item
)
2327 V
: VisitMut
+ ?Sized
,
2330 Item
::Const(_binding_0
) => {
2331 v
.visit_item_const_mut(_binding_0
);
2333 Item
::Enum(_binding_0
) => {
2334 v
.visit_item_enum_mut(_binding_0
);
2336 Item
::ExternCrate(_binding_0
) => {
2337 v
.visit_item_extern_crate_mut(_binding_0
);
2339 Item
::Fn(_binding_0
) => {
2340 v
.visit_item_fn_mut(_binding_0
);
2342 Item
::ForeignMod(_binding_0
) => {
2343 v
.visit_item_foreign_mod_mut(_binding_0
);
2345 Item
::Impl(_binding_0
) => {
2346 v
.visit_item_impl_mut(_binding_0
);
2348 Item
::Macro(_binding_0
) => {
2349 v
.visit_item_macro_mut(_binding_0
);
2351 Item
::Mod(_binding_0
) => {
2352 v
.visit_item_mod_mut(_binding_0
);
2354 Item
::Static(_binding_0
) => {
2355 v
.visit_item_static_mut(_binding_0
);
2357 Item
::Struct(_binding_0
) => {
2358 v
.visit_item_struct_mut(_binding_0
);
2360 Item
::Trait(_binding_0
) => {
2361 v
.visit_item_trait_mut(_binding_0
);
2363 Item
::TraitAlias(_binding_0
) => {
2364 v
.visit_item_trait_alias_mut(_binding_0
);
2366 Item
::Type(_binding_0
) => {
2367 v
.visit_item_type_mut(_binding_0
);
2369 Item
::Union(_binding_0
) => {
2370 v
.visit_item_union_mut(_binding_0
);
2372 Item
::Use(_binding_0
) => {
2373 v
.visit_item_use_mut(_binding_0
);
2375 Item
::Verbatim(_binding_0
) => {
2380 #[cfg(feature = "full")]
2381 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2382 pub fn visit_item_const_mut
<V
>(v
: &mut V
, node
: &mut ItemConst
)
2384 V
: VisitMut
+ ?Sized
,
2386 for it
in &mut node
.attrs
{
2387 v
.visit_attribute_mut(it
);
2389 v
.visit_visibility_mut(&mut node
.vis
);
2390 skip
!(node
.const_token
);
2391 v
.visit_ident_mut(&mut node
.ident
);
2392 v
.visit_generics_mut(&mut node
.generics
);
2393 skip
!(node
.colon_token
);
2394 v
.visit_type_mut(&mut *node
.ty
);
2395 skip
!(node
.eq_token
);
2396 v
.visit_expr_mut(&mut *node
.expr
);
2397 skip
!(node
.semi_token
);
2399 #[cfg(feature = "full")]
2400 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2401 pub fn visit_item_enum_mut
<V
>(v
: &mut V
, node
: &mut ItemEnum
)
2403 V
: VisitMut
+ ?Sized
,
2405 for it
in &mut node
.attrs
{
2406 v
.visit_attribute_mut(it
);
2408 v
.visit_visibility_mut(&mut node
.vis
);
2409 skip
!(node
.enum_token
);
2410 v
.visit_ident_mut(&mut node
.ident
);
2411 v
.visit_generics_mut(&mut node
.generics
);
2412 skip
!(node
.brace_token
);
2413 for mut el
in Punctuated
::pairs_mut(&mut node
.variants
) {
2414 let it
= el
.value_mut();
2415 v
.visit_variant_mut(it
);
2418 #[cfg(feature = "full")]
2419 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2420 pub fn visit_item_extern_crate_mut
<V
>(v
: &mut V
, node
: &mut ItemExternCrate
)
2422 V
: VisitMut
+ ?Sized
,
2424 for it
in &mut node
.attrs
{
2425 v
.visit_attribute_mut(it
);
2427 v
.visit_visibility_mut(&mut node
.vis
);
2428 skip
!(node
.extern_token
);
2429 skip
!(node
.crate_token
);
2430 v
.visit_ident_mut(&mut node
.ident
);
2431 if let Some(it
) = &mut node
.rename
{
2433 v
.visit_ident_mut(&mut (it
).1);
2435 skip
!(node
.semi_token
);
2437 #[cfg(feature = "full")]
2438 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2439 pub fn visit_item_fn_mut
<V
>(v
: &mut V
, node
: &mut ItemFn
)
2441 V
: VisitMut
+ ?Sized
,
2443 for it
in &mut node
.attrs
{
2444 v
.visit_attribute_mut(it
);
2446 v
.visit_visibility_mut(&mut node
.vis
);
2447 v
.visit_signature_mut(&mut node
.sig
);
2448 v
.visit_block_mut(&mut *node
.block
);
2450 #[cfg(feature = "full")]
2451 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2452 pub fn visit_item_foreign_mod_mut
<V
>(v
: &mut V
, node
: &mut ItemForeignMod
)
2454 V
: VisitMut
+ ?Sized
,
2456 for it
in &mut node
.attrs
{
2457 v
.visit_attribute_mut(it
);
2459 skip
!(node
.unsafety
);
2460 v
.visit_abi_mut(&mut node
.abi
);
2461 skip
!(node
.brace_token
);
2462 for it
in &mut node
.items
{
2463 v
.visit_foreign_item_mut(it
);
2466 #[cfg(feature = "full")]
2467 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2468 pub fn visit_item_impl_mut
<V
>(v
: &mut V
, node
: &mut ItemImpl
)
2470 V
: VisitMut
+ ?Sized
,
2472 for it
in &mut node
.attrs
{
2473 v
.visit_attribute_mut(it
);
2475 skip
!(node
.defaultness
);
2476 skip
!(node
.unsafety
);
2477 skip
!(node
.impl_token
);
2478 v
.visit_generics_mut(&mut node
.generics
);
2479 if let Some(it
) = &mut node
.trait_
{
2481 v
.visit_path_mut(&mut (it
).1);
2484 v
.visit_type_mut(&mut *node
.self_ty
);
2485 skip
!(node
.brace_token
);
2486 for it
in &mut node
.items
{
2487 v
.visit_impl_item_mut(it
);
2490 #[cfg(feature = "full")]
2491 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2492 pub fn visit_item_macro_mut
<V
>(v
: &mut V
, node
: &mut ItemMacro
)
2494 V
: VisitMut
+ ?Sized
,
2496 for it
in &mut node
.attrs
{
2497 v
.visit_attribute_mut(it
);
2499 if let Some(it
) = &mut node
.ident
{
2500 v
.visit_ident_mut(it
);
2502 v
.visit_macro_mut(&mut node
.mac
);
2503 skip
!(node
.semi_token
);
2505 #[cfg(feature = "full")]
2506 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2507 pub fn visit_item_mod_mut
<V
>(v
: &mut V
, node
: &mut ItemMod
)
2509 V
: VisitMut
+ ?Sized
,
2511 for it
in &mut node
.attrs
{
2512 v
.visit_attribute_mut(it
);
2514 v
.visit_visibility_mut(&mut node
.vis
);
2515 skip
!(node
.unsafety
);
2516 skip
!(node
.mod_token
);
2517 v
.visit_ident_mut(&mut node
.ident
);
2518 if let Some(it
) = &mut node
.content
{
2520 for it
in &mut (it
).1 {
2521 v
.visit_item_mut(it
);
2526 #[cfg(feature = "full")]
2527 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2528 pub fn visit_item_static_mut
<V
>(v
: &mut V
, node
: &mut ItemStatic
)
2530 V
: VisitMut
+ ?Sized
,
2532 for it
in &mut node
.attrs
{
2533 v
.visit_attribute_mut(it
);
2535 v
.visit_visibility_mut(&mut node
.vis
);
2536 skip
!(node
.static_token
);
2537 v
.visit_static_mutability_mut(&mut node
.mutability
);
2538 v
.visit_ident_mut(&mut node
.ident
);
2539 skip
!(node
.colon_token
);
2540 v
.visit_type_mut(&mut *node
.ty
);
2541 skip
!(node
.eq_token
);
2542 v
.visit_expr_mut(&mut *node
.expr
);
2543 skip
!(node
.semi_token
);
2545 #[cfg(feature = "full")]
2546 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2547 pub fn visit_item_struct_mut
<V
>(v
: &mut V
, node
: &mut ItemStruct
)
2549 V
: VisitMut
+ ?Sized
,
2551 for it
in &mut node
.attrs
{
2552 v
.visit_attribute_mut(it
);
2554 v
.visit_visibility_mut(&mut node
.vis
);
2555 skip
!(node
.struct_token
);
2556 v
.visit_ident_mut(&mut node
.ident
);
2557 v
.visit_generics_mut(&mut node
.generics
);
2558 v
.visit_fields_mut(&mut node
.fields
);
2559 skip
!(node
.semi_token
);
2561 #[cfg(feature = "full")]
2562 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2563 pub fn visit_item_trait_mut
<V
>(v
: &mut V
, node
: &mut ItemTrait
)
2565 V
: VisitMut
+ ?Sized
,
2567 for it
in &mut node
.attrs
{
2568 v
.visit_attribute_mut(it
);
2570 v
.visit_visibility_mut(&mut node
.vis
);
2571 skip
!(node
.unsafety
);
2572 skip
!(node
.auto_token
);
2573 if let Some(it
) = &mut node
.restriction
{
2574 v
.visit_impl_restriction_mut(it
);
2576 skip
!(node
.trait_token
);
2577 v
.visit_ident_mut(&mut node
.ident
);
2578 v
.visit_generics_mut(&mut node
.generics
);
2579 skip
!(node
.colon_token
);
2580 for mut el
in Punctuated
::pairs_mut(&mut node
.supertraits
) {
2581 let it
= el
.value_mut();
2582 v
.visit_type_param_bound_mut(it
);
2584 skip
!(node
.brace_token
);
2585 for it
in &mut node
.items
{
2586 v
.visit_trait_item_mut(it
);
2589 #[cfg(feature = "full")]
2590 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2591 pub fn visit_item_trait_alias_mut
<V
>(v
: &mut V
, node
: &mut ItemTraitAlias
)
2593 V
: VisitMut
+ ?Sized
,
2595 for it
in &mut node
.attrs
{
2596 v
.visit_attribute_mut(it
);
2598 v
.visit_visibility_mut(&mut node
.vis
);
2599 skip
!(node
.trait_token
);
2600 v
.visit_ident_mut(&mut node
.ident
);
2601 v
.visit_generics_mut(&mut node
.generics
);
2602 skip
!(node
.eq_token
);
2603 for mut el
in Punctuated
::pairs_mut(&mut node
.bounds
) {
2604 let it
= el
.value_mut();
2605 v
.visit_type_param_bound_mut(it
);
2607 skip
!(node
.semi_token
);
2609 #[cfg(feature = "full")]
2610 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2611 pub fn visit_item_type_mut
<V
>(v
: &mut V
, node
: &mut ItemType
)
2613 V
: VisitMut
+ ?Sized
,
2615 for it
in &mut node
.attrs
{
2616 v
.visit_attribute_mut(it
);
2618 v
.visit_visibility_mut(&mut node
.vis
);
2619 skip
!(node
.type_token
);
2620 v
.visit_ident_mut(&mut node
.ident
);
2621 v
.visit_generics_mut(&mut node
.generics
);
2622 skip
!(node
.eq_token
);
2623 v
.visit_type_mut(&mut *node
.ty
);
2624 skip
!(node
.semi_token
);
2626 #[cfg(feature = "full")]
2627 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2628 pub fn visit_item_union_mut
<V
>(v
: &mut V
, node
: &mut ItemUnion
)
2630 V
: VisitMut
+ ?Sized
,
2632 for it
in &mut node
.attrs
{
2633 v
.visit_attribute_mut(it
);
2635 v
.visit_visibility_mut(&mut node
.vis
);
2636 skip
!(node
.union_token
);
2637 v
.visit_ident_mut(&mut node
.ident
);
2638 v
.visit_generics_mut(&mut node
.generics
);
2639 v
.visit_fields_named_mut(&mut node
.fields
);
2641 #[cfg(feature = "full")]
2642 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2643 pub fn visit_item_use_mut
<V
>(v
: &mut V
, node
: &mut ItemUse
)
2645 V
: VisitMut
+ ?Sized
,
2647 for it
in &mut node
.attrs
{
2648 v
.visit_attribute_mut(it
);
2650 v
.visit_visibility_mut(&mut node
.vis
);
2651 skip
!(node
.use_token
);
2652 skip
!(node
.leading_colon
);
2653 v
.visit_use_tree_mut(&mut node
.tree
);
2654 skip
!(node
.semi_token
);
2656 #[cfg(feature = "full")]
2657 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2658 pub fn visit_label_mut
<V
>(v
: &mut V
, node
: &mut Label
)
2660 V
: VisitMut
+ ?Sized
,
2662 v
.visit_lifetime_mut(&mut node
.name
);
2663 skip
!(node
.colon_token
);
2665 pub fn visit_lifetime_mut
<V
>(v
: &mut V
, node
: &mut Lifetime
)
2667 V
: VisitMut
+ ?Sized
,
2669 v
.visit_span_mut(&mut node
.apostrophe
);
2670 v
.visit_ident_mut(&mut node
.ident
);
2672 #[cfg(any(feature = "derive", feature = "full"))]
2673 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
2674 pub fn visit_lifetime_param_mut
<V
>(v
: &mut V
, node
: &mut LifetimeParam
)
2676 V
: VisitMut
+ ?Sized
,
2678 for it
in &mut node
.attrs
{
2679 v
.visit_attribute_mut(it
);
2681 v
.visit_lifetime_mut(&mut node
.lifetime
);
2682 skip
!(node
.colon_token
);
2683 for mut el
in Punctuated
::pairs_mut(&mut node
.bounds
) {
2684 let it
= el
.value_mut();
2685 v
.visit_lifetime_mut(it
);
2688 pub fn visit_lit_mut
<V
>(v
: &mut V
, node
: &mut Lit
)
2690 V
: VisitMut
+ ?Sized
,
2693 Lit
::Str(_binding_0
) => {
2694 v
.visit_lit_str_mut(_binding_0
);
2696 Lit
::ByteStr(_binding_0
) => {
2697 v
.visit_lit_byte_str_mut(_binding_0
);
2699 Lit
::Byte(_binding_0
) => {
2700 v
.visit_lit_byte_mut(_binding_0
);
2702 Lit
::Char(_binding_0
) => {
2703 v
.visit_lit_char_mut(_binding_0
);
2705 Lit
::Int(_binding_0
) => {
2706 v
.visit_lit_int_mut(_binding_0
);
2708 Lit
::Float(_binding_0
) => {
2709 v
.visit_lit_float_mut(_binding_0
);
2711 Lit
::Bool(_binding_0
) => {
2712 v
.visit_lit_bool_mut(_binding_0
);
2714 Lit
::Verbatim(_binding_0
) => {
2719 pub fn visit_lit_bool_mut
<V
>(v
: &mut V
, node
: &mut LitBool
)
2721 V
: VisitMut
+ ?Sized
,
2724 v
.visit_span_mut(&mut node
.span
);
2726 pub fn visit_lit_byte_mut
<V
>(v
: &mut V
, node
: &mut LitByte
)
2728 V
: VisitMut
+ ?Sized
,
2730 pub fn visit_lit_byte_str_mut
<V
>(v
: &mut V
, node
: &mut LitByteStr
)
2732 V
: VisitMut
+ ?Sized
,
2734 pub fn visit_lit_char_mut
<V
>(v
: &mut V
, node
: &mut LitChar
)
2736 V
: VisitMut
+ ?Sized
,
2738 pub fn visit_lit_float_mut
<V
>(v
: &mut V
, node
: &mut LitFloat
)
2740 V
: VisitMut
+ ?Sized
,
2742 pub fn visit_lit_int_mut
<V
>(v
: &mut V
, node
: &mut LitInt
)
2744 V
: VisitMut
+ ?Sized
,
2746 pub fn visit_lit_str_mut
<V
>(v
: &mut V
, node
: &mut LitStr
)
2748 V
: VisitMut
+ ?Sized
,
2750 #[cfg(feature = "full")]
2751 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2752 pub fn visit_local_mut
<V
>(v
: &mut V
, node
: &mut Local
)
2754 V
: VisitMut
+ ?Sized
,
2756 for it
in &mut node
.attrs
{
2757 v
.visit_attribute_mut(it
);
2759 skip
!(node
.let_token
);
2760 v
.visit_pat_mut(&mut node
.pat
);
2761 if let Some(it
) = &mut node
.init
{
2762 v
.visit_local_init_mut(it
);
2764 skip
!(node
.semi_token
);
2766 #[cfg(feature = "full")]
2767 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2768 pub fn visit_local_init_mut
<V
>(v
: &mut V
, node
: &mut LocalInit
)
2770 V
: VisitMut
+ ?Sized
,
2772 skip
!(node
.eq_token
);
2773 v
.visit_expr_mut(&mut *node
.expr
);
2774 if let Some(it
) = &mut node
.diverge
{
2776 v
.visit_expr_mut(&mut *(it
).1);
2779 #[cfg(any(feature = "derive", feature = "full"))]
2780 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
2781 pub fn visit_macro_mut
<V
>(v
: &mut V
, node
: &mut Macro
)
2783 V
: VisitMut
+ ?Sized
,
2785 v
.visit_path_mut(&mut node
.path
);
2786 skip
!(node
.bang_token
);
2787 v
.visit_macro_delimiter_mut(&mut node
.delimiter
);
2790 #[cfg(any(feature = "derive", feature = "full"))]
2791 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
2792 pub fn visit_macro_delimiter_mut
<V
>(v
: &mut V
, node
: &mut MacroDelimiter
)
2794 V
: VisitMut
+ ?Sized
,
2797 MacroDelimiter
::Paren(_binding_0
) => {
2800 MacroDelimiter
::Brace(_binding_0
) => {
2803 MacroDelimiter
::Bracket(_binding_0
) => {
2808 #[cfg(any(feature = "derive", feature = "full"))]
2809 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
2810 pub fn visit_member_mut
<V
>(v
: &mut V
, node
: &mut Member
)
2812 V
: VisitMut
+ ?Sized
,
2815 Member
::Named(_binding_0
) => {
2816 v
.visit_ident_mut(_binding_0
);
2818 Member
::Unnamed(_binding_0
) => {
2819 v
.visit_index_mut(_binding_0
);
2823 #[cfg(any(feature = "derive", feature = "full"))]
2824 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
2825 pub fn visit_meta_mut
<V
>(v
: &mut V
, node
: &mut Meta
)
2827 V
: VisitMut
+ ?Sized
,
2830 Meta
::Path(_binding_0
) => {
2831 v
.visit_path_mut(_binding_0
);
2833 Meta
::List(_binding_0
) => {
2834 v
.visit_meta_list_mut(_binding_0
);
2836 Meta
::NameValue(_binding_0
) => {
2837 v
.visit_meta_name_value_mut(_binding_0
);
2841 #[cfg(any(feature = "derive", feature = "full"))]
2842 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
2843 pub fn visit_meta_list_mut
<V
>(v
: &mut V
, node
: &mut MetaList
)
2845 V
: VisitMut
+ ?Sized
,
2847 v
.visit_path_mut(&mut node
.path
);
2848 v
.visit_macro_delimiter_mut(&mut node
.delimiter
);
2851 #[cfg(any(feature = "derive", feature = "full"))]
2852 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
2853 pub fn visit_meta_name_value_mut
<V
>(v
: &mut V
, node
: &mut MetaNameValue
)
2855 V
: VisitMut
+ ?Sized
,
2857 v
.visit_path_mut(&mut node
.path
);
2858 skip
!(node
.eq_token
);
2859 v
.visit_expr_mut(&mut node
.value
);
2861 #[cfg(any(feature = "derive", feature = "full"))]
2862 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
2863 pub fn visit_parenthesized_generic_arguments_mut
<V
>(
2865 node
: &mut ParenthesizedGenericArguments
,
2868 V
: VisitMut
+ ?Sized
,
2870 skip
!(node
.paren_token
);
2871 for mut el
in Punctuated
::pairs_mut(&mut node
.inputs
) {
2872 let it
= el
.value_mut();
2873 v
.visit_type_mut(it
);
2875 v
.visit_return_type_mut(&mut node
.output
);
2877 #[cfg(feature = "full")]
2878 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2879 pub fn visit_pat_mut
<V
>(v
: &mut V
, node
: &mut Pat
)
2881 V
: VisitMut
+ ?Sized
,
2884 Pat
::Const(_binding_0
) => {
2885 v
.visit_expr_const_mut(_binding_0
);
2887 Pat
::Ident(_binding_0
) => {
2888 v
.visit_pat_ident_mut(_binding_0
);
2890 Pat
::Lit(_binding_0
) => {
2891 v
.visit_expr_lit_mut(_binding_0
);
2893 Pat
::Macro(_binding_0
) => {
2894 v
.visit_expr_macro_mut(_binding_0
);
2896 Pat
::Or(_binding_0
) => {
2897 v
.visit_pat_or_mut(_binding_0
);
2899 Pat
::Paren(_binding_0
) => {
2900 v
.visit_pat_paren_mut(_binding_0
);
2902 Pat
::Path(_binding_0
) => {
2903 v
.visit_expr_path_mut(_binding_0
);
2905 Pat
::Range(_binding_0
) => {
2906 v
.visit_expr_range_mut(_binding_0
);
2908 Pat
::Reference(_binding_0
) => {
2909 v
.visit_pat_reference_mut(_binding_0
);
2911 Pat
::Rest(_binding_0
) => {
2912 v
.visit_pat_rest_mut(_binding_0
);
2914 Pat
::Slice(_binding_0
) => {
2915 v
.visit_pat_slice_mut(_binding_0
);
2917 Pat
::Struct(_binding_0
) => {
2918 v
.visit_pat_struct_mut(_binding_0
);
2920 Pat
::Tuple(_binding_0
) => {
2921 v
.visit_pat_tuple_mut(_binding_0
);
2923 Pat
::TupleStruct(_binding_0
) => {
2924 v
.visit_pat_tuple_struct_mut(_binding_0
);
2926 Pat
::Type(_binding_0
) => {
2927 v
.visit_pat_type_mut(_binding_0
);
2929 Pat
::Verbatim(_binding_0
) => {
2932 Pat
::Wild(_binding_0
) => {
2933 v
.visit_pat_wild_mut(_binding_0
);
2937 #[cfg(feature = "full")]
2938 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2939 pub fn visit_pat_ident_mut
<V
>(v
: &mut V
, node
: &mut PatIdent
)
2941 V
: VisitMut
+ ?Sized
,
2943 for it
in &mut node
.attrs
{
2944 v
.visit_attribute_mut(it
);
2947 skip
!(node
.mutability
);
2948 v
.visit_ident_mut(&mut node
.ident
);
2949 if let Some(it
) = &mut node
.subpat
{
2951 v
.visit_pat_mut(&mut *(it
).1);
2954 #[cfg(feature = "full")]
2955 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2956 pub fn visit_pat_or_mut
<V
>(v
: &mut V
, node
: &mut PatOr
)
2958 V
: VisitMut
+ ?Sized
,
2960 for it
in &mut node
.attrs
{
2961 v
.visit_attribute_mut(it
);
2963 skip
!(node
.leading_vert
);
2964 for mut el
in Punctuated
::pairs_mut(&mut node
.cases
) {
2965 let it
= el
.value_mut();
2966 v
.visit_pat_mut(it
);
2969 #[cfg(feature = "full")]
2970 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2971 pub fn visit_pat_paren_mut
<V
>(v
: &mut V
, node
: &mut PatParen
)
2973 V
: VisitMut
+ ?Sized
,
2975 for it
in &mut node
.attrs
{
2976 v
.visit_attribute_mut(it
);
2978 skip
!(node
.paren_token
);
2979 v
.visit_pat_mut(&mut *node
.pat
);
2981 #[cfg(feature = "full")]
2982 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2983 pub fn visit_pat_reference_mut
<V
>(v
: &mut V
, node
: &mut PatReference
)
2985 V
: VisitMut
+ ?Sized
,
2987 for it
in &mut node
.attrs
{
2988 v
.visit_attribute_mut(it
);
2990 skip
!(node
.and_token
);
2991 skip
!(node
.mutability
);
2992 v
.visit_pat_mut(&mut *node
.pat
);
2994 #[cfg(feature = "full")]
2995 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
2996 pub fn visit_pat_rest_mut
<V
>(v
: &mut V
, node
: &mut PatRest
)
2998 V
: VisitMut
+ ?Sized
,
3000 for it
in &mut node
.attrs
{
3001 v
.visit_attribute_mut(it
);
3003 skip
!(node
.dot2_token
);
3005 #[cfg(feature = "full")]
3006 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
3007 pub fn visit_pat_slice_mut
<V
>(v
: &mut V
, node
: &mut PatSlice
)
3009 V
: VisitMut
+ ?Sized
,
3011 for it
in &mut node
.attrs
{
3012 v
.visit_attribute_mut(it
);
3014 skip
!(node
.bracket_token
);
3015 for mut el
in Punctuated
::pairs_mut(&mut node
.elems
) {
3016 let it
= el
.value_mut();
3017 v
.visit_pat_mut(it
);
3020 #[cfg(feature = "full")]
3021 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
3022 pub fn visit_pat_struct_mut
<V
>(v
: &mut V
, node
: &mut PatStruct
)
3024 V
: VisitMut
+ ?Sized
,
3026 for it
in &mut node
.attrs
{
3027 v
.visit_attribute_mut(it
);
3029 if let Some(it
) = &mut node
.qself
{
3030 v
.visit_qself_mut(it
);
3032 v
.visit_path_mut(&mut node
.path
);
3033 skip
!(node
.brace_token
);
3034 for mut el
in Punctuated
::pairs_mut(&mut node
.fields
) {
3035 let it
= el
.value_mut();
3036 v
.visit_field_pat_mut(it
);
3038 if let Some(it
) = &mut node
.rest
{
3039 v
.visit_pat_rest_mut(it
);
3042 #[cfg(feature = "full")]
3043 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
3044 pub fn visit_pat_tuple_mut
<V
>(v
: &mut V
, node
: &mut PatTuple
)
3046 V
: VisitMut
+ ?Sized
,
3048 for it
in &mut node
.attrs
{
3049 v
.visit_attribute_mut(it
);
3051 skip
!(node
.paren_token
);
3052 for mut el
in Punctuated
::pairs_mut(&mut node
.elems
) {
3053 let it
= el
.value_mut();
3054 v
.visit_pat_mut(it
);
3057 #[cfg(feature = "full")]
3058 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
3059 pub fn visit_pat_tuple_struct_mut
<V
>(v
: &mut V
, node
: &mut PatTupleStruct
)
3061 V
: VisitMut
+ ?Sized
,
3063 for it
in &mut node
.attrs
{
3064 v
.visit_attribute_mut(it
);
3066 if let Some(it
) = &mut node
.qself
{
3067 v
.visit_qself_mut(it
);
3069 v
.visit_path_mut(&mut node
.path
);
3070 skip
!(node
.paren_token
);
3071 for mut el
in Punctuated
::pairs_mut(&mut node
.elems
) {
3072 let it
= el
.value_mut();
3073 v
.visit_pat_mut(it
);
3076 #[cfg(feature = "full")]
3077 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
3078 pub fn visit_pat_type_mut
<V
>(v
: &mut V
, node
: &mut PatType
)
3080 V
: VisitMut
+ ?Sized
,
3082 for it
in &mut node
.attrs
{
3083 v
.visit_attribute_mut(it
);
3085 v
.visit_pat_mut(&mut *node
.pat
);
3086 skip
!(node
.colon_token
);
3087 v
.visit_type_mut(&mut *node
.ty
);
3089 #[cfg(feature = "full")]
3090 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
3091 pub fn visit_pat_wild_mut
<V
>(v
: &mut V
, node
: &mut PatWild
)
3093 V
: VisitMut
+ ?Sized
,
3095 for it
in &mut node
.attrs
{
3096 v
.visit_attribute_mut(it
);
3098 skip
!(node
.underscore_token
);
3100 #[cfg(any(feature = "derive", feature = "full"))]
3101 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
3102 pub fn visit_path_mut
<V
>(v
: &mut V
, node
: &mut Path
)
3104 V
: VisitMut
+ ?Sized
,
3106 skip
!(node
.leading_colon
);
3107 for mut el
in Punctuated
::pairs_mut(&mut node
.segments
) {
3108 let it
= el
.value_mut();
3109 v
.visit_path_segment_mut(it
);
3112 #[cfg(any(feature = "derive", feature = "full"))]
3113 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
3114 pub fn visit_path_arguments_mut
<V
>(v
: &mut V
, node
: &mut PathArguments
)
3116 V
: VisitMut
+ ?Sized
,
3119 PathArguments
::None
=> {}
3120 PathArguments
::AngleBracketed(_binding_0
) => {
3121 v
.visit_angle_bracketed_generic_arguments_mut(_binding_0
);
3123 PathArguments
::Parenthesized(_binding_0
) => {
3124 v
.visit_parenthesized_generic_arguments_mut(_binding_0
);
3128 #[cfg(any(feature = "derive", feature = "full"))]
3129 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
3130 pub fn visit_path_segment_mut
<V
>(v
: &mut V
, node
: &mut PathSegment
)
3132 V
: VisitMut
+ ?Sized
,
3134 v
.visit_ident_mut(&mut node
.ident
);
3135 v
.visit_path_arguments_mut(&mut node
.arguments
);
3137 #[cfg(any(feature = "derive", feature = "full"))]
3138 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
3139 pub fn visit_predicate_lifetime_mut
<V
>(v
: &mut V
, node
: &mut PredicateLifetime
)
3141 V
: VisitMut
+ ?Sized
,
3143 v
.visit_lifetime_mut(&mut node
.lifetime
);
3144 skip
!(node
.colon_token
);
3145 for mut el
in Punctuated
::pairs_mut(&mut node
.bounds
) {
3146 let it
= el
.value_mut();
3147 v
.visit_lifetime_mut(it
);
3150 #[cfg(any(feature = "derive", feature = "full"))]
3151 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
3152 pub fn visit_predicate_type_mut
<V
>(v
: &mut V
, node
: &mut PredicateType
)
3154 V
: VisitMut
+ ?Sized
,
3156 if let Some(it
) = &mut node
.lifetimes
{
3157 v
.visit_bound_lifetimes_mut(it
);
3159 v
.visit_type_mut(&mut node
.bounded_ty
);
3160 skip
!(node
.colon_token
);
3161 for mut el
in Punctuated
::pairs_mut(&mut node
.bounds
) {
3162 let it
= el
.value_mut();
3163 v
.visit_type_param_bound_mut(it
);
3166 #[cfg(any(feature = "derive", feature = "full"))]
3167 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
3168 pub fn visit_qself_mut
<V
>(v
: &mut V
, node
: &mut QSelf
)
3170 V
: VisitMut
+ ?Sized
,
3172 skip
!(node
.lt_token
);
3173 v
.visit_type_mut(&mut *node
.ty
);
3174 skip
!(node
.position
);
3175 skip
!(node
.as_token
);
3176 skip
!(node
.gt_token
);
3178 #[cfg(feature = "full")]
3179 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
3180 pub fn visit_range_limits_mut
<V
>(v
: &mut V
, node
: &mut RangeLimits
)
3182 V
: VisitMut
+ ?Sized
,
3185 RangeLimits
::HalfOpen(_binding_0
) => {
3188 RangeLimits
::Closed(_binding_0
) => {
3193 #[cfg(feature = "full")]
3194 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
3195 pub fn visit_receiver_mut
<V
>(v
: &mut V
, node
: &mut Receiver
)
3197 V
: VisitMut
+ ?Sized
,
3199 for it
in &mut node
.attrs
{
3200 v
.visit_attribute_mut(it
);
3202 if let Some(it
) = &mut node
.reference
{
3204 if let Some(it
) = &mut (it
).1 {
3205 v
.visit_lifetime_mut(it
);
3208 skip
!(node
.mutability
);
3209 skip
!(node
.self_token
);
3210 skip
!(node
.colon_token
);
3211 v
.visit_type_mut(&mut *node
.ty
);
3213 #[cfg(any(feature = "derive", feature = "full"))]
3214 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
3215 pub fn visit_return_type_mut
<V
>(v
: &mut V
, node
: &mut ReturnType
)
3217 V
: VisitMut
+ ?Sized
,
3220 ReturnType
::Default
=> {}
3221 ReturnType
::Type(_binding_0
, _binding_1
) => {
3223 v
.visit_type_mut(&mut **_binding_1
);
3227 #[cfg(feature = "full")]
3228 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
3229 pub fn visit_signature_mut
<V
>(v
: &mut V
, node
: &mut Signature
)
3231 V
: VisitMut
+ ?Sized
,
3233 skip
!(node
.constness
);
3234 skip
!(node
.asyncness
);
3235 skip
!(node
.unsafety
);
3236 if let Some(it
) = &mut node
.abi
{
3237 v
.visit_abi_mut(it
);
3239 skip
!(node
.fn_token
);
3240 v
.visit_ident_mut(&mut node
.ident
);
3241 v
.visit_generics_mut(&mut node
.generics
);
3242 skip
!(node
.paren_token
);
3243 for mut el
in Punctuated
::pairs_mut(&mut node
.inputs
) {
3244 let it
= el
.value_mut();
3245 v
.visit_fn_arg_mut(it
);
3247 if let Some(it
) = &mut node
.variadic
{
3248 v
.visit_variadic_mut(it
);
3250 v
.visit_return_type_mut(&mut node
.output
);
3252 pub fn visit_span_mut
<V
>(v
: &mut V
, node
: &mut Span
)
3254 V
: VisitMut
+ ?Sized
,
3256 #[cfg(feature = "full")]
3257 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
3258 pub fn visit_static_mutability_mut
<V
>(v
: &mut V
, node
: &mut StaticMutability
)
3260 V
: VisitMut
+ ?Sized
,
3263 StaticMutability
::Mut(_binding_0
) => {
3266 StaticMutability
::None
=> {}
3269 #[cfg(feature = "full")]
3270 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
3271 pub fn visit_stmt_mut
<V
>(v
: &mut V
, node
: &mut Stmt
)
3273 V
: VisitMut
+ ?Sized
,
3276 Stmt
::Local(_binding_0
) => {
3277 v
.visit_local_mut(_binding_0
);
3279 Stmt
::Item(_binding_0
) => {
3280 v
.visit_item_mut(_binding_0
);
3282 Stmt
::Expr(_binding_0
, _binding_1
) => {
3283 v
.visit_expr_mut(_binding_0
);
3286 Stmt
::Macro(_binding_0
) => {
3287 v
.visit_stmt_macro_mut(_binding_0
);
3291 #[cfg(feature = "full")]
3292 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
3293 pub fn visit_stmt_macro_mut
<V
>(v
: &mut V
, node
: &mut StmtMacro
)
3295 V
: VisitMut
+ ?Sized
,
3297 for it
in &mut node
.attrs
{
3298 v
.visit_attribute_mut(it
);
3300 v
.visit_macro_mut(&mut node
.mac
);
3301 skip
!(node
.semi_token
);
3303 #[cfg(any(feature = "derive", feature = "full"))]
3304 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
3305 pub fn visit_trait_bound_mut
<V
>(v
: &mut V
, node
: &mut TraitBound
)
3307 V
: VisitMut
+ ?Sized
,
3309 skip
!(node
.paren_token
);
3310 v
.visit_trait_bound_modifier_mut(&mut node
.modifier
);
3311 if let Some(it
) = &mut node
.lifetimes
{
3312 v
.visit_bound_lifetimes_mut(it
);
3314 v
.visit_path_mut(&mut node
.path
);
3316 #[cfg(any(feature = "derive", feature = "full"))]
3317 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
3318 pub fn visit_trait_bound_modifier_mut
<V
>(v
: &mut V
, node
: &mut TraitBoundModifier
)
3320 V
: VisitMut
+ ?Sized
,
3323 TraitBoundModifier
::None
=> {}
3324 TraitBoundModifier
::Maybe(_binding_0
) => {
3329 #[cfg(feature = "full")]
3330 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
3331 pub fn visit_trait_item_mut
<V
>(v
: &mut V
, node
: &mut TraitItem
)
3333 V
: VisitMut
+ ?Sized
,
3336 TraitItem
::Const(_binding_0
) => {
3337 v
.visit_trait_item_const_mut(_binding_0
);
3339 TraitItem
::Fn(_binding_0
) => {
3340 v
.visit_trait_item_fn_mut(_binding_0
);
3342 TraitItem
::Type(_binding_0
) => {
3343 v
.visit_trait_item_type_mut(_binding_0
);
3345 TraitItem
::Macro(_binding_0
) => {
3346 v
.visit_trait_item_macro_mut(_binding_0
);
3348 TraitItem
::Verbatim(_binding_0
) => {
3353 #[cfg(feature = "full")]
3354 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
3355 pub fn visit_trait_item_const_mut
<V
>(v
: &mut V
, node
: &mut TraitItemConst
)
3357 V
: VisitMut
+ ?Sized
,
3359 for it
in &mut node
.attrs
{
3360 v
.visit_attribute_mut(it
);
3362 skip
!(node
.const_token
);
3363 v
.visit_ident_mut(&mut node
.ident
);
3364 v
.visit_generics_mut(&mut node
.generics
);
3365 skip
!(node
.colon_token
);
3366 v
.visit_type_mut(&mut node
.ty
);
3367 if let Some(it
) = &mut node
.default {
3369 v
.visit_expr_mut(&mut (it
).1);
3371 skip
!(node
.semi_token
);
3373 #[cfg(feature = "full")]
3374 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
3375 pub fn visit_trait_item_fn_mut
<V
>(v
: &mut V
, node
: &mut TraitItemFn
)
3377 V
: VisitMut
+ ?Sized
,
3379 for it
in &mut node
.attrs
{
3380 v
.visit_attribute_mut(it
);
3382 v
.visit_signature_mut(&mut node
.sig
);
3383 if let Some(it
) = &mut node
.default {
3384 v
.visit_block_mut(it
);
3386 skip
!(node
.semi_token
);
3388 #[cfg(feature = "full")]
3389 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
3390 pub fn visit_trait_item_macro_mut
<V
>(v
: &mut V
, node
: &mut TraitItemMacro
)
3392 V
: VisitMut
+ ?Sized
,
3394 for it
in &mut node
.attrs
{
3395 v
.visit_attribute_mut(it
);
3397 v
.visit_macro_mut(&mut node
.mac
);
3398 skip
!(node
.semi_token
);
3400 #[cfg(feature = "full")]
3401 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
3402 pub fn visit_trait_item_type_mut
<V
>(v
: &mut V
, node
: &mut TraitItemType
)
3404 V
: VisitMut
+ ?Sized
,
3406 for it
in &mut node
.attrs
{
3407 v
.visit_attribute_mut(it
);
3409 skip
!(node
.type_token
);
3410 v
.visit_ident_mut(&mut node
.ident
);
3411 v
.visit_generics_mut(&mut node
.generics
);
3412 skip
!(node
.colon_token
);
3413 for mut el
in Punctuated
::pairs_mut(&mut node
.bounds
) {
3414 let it
= el
.value_mut();
3415 v
.visit_type_param_bound_mut(it
);
3417 if let Some(it
) = &mut node
.default {
3419 v
.visit_type_mut(&mut (it
).1);
3421 skip
!(node
.semi_token
);
3423 #[cfg(any(feature = "derive", feature = "full"))]
3424 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
3425 pub fn visit_type_mut
<V
>(v
: &mut V
, node
: &mut Type
)
3427 V
: VisitMut
+ ?Sized
,
3430 Type
::Array(_binding_0
) => {
3431 v
.visit_type_array_mut(_binding_0
);
3433 Type
::BareFn(_binding_0
) => {
3434 v
.visit_type_bare_fn_mut(_binding_0
);
3436 Type
::Group(_binding_0
) => {
3437 v
.visit_type_group_mut(_binding_0
);
3439 Type
::ImplTrait(_binding_0
) => {
3440 v
.visit_type_impl_trait_mut(_binding_0
);
3442 Type
::Infer(_binding_0
) => {
3443 v
.visit_type_infer_mut(_binding_0
);
3445 Type
::Macro(_binding_0
) => {
3446 v
.visit_type_macro_mut(_binding_0
);
3448 Type
::Never(_binding_0
) => {
3449 v
.visit_type_never_mut(_binding_0
);
3451 Type
::Paren(_binding_0
) => {
3452 v
.visit_type_paren_mut(_binding_0
);
3454 Type
::Path(_binding_0
) => {
3455 v
.visit_type_path_mut(_binding_0
);
3457 Type
::Ptr(_binding_0
) => {
3458 v
.visit_type_ptr_mut(_binding_0
);
3460 Type
::Reference(_binding_0
) => {
3461 v
.visit_type_reference_mut(_binding_0
);
3463 Type
::Slice(_binding_0
) => {
3464 v
.visit_type_slice_mut(_binding_0
);
3466 Type
::TraitObject(_binding_0
) => {
3467 v
.visit_type_trait_object_mut(_binding_0
);
3469 Type
::Tuple(_binding_0
) => {
3470 v
.visit_type_tuple_mut(_binding_0
);
3472 Type
::Verbatim(_binding_0
) => {
3477 #[cfg(any(feature = "derive", feature = "full"))]
3478 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
3479 pub fn visit_type_array_mut
<V
>(v
: &mut V
, node
: &mut TypeArray
)
3481 V
: VisitMut
+ ?Sized
,
3483 skip
!(node
.bracket_token
);
3484 v
.visit_type_mut(&mut *node
.elem
);
3485 skip
!(node
.semi_token
);
3486 v
.visit_expr_mut(&mut node
.len
);
3488 #[cfg(any(feature = "derive", feature = "full"))]
3489 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
3490 pub fn visit_type_bare_fn_mut
<V
>(v
: &mut V
, node
: &mut TypeBareFn
)
3492 V
: VisitMut
+ ?Sized
,
3494 if let Some(it
) = &mut node
.lifetimes
{
3495 v
.visit_bound_lifetimes_mut(it
);
3497 skip
!(node
.unsafety
);
3498 if let Some(it
) = &mut node
.abi
{
3499 v
.visit_abi_mut(it
);
3501 skip
!(node
.fn_token
);
3502 skip
!(node
.paren_token
);
3503 for mut el
in Punctuated
::pairs_mut(&mut node
.inputs
) {
3504 let it
= el
.value_mut();
3505 v
.visit_bare_fn_arg_mut(it
);
3507 if let Some(it
) = &mut node
.variadic
{
3508 v
.visit_bare_variadic_mut(it
);
3510 v
.visit_return_type_mut(&mut node
.output
);
3512 #[cfg(any(feature = "derive", feature = "full"))]
3513 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
3514 pub fn visit_type_group_mut
<V
>(v
: &mut V
, node
: &mut TypeGroup
)
3516 V
: VisitMut
+ ?Sized
,
3518 skip
!(node
.group_token
);
3519 v
.visit_type_mut(&mut *node
.elem
);
3521 #[cfg(any(feature = "derive", feature = "full"))]
3522 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
3523 pub fn visit_type_impl_trait_mut
<V
>(v
: &mut V
, node
: &mut TypeImplTrait
)
3525 V
: VisitMut
+ ?Sized
,
3527 skip
!(node
.impl_token
);
3528 for mut el
in Punctuated
::pairs_mut(&mut node
.bounds
) {
3529 let it
= el
.value_mut();
3530 v
.visit_type_param_bound_mut(it
);
3533 #[cfg(any(feature = "derive", feature = "full"))]
3534 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
3535 pub fn visit_type_infer_mut
<V
>(v
: &mut V
, node
: &mut TypeInfer
)
3537 V
: VisitMut
+ ?Sized
,
3539 skip
!(node
.underscore_token
);
3541 #[cfg(any(feature = "derive", feature = "full"))]
3542 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
3543 pub fn visit_type_macro_mut
<V
>(v
: &mut V
, node
: &mut TypeMacro
)
3545 V
: VisitMut
+ ?Sized
,
3547 v
.visit_macro_mut(&mut node
.mac
);
3549 #[cfg(any(feature = "derive", feature = "full"))]
3550 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
3551 pub fn visit_type_never_mut
<V
>(v
: &mut V
, node
: &mut TypeNever
)
3553 V
: VisitMut
+ ?Sized
,
3555 skip
!(node
.bang_token
);
3557 #[cfg(any(feature = "derive", feature = "full"))]
3558 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
3559 pub fn visit_type_param_mut
<V
>(v
: &mut V
, node
: &mut TypeParam
)
3561 V
: VisitMut
+ ?Sized
,
3563 for it
in &mut node
.attrs
{
3564 v
.visit_attribute_mut(it
);
3566 v
.visit_ident_mut(&mut node
.ident
);
3567 skip
!(node
.colon_token
);
3568 for mut el
in Punctuated
::pairs_mut(&mut node
.bounds
) {
3569 let it
= el
.value_mut();
3570 v
.visit_type_param_bound_mut(it
);
3572 skip
!(node
.eq_token
);
3573 if let Some(it
) = &mut node
.default {
3574 v
.visit_type_mut(it
);
3577 #[cfg(any(feature = "derive", feature = "full"))]
3578 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
3579 pub fn visit_type_param_bound_mut
<V
>(v
: &mut V
, node
: &mut TypeParamBound
)
3581 V
: VisitMut
+ ?Sized
,
3584 TypeParamBound
::Trait(_binding_0
) => {
3585 v
.visit_trait_bound_mut(_binding_0
);
3587 TypeParamBound
::Lifetime(_binding_0
) => {
3588 v
.visit_lifetime_mut(_binding_0
);
3590 TypeParamBound
::Verbatim(_binding_0
) => {
3595 #[cfg(any(feature = "derive", feature = "full"))]
3596 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
3597 pub fn visit_type_paren_mut
<V
>(v
: &mut V
, node
: &mut TypeParen
)
3599 V
: VisitMut
+ ?Sized
,
3601 skip
!(node
.paren_token
);
3602 v
.visit_type_mut(&mut *node
.elem
);
3604 #[cfg(any(feature = "derive", feature = "full"))]
3605 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
3606 pub fn visit_type_path_mut
<V
>(v
: &mut V
, node
: &mut TypePath
)
3608 V
: VisitMut
+ ?Sized
,
3610 if let Some(it
) = &mut node
.qself
{
3611 v
.visit_qself_mut(it
);
3613 v
.visit_path_mut(&mut node
.path
);
3615 #[cfg(any(feature = "derive", feature = "full"))]
3616 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
3617 pub fn visit_type_ptr_mut
<V
>(v
: &mut V
, node
: &mut TypePtr
)
3619 V
: VisitMut
+ ?Sized
,
3621 skip
!(node
.star_token
);
3622 skip
!(node
.const_token
);
3623 skip
!(node
.mutability
);
3624 v
.visit_type_mut(&mut *node
.elem
);
3626 #[cfg(any(feature = "derive", feature = "full"))]
3627 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
3628 pub fn visit_type_reference_mut
<V
>(v
: &mut V
, node
: &mut TypeReference
)
3630 V
: VisitMut
+ ?Sized
,
3632 skip
!(node
.and_token
);
3633 if let Some(it
) = &mut node
.lifetime
{
3634 v
.visit_lifetime_mut(it
);
3636 skip
!(node
.mutability
);
3637 v
.visit_type_mut(&mut *node
.elem
);
3639 #[cfg(any(feature = "derive", feature = "full"))]
3640 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
3641 pub fn visit_type_slice_mut
<V
>(v
: &mut V
, node
: &mut TypeSlice
)
3643 V
: VisitMut
+ ?Sized
,
3645 skip
!(node
.bracket_token
);
3646 v
.visit_type_mut(&mut *node
.elem
);
3648 #[cfg(any(feature = "derive", feature = "full"))]
3649 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
3650 pub fn visit_type_trait_object_mut
<V
>(v
: &mut V
, node
: &mut TypeTraitObject
)
3652 V
: VisitMut
+ ?Sized
,
3654 skip
!(node
.dyn_token
);
3655 for mut el
in Punctuated
::pairs_mut(&mut node
.bounds
) {
3656 let it
= el
.value_mut();
3657 v
.visit_type_param_bound_mut(it
);
3660 #[cfg(any(feature = "derive", feature = "full"))]
3661 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
3662 pub fn visit_type_tuple_mut
<V
>(v
: &mut V
, node
: &mut TypeTuple
)
3664 V
: VisitMut
+ ?Sized
,
3666 skip
!(node
.paren_token
);
3667 for mut el
in Punctuated
::pairs_mut(&mut node
.elems
) {
3668 let it
= el
.value_mut();
3669 v
.visit_type_mut(it
);
3672 #[cfg(any(feature = "derive", feature = "full"))]
3673 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
3674 pub fn visit_un_op_mut
<V
>(v
: &mut V
, node
: &mut UnOp
)
3676 V
: VisitMut
+ ?Sized
,
3679 UnOp
::Deref(_binding_0
) => {
3682 UnOp
::Not(_binding_0
) => {
3685 UnOp
::Neg(_binding_0
) => {
3690 #[cfg(feature = "full")]
3691 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
3692 pub fn visit_use_glob_mut
<V
>(v
: &mut V
, node
: &mut UseGlob
)
3694 V
: VisitMut
+ ?Sized
,
3696 skip
!(node
.star_token
);
3698 #[cfg(feature = "full")]
3699 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
3700 pub fn visit_use_group_mut
<V
>(v
: &mut V
, node
: &mut UseGroup
)
3702 V
: VisitMut
+ ?Sized
,
3704 skip
!(node
.brace_token
);
3705 for mut el
in Punctuated
::pairs_mut(&mut node
.items
) {
3706 let it
= el
.value_mut();
3707 v
.visit_use_tree_mut(it
);
3710 #[cfg(feature = "full")]
3711 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
3712 pub fn visit_use_name_mut
<V
>(v
: &mut V
, node
: &mut UseName
)
3714 V
: VisitMut
+ ?Sized
,
3716 v
.visit_ident_mut(&mut node
.ident
);
3718 #[cfg(feature = "full")]
3719 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
3720 pub fn visit_use_path_mut
<V
>(v
: &mut V
, node
: &mut UsePath
)
3722 V
: VisitMut
+ ?Sized
,
3724 v
.visit_ident_mut(&mut node
.ident
);
3725 skip
!(node
.colon2_token
);
3726 v
.visit_use_tree_mut(&mut *node
.tree
);
3728 #[cfg(feature = "full")]
3729 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
3730 pub fn visit_use_rename_mut
<V
>(v
: &mut V
, node
: &mut UseRename
)
3732 V
: VisitMut
+ ?Sized
,
3734 v
.visit_ident_mut(&mut node
.ident
);
3735 skip
!(node
.as_token
);
3736 v
.visit_ident_mut(&mut node
.rename
);
3738 #[cfg(feature = "full")]
3739 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
3740 pub fn visit_use_tree_mut
<V
>(v
: &mut V
, node
: &mut UseTree
)
3742 V
: VisitMut
+ ?Sized
,
3745 UseTree
::Path(_binding_0
) => {
3746 v
.visit_use_path_mut(_binding_0
);
3748 UseTree
::Name(_binding_0
) => {
3749 v
.visit_use_name_mut(_binding_0
);
3751 UseTree
::Rename(_binding_0
) => {
3752 v
.visit_use_rename_mut(_binding_0
);
3754 UseTree
::Glob(_binding_0
) => {
3755 v
.visit_use_glob_mut(_binding_0
);
3757 UseTree
::Group(_binding_0
) => {
3758 v
.visit_use_group_mut(_binding_0
);
3762 #[cfg(feature = "full")]
3763 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
3764 pub fn visit_variadic_mut
<V
>(v
: &mut V
, node
: &mut Variadic
)
3766 V
: VisitMut
+ ?Sized
,
3768 for it
in &mut node
.attrs
{
3769 v
.visit_attribute_mut(it
);
3771 if let Some(it
) = &mut node
.pat
{
3772 v
.visit_pat_mut(&mut *(it
).0);
3778 #[cfg(any(feature = "derive", feature = "full"))]
3779 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
3780 pub fn visit_variant_mut
<V
>(v
: &mut V
, node
: &mut Variant
)
3782 V
: VisitMut
+ ?Sized
,
3784 for it
in &mut node
.attrs
{
3785 v
.visit_attribute_mut(it
);
3787 v
.visit_ident_mut(&mut node
.ident
);
3788 v
.visit_fields_mut(&mut node
.fields
);
3789 if let Some(it
) = &mut node
.discriminant
{
3791 v
.visit_expr_mut(&mut (it
).1);
3794 #[cfg(any(feature = "derive", feature = "full"))]
3795 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
3796 pub fn visit_vis_restricted_mut
<V
>(v
: &mut V
, node
: &mut VisRestricted
)
3798 V
: VisitMut
+ ?Sized
,
3800 skip
!(node
.pub_token
);
3801 skip
!(node
.paren_token
);
3802 skip
!(node
.in_token
);
3803 v
.visit_path_mut(&mut *node
.path
);
3805 #[cfg(any(feature = "derive", feature = "full"))]
3806 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
3807 pub fn visit_visibility_mut
<V
>(v
: &mut V
, node
: &mut Visibility
)
3809 V
: VisitMut
+ ?Sized
,
3812 Visibility
::Public(_binding_0
) => {
3815 Visibility
::Restricted(_binding_0
) => {
3816 v
.visit_vis_restricted_mut(_binding_0
);
3818 Visibility
::Inherited
=> {}
3821 #[cfg(any(feature = "derive", feature = "full"))]
3822 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
3823 pub fn visit_where_clause_mut
<V
>(v
: &mut V
, node
: &mut WhereClause
)
3825 V
: VisitMut
+ ?Sized
,
3827 skip
!(node
.where_token
);
3828 for mut el
in Punctuated
::pairs_mut(&mut node
.predicates
) {
3829 let it
= el
.value_mut();
3830 v
.visit_where_predicate_mut(it
);
3833 #[cfg(any(feature = "derive", feature = "full"))]
3834 #[cfg_attr(doc_cfg, doc(cfg(any(feature = "derive", feature = "full"))))]
3835 pub fn visit_where_predicate_mut
<V
>(v
: &mut V
, node
: &mut WherePredicate
)
3837 V
: VisitMut
+ ?Sized
,
3840 WherePredicate
::Lifetime(_binding_0
) => {
3841 v
.visit_predicate_lifetime_mut(_binding_0
);
3843 WherePredicate
::Type(_binding_0
) => {
3844 v
.visit_predicate_type_mut(_binding_0
);
projects / rustc.git / blob