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