projects/linux·blob master · refs

3904 lines · 133.8 KiB

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