xref: /third_party/rust/crates/syn/src/gen/clone.rs (revision fad3a1d3) 
1// This file is @generated by syn-internal-codegen.
2// It is not intended for manual editing.
3
4#![allow(clippy::clone_on_copy, clippy::expl_impl_clone_on_copy)]
5use crate::*;
6#[cfg(any(feature = "derive", feature = "full"))]
7#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
8impl Clone for Abi {
9    fn clone(&self) -> Self {
10        Abi {
11            extern_token: self.extern_token.clone(),
12            name: self.name.clone(),
13        }
14    }
15}
16#[cfg(any(feature = "derive", feature = "full"))]
17#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
18impl Clone for AngleBracketedGenericArguments {
19    fn clone(&self) -> Self {
20        AngleBracketedGenericArguments {
21            colon2_token: self.colon2_token.clone(),
22            lt_token: self.lt_token.clone(),
23            args: self.args.clone(),
24            gt_token: self.gt_token.clone(),
25        }
26    }
27}
28#[cfg(feature = "full")]
29#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
30impl Clone for Arm {
31    fn clone(&self) -> Self {
32        Arm {
33            attrs: self.attrs.clone(),
34            pat: self.pat.clone(),
35            guard: self.guard.clone(),
36            fat_arrow_token: self.fat_arrow_token.clone(),
37            body: self.body.clone(),
38            comma: self.comma.clone(),
39        }
40    }
41}
42#[cfg(any(feature = "derive", feature = "full"))]
43#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
44impl Clone for AssocConst {
45    fn clone(&self) -> Self {
46        AssocConst {
47            ident: self.ident.clone(),
48            generics: self.generics.clone(),
49            eq_token: self.eq_token.clone(),
50            value: self.value.clone(),
51        }
52    }
53}
54#[cfg(any(feature = "derive", feature = "full"))]
55#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
56impl Clone for AssocType {
57    fn clone(&self) -> Self {
58        AssocType {
59            ident: self.ident.clone(),
60            generics: self.generics.clone(),
61            eq_token: self.eq_token.clone(),
62            ty: self.ty.clone(),
63        }
64    }
65}
66#[cfg(any(feature = "derive", feature = "full"))]
67#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
68impl Copy for AttrStyle {}
69#[cfg(any(feature = "derive", feature = "full"))]
70#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
71impl Clone for AttrStyle {
72    fn clone(&self) -> Self {
73        *self
74    }
75}
76#[cfg(any(feature = "derive", feature = "full"))]
77#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
78impl Clone for Attribute {
79    fn clone(&self) -> Self {
80        Attribute {
81            pound_token: self.pound_token.clone(),
82            style: self.style.clone(),
83            bracket_token: self.bracket_token.clone(),
84            meta: self.meta.clone(),
85        }
86    }
87}
88#[cfg(any(feature = "derive", feature = "full"))]
89#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
90impl Clone for BareFnArg {
91    fn clone(&self) -> Self {
92        BareFnArg {
93            attrs: self.attrs.clone(),
94            name: self.name.clone(),
95            ty: self.ty.clone(),
96        }
97    }
98}
99#[cfg(any(feature = "derive", feature = "full"))]
100#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
101impl Clone for BareVariadic {
102    fn clone(&self) -> Self {
103        BareVariadic {
104            attrs: self.attrs.clone(),
105            name: self.name.clone(),
106            dots: self.dots.clone(),
107            comma: self.comma.clone(),
108        }
109    }
110}
111#[cfg(any(feature = "derive", feature = "full"))]
112#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
113impl Copy for BinOp {}
114#[cfg(any(feature = "derive", feature = "full"))]
115#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
116impl Clone for BinOp {
117    fn clone(&self) -> Self {
118        *self
119    }
120}
121#[cfg(feature = "full")]
122#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
123impl Clone for Block {
124    fn clone(&self) -> Self {
125        Block {
126            brace_token: self.brace_token.clone(),
127            stmts: self.stmts.clone(),
128        }
129    }
130}
131#[cfg(any(feature = "derive", feature = "full"))]
132#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
133impl Clone for BoundLifetimes {
134    fn clone(&self) -> Self {
135        BoundLifetimes {
136            for_token: self.for_token.clone(),
137            lt_token: self.lt_token.clone(),
138            lifetimes: self.lifetimes.clone(),
139            gt_token: self.gt_token.clone(),
140        }
141    }
142}
143#[cfg(any(feature = "derive", feature = "full"))]
144#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
145impl Clone for ConstParam {
146    fn clone(&self) -> Self {
147        ConstParam {
148            attrs: self.attrs.clone(),
149            const_token: self.const_token.clone(),
150            ident: self.ident.clone(),
151            colon_token: self.colon_token.clone(),
152            ty: self.ty.clone(),
153            eq_token: self.eq_token.clone(),
154            default: self.default.clone(),
155        }
156    }
157}
158#[cfg(any(feature = "derive", feature = "full"))]
159#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
160impl Clone for Constraint {
161    fn clone(&self) -> Self {
162        Constraint {
163            ident: self.ident.clone(),
164            generics: self.generics.clone(),
165            colon_token: self.colon_token.clone(),
166            bounds: self.bounds.clone(),
167        }
168    }
169}
170#[cfg(feature = "derive")]
171#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
172impl Clone for Data {
173    fn clone(&self) -> Self {
174        match self {
175            Data::Struct(v0) => Data::Struct(v0.clone()),
176            Data::Enum(v0) => Data::Enum(v0.clone()),
177            Data::Union(v0) => Data::Union(v0.clone()),
178        }
179    }
180}
181#[cfg(feature = "derive")]
182#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
183impl Clone for DataEnum {
184    fn clone(&self) -> Self {
185        DataEnum {
186            enum_token: self.enum_token.clone(),
187            brace_token: self.brace_token.clone(),
188            variants: self.variants.clone(),
189        }
190    }
191}
192#[cfg(feature = "derive")]
193#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
194impl Clone for DataStruct {
195    fn clone(&self) -> Self {
196        DataStruct {
197            struct_token: self.struct_token.clone(),
198            fields: self.fields.clone(),
199            semi_token: self.semi_token.clone(),
200        }
201    }
202}
203#[cfg(feature = "derive")]
204#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
205impl Clone for DataUnion {
206    fn clone(&self) -> Self {
207        DataUnion {
208            union_token: self.union_token.clone(),
209            fields: self.fields.clone(),
210        }
211    }
212}
213#[cfg(feature = "derive")]
214#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
215impl Clone for DeriveInput {
216    fn clone(&self) -> Self {
217        DeriveInput {
218            attrs: self.attrs.clone(),
219            vis: self.vis.clone(),
220            ident: self.ident.clone(),
221            generics: self.generics.clone(),
222            data: self.data.clone(),
223        }
224    }
225}
226#[cfg(any(feature = "derive", feature = "full"))]
227#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
228impl Clone for Expr {
229    fn clone(&self) -> Self {
230        match self {
231            #[cfg(feature = "full")]
232            Expr::Array(v0) => Expr::Array(v0.clone()),
233            #[cfg(feature = "full")]
234            Expr::Assign(v0) => Expr::Assign(v0.clone()),
235            #[cfg(feature = "full")]
236            Expr::Async(v0) => Expr::Async(v0.clone()),
237            #[cfg(feature = "full")]
238            Expr::Await(v0) => Expr::Await(v0.clone()),
239            Expr::Binary(v0) => Expr::Binary(v0.clone()),
240            #[cfg(feature = "full")]
241            Expr::Block(v0) => Expr::Block(v0.clone()),
242            #[cfg(feature = "full")]
243            Expr::Break(v0) => Expr::Break(v0.clone()),
244            Expr::Call(v0) => Expr::Call(v0.clone()),
245            Expr::Cast(v0) => Expr::Cast(v0.clone()),
246            #[cfg(feature = "full")]
247            Expr::Closure(v0) => Expr::Closure(v0.clone()),
248            #[cfg(feature = "full")]
249            Expr::Const(v0) => Expr::Const(v0.clone()),
250            #[cfg(feature = "full")]
251            Expr::Continue(v0) => Expr::Continue(v0.clone()),
252            Expr::Field(v0) => Expr::Field(v0.clone()),
253            #[cfg(feature = "full")]
254            Expr::ForLoop(v0) => Expr::ForLoop(v0.clone()),
255            Expr::Group(v0) => Expr::Group(v0.clone()),
256            #[cfg(feature = "full")]
257            Expr::If(v0) => Expr::If(v0.clone()),
258            Expr::Index(v0) => Expr::Index(v0.clone()),
259            #[cfg(feature = "full")]
260            Expr::Infer(v0) => Expr::Infer(v0.clone()),
261            #[cfg(feature = "full")]
262            Expr::Let(v0) => Expr::Let(v0.clone()),
263            Expr::Lit(v0) => Expr::Lit(v0.clone()),
264            #[cfg(feature = "full")]
265            Expr::Loop(v0) => Expr::Loop(v0.clone()),
266            Expr::Macro(v0) => Expr::Macro(v0.clone()),
267            #[cfg(feature = "full")]
268            Expr::Match(v0) => Expr::Match(v0.clone()),
269            Expr::MethodCall(v0) => Expr::MethodCall(v0.clone()),
270            Expr::Paren(v0) => Expr::Paren(v0.clone()),
271            Expr::Path(v0) => Expr::Path(v0.clone()),
272            #[cfg(feature = "full")]
273            Expr::Range(v0) => Expr::Range(v0.clone()),
274            Expr::Reference(v0) => Expr::Reference(v0.clone()),
275            #[cfg(feature = "full")]
276            Expr::Repeat(v0) => Expr::Repeat(v0.clone()),
277            #[cfg(feature = "full")]
278            Expr::Return(v0) => Expr::Return(v0.clone()),
279            Expr::Struct(v0) => Expr::Struct(v0.clone()),
280            #[cfg(feature = "full")]
281            Expr::Try(v0) => Expr::Try(v0.clone()),
282            #[cfg(feature = "full")]
283            Expr::TryBlock(v0) => Expr::TryBlock(v0.clone()),
284            #[cfg(feature = "full")]
285            Expr::Tuple(v0) => Expr::Tuple(v0.clone()),
286            Expr::Unary(v0) => Expr::Unary(v0.clone()),
287            #[cfg(feature = "full")]
288            Expr::Unsafe(v0) => Expr::Unsafe(v0.clone()),
289            Expr::Verbatim(v0) => Expr::Verbatim(v0.clone()),
290            #[cfg(feature = "full")]
291            Expr::While(v0) => Expr::While(v0.clone()),
292            #[cfg(feature = "full")]
293            Expr::Yield(v0) => Expr::Yield(v0.clone()),
294            #[cfg(not(feature = "full"))]
295            _ => unreachable!(),
296        }
297    }
298}
299#[cfg(feature = "full")]
300#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
301impl Clone for ExprArray {
302    fn clone(&self) -> Self {
303        ExprArray {
304            attrs: self.attrs.clone(),
305            bracket_token: self.bracket_token.clone(),
306            elems: self.elems.clone(),
307        }
308    }
309}
310#[cfg(feature = "full")]
311#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
312impl Clone for ExprAssign {
313    fn clone(&self) -> Self {
314        ExprAssign {
315            attrs: self.attrs.clone(),
316            left: self.left.clone(),
317            eq_token: self.eq_token.clone(),
318            right: self.right.clone(),
319        }
320    }
321}
322#[cfg(feature = "full")]
323#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
324impl Clone for ExprAsync {
325    fn clone(&self) -> Self {
326        ExprAsync {
327            attrs: self.attrs.clone(),
328            async_token: self.async_token.clone(),
329            capture: self.capture.clone(),
330            block: self.block.clone(),
331        }
332    }
333}
334#[cfg(feature = "full")]
335#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
336impl Clone for ExprAwait {
337    fn clone(&self) -> Self {
338        ExprAwait {
339            attrs: self.attrs.clone(),
340            base: self.base.clone(),
341            dot_token: self.dot_token.clone(),
342            await_token: self.await_token.clone(),
343        }
344    }
345}
346#[cfg(any(feature = "derive", feature = "full"))]
347#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
348impl Clone for ExprBinary {
349    fn clone(&self) -> Self {
350        ExprBinary {
351            attrs: self.attrs.clone(),
352            left: self.left.clone(),
353            op: self.op.clone(),
354            right: self.right.clone(),
355        }
356    }
357}
358#[cfg(feature = "full")]
359#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
360impl Clone for ExprBlock {
361    fn clone(&self) -> Self {
362        ExprBlock {
363            attrs: self.attrs.clone(),
364            label: self.label.clone(),
365            block: self.block.clone(),
366        }
367    }
368}
369#[cfg(feature = "full")]
370#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
371impl Clone for ExprBreak {
372    fn clone(&self) -> Self {
373        ExprBreak {
374            attrs: self.attrs.clone(),
375            break_token: self.break_token.clone(),
376            label: self.label.clone(),
377            expr: self.expr.clone(),
378        }
379    }
380}
381#[cfg(any(feature = "derive", feature = "full"))]
382#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
383impl Clone for ExprCall {
384    fn clone(&self) -> Self {
385        ExprCall {
386            attrs: self.attrs.clone(),
387            func: self.func.clone(),
388            paren_token: self.paren_token.clone(),
389            args: self.args.clone(),
390        }
391    }
392}
393#[cfg(any(feature = "derive", feature = "full"))]
394#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
395impl Clone for ExprCast {
396    fn clone(&self) -> Self {
397        ExprCast {
398            attrs: self.attrs.clone(),
399            expr: self.expr.clone(),
400            as_token: self.as_token.clone(),
401            ty: self.ty.clone(),
402        }
403    }
404}
405#[cfg(feature = "full")]
406#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
407impl Clone for ExprClosure {
408    fn clone(&self) -> Self {
409        ExprClosure {
410            attrs: self.attrs.clone(),
411            lifetimes: self.lifetimes.clone(),
412            constness: self.constness.clone(),
413            movability: self.movability.clone(),
414            asyncness: self.asyncness.clone(),
415            capture: self.capture.clone(),
416            or1_token: self.or1_token.clone(),
417            inputs: self.inputs.clone(),
418            or2_token: self.or2_token.clone(),
419            output: self.output.clone(),
420            body: self.body.clone(),
421        }
422    }
423}
424#[cfg(feature = "full")]
425#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
426impl Clone for ExprConst {
427    fn clone(&self) -> Self {
428        ExprConst {
429            attrs: self.attrs.clone(),
430            const_token: self.const_token.clone(),
431            block: self.block.clone(),
432        }
433    }
434}
435#[cfg(feature = "full")]
436#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
437impl Clone for ExprContinue {
438    fn clone(&self) -> Self {
439        ExprContinue {
440            attrs: self.attrs.clone(),
441            continue_token: self.continue_token.clone(),
442            label: self.label.clone(),
443        }
444    }
445}
446#[cfg(any(feature = "derive", feature = "full"))]
447#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
448impl Clone for ExprField {
449    fn clone(&self) -> Self {
450        ExprField {
451            attrs: self.attrs.clone(),
452            base: self.base.clone(),
453            dot_token: self.dot_token.clone(),
454            member: self.member.clone(),
455        }
456    }
457}
458#[cfg(feature = "full")]
459#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
460impl Clone for ExprForLoop {
461    fn clone(&self) -> Self {
462        ExprForLoop {
463            attrs: self.attrs.clone(),
464            label: self.label.clone(),
465            for_token: self.for_token.clone(),
466            pat: self.pat.clone(),
467            in_token: self.in_token.clone(),
468            expr: self.expr.clone(),
469            body: self.body.clone(),
470        }
471    }
472}
473#[cfg(any(feature = "derive", feature = "full"))]
474#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
475impl Clone for ExprGroup {
476    fn clone(&self) -> Self {
477        ExprGroup {
478            attrs: self.attrs.clone(),
479            group_token: self.group_token.clone(),
480            expr: self.expr.clone(),
481        }
482    }
483}
484#[cfg(feature = "full")]
485#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
486impl Clone for ExprIf {
487    fn clone(&self) -> Self {
488        ExprIf {
489            attrs: self.attrs.clone(),
490            if_token: self.if_token.clone(),
491            cond: self.cond.clone(),
492            then_branch: self.then_branch.clone(),
493            else_branch: self.else_branch.clone(),
494        }
495    }
496}
497#[cfg(any(feature = "derive", feature = "full"))]
498#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
499impl Clone for ExprIndex {
500    fn clone(&self) -> Self {
501        ExprIndex {
502            attrs: self.attrs.clone(),
503            expr: self.expr.clone(),
504            bracket_token: self.bracket_token.clone(),
505            index: self.index.clone(),
506        }
507    }
508}
509#[cfg(feature = "full")]
510#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
511impl Clone for ExprInfer {
512    fn clone(&self) -> Self {
513        ExprInfer {
514            attrs: self.attrs.clone(),
515            underscore_token: self.underscore_token.clone(),
516        }
517    }
518}
519#[cfg(feature = "full")]
520#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
521impl Clone for ExprLet {
522    fn clone(&self) -> Self {
523        ExprLet {
524            attrs: self.attrs.clone(),
525            let_token: self.let_token.clone(),
526            pat: self.pat.clone(),
527            eq_token: self.eq_token.clone(),
528            expr: self.expr.clone(),
529        }
530    }
531}
532#[cfg(any(feature = "derive", feature = "full"))]
533#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
534impl Clone for ExprLit {
535    fn clone(&self) -> Self {
536        ExprLit {
537            attrs: self.attrs.clone(),
538            lit: self.lit.clone(),
539        }
540    }
541}
542#[cfg(feature = "full")]
543#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
544impl Clone for ExprLoop {
545    fn clone(&self) -> Self {
546        ExprLoop {
547            attrs: self.attrs.clone(),
548            label: self.label.clone(),
549            loop_token: self.loop_token.clone(),
550            body: self.body.clone(),
551        }
552    }
553}
554#[cfg(any(feature = "derive", feature = "full"))]
555#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
556impl Clone for ExprMacro {
557    fn clone(&self) -> Self {
558        ExprMacro {
559            attrs: self.attrs.clone(),
560            mac: self.mac.clone(),
561        }
562    }
563}
564#[cfg(feature = "full")]
565#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
566impl Clone for ExprMatch {
567    fn clone(&self) -> Self {
568        ExprMatch {
569            attrs: self.attrs.clone(),
570            match_token: self.match_token.clone(),
571            expr: self.expr.clone(),
572            brace_token: self.brace_token.clone(),
573            arms: self.arms.clone(),
574        }
575    }
576}
577#[cfg(any(feature = "derive", feature = "full"))]
578#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
579impl Clone for ExprMethodCall {
580    fn clone(&self) -> Self {
581        ExprMethodCall {
582            attrs: self.attrs.clone(),
583            receiver: self.receiver.clone(),
584            dot_token: self.dot_token.clone(),
585            method: self.method.clone(),
586            turbofish: self.turbofish.clone(),
587            paren_token: self.paren_token.clone(),
588            args: self.args.clone(),
589        }
590    }
591}
592#[cfg(any(feature = "derive", feature = "full"))]
593#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
594impl Clone for ExprParen {
595    fn clone(&self) -> Self {
596        ExprParen {
597            attrs: self.attrs.clone(),
598            paren_token: self.paren_token.clone(),
599            expr: self.expr.clone(),
600        }
601    }
602}
603#[cfg(any(feature = "derive", feature = "full"))]
604#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
605impl Clone for ExprPath {
606    fn clone(&self) -> Self {
607        ExprPath {
608            attrs: self.attrs.clone(),
609            qself: self.qself.clone(),
610            path: self.path.clone(),
611        }
612    }
613}
614#[cfg(feature = "full")]
615#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
616impl Clone for ExprRange {
617    fn clone(&self) -> Self {
618        ExprRange {
619            attrs: self.attrs.clone(),
620            start: self.start.clone(),
621            limits: self.limits.clone(),
622            end: self.end.clone(),
623        }
624    }
625}
626#[cfg(any(feature = "derive", feature = "full"))]
627#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
628impl Clone for ExprReference {
629    fn clone(&self) -> Self {
630        ExprReference {
631            attrs: self.attrs.clone(),
632            and_token: self.and_token.clone(),
633            mutability: self.mutability.clone(),
634            expr: self.expr.clone(),
635        }
636    }
637}
638#[cfg(feature = "full")]
639#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
640impl Clone for ExprRepeat {
641    fn clone(&self) -> Self {
642        ExprRepeat {
643            attrs: self.attrs.clone(),
644            bracket_token: self.bracket_token.clone(),
645            expr: self.expr.clone(),
646            semi_token: self.semi_token.clone(),
647            len: self.len.clone(),
648        }
649    }
650}
651#[cfg(feature = "full")]
652#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
653impl Clone for ExprReturn {
654    fn clone(&self) -> Self {
655        ExprReturn {
656            attrs: self.attrs.clone(),
657            return_token: self.return_token.clone(),
658            expr: self.expr.clone(),
659        }
660    }
661}
662#[cfg(any(feature = "derive", feature = "full"))]
663#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
664impl Clone for ExprStruct {
665    fn clone(&self) -> Self {
666        ExprStruct {
667            attrs: self.attrs.clone(),
668            qself: self.qself.clone(),
669            path: self.path.clone(),
670            brace_token: self.brace_token.clone(),
671            fields: self.fields.clone(),
672            dot2_token: self.dot2_token.clone(),
673            rest: self.rest.clone(),
674        }
675    }
676}
677#[cfg(feature = "full")]
678#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
679impl Clone for ExprTry {
680    fn clone(&self) -> Self {
681        ExprTry {
682            attrs: self.attrs.clone(),
683            expr: self.expr.clone(),
684            question_token: self.question_token.clone(),
685        }
686    }
687}
688#[cfg(feature = "full")]
689#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
690impl Clone for ExprTryBlock {
691    fn clone(&self) -> Self {
692        ExprTryBlock {
693            attrs: self.attrs.clone(),
694            try_token: self.try_token.clone(),
695            block: self.block.clone(),
696        }
697    }
698}
699#[cfg(feature = "full")]
700#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
701impl Clone for ExprTuple {
702    fn clone(&self) -> Self {
703        ExprTuple {
704            attrs: self.attrs.clone(),
705            paren_token: self.paren_token.clone(),
706            elems: self.elems.clone(),
707        }
708    }
709}
710#[cfg(any(feature = "derive", feature = "full"))]
711#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
712impl Clone for ExprUnary {
713    fn clone(&self) -> Self {
714        ExprUnary {
715            attrs: self.attrs.clone(),
716            op: self.op.clone(),
717            expr: self.expr.clone(),
718        }
719    }
720}
721#[cfg(feature = "full")]
722#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
723impl Clone for ExprUnsafe {
724    fn clone(&self) -> Self {
725        ExprUnsafe {
726            attrs: self.attrs.clone(),
727            unsafe_token: self.unsafe_token.clone(),
728            block: self.block.clone(),
729        }
730    }
731}
732#[cfg(feature = "full")]
733#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
734impl Clone for ExprWhile {
735    fn clone(&self) -> Self {
736        ExprWhile {
737            attrs: self.attrs.clone(),
738            label: self.label.clone(),
739            while_token: self.while_token.clone(),
740            cond: self.cond.clone(),
741            body: self.body.clone(),
742        }
743    }
744}
745#[cfg(feature = "full")]
746#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
747impl Clone for ExprYield {
748    fn clone(&self) -> Self {
749        ExprYield {
750            attrs: self.attrs.clone(),
751            yield_token: self.yield_token.clone(),
752            expr: self.expr.clone(),
753        }
754    }
755}
756#[cfg(any(feature = "derive", feature = "full"))]
757#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
758impl Clone for Field {
759    fn clone(&self) -> Self {
760        Field {
761            attrs: self.attrs.clone(),
762            vis: self.vis.clone(),
763            mutability: self.mutability.clone(),
764            ident: self.ident.clone(),
765            colon_token: self.colon_token.clone(),
766            ty: self.ty.clone(),
767        }
768    }
769}
770#[cfg(any(feature = "derive", feature = "full"))]
771#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
772impl Clone for FieldMutability {
773    fn clone(&self) -> Self {
774        match self {
775            FieldMutability::None => FieldMutability::None,
776        }
777    }
778}
779#[cfg(feature = "full")]
780#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
781impl Clone for FieldPat {
782    fn clone(&self) -> Self {
783        FieldPat {
784            attrs: self.attrs.clone(),
785            member: self.member.clone(),
786            colon_token: self.colon_token.clone(),
787            pat: self.pat.clone(),
788        }
789    }
790}
791#[cfg(any(feature = "derive", feature = "full"))]
792#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
793impl Clone for FieldValue {
794    fn clone(&self) -> Self {
795        FieldValue {
796            attrs: self.attrs.clone(),
797            member: self.member.clone(),
798            colon_token: self.colon_token.clone(),
799            expr: self.expr.clone(),
800        }
801    }
802}
803#[cfg(any(feature = "derive", feature = "full"))]
804#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
805impl Clone for Fields {
806    fn clone(&self) -> Self {
807        match self {
808            Fields::Named(v0) => Fields::Named(v0.clone()),
809            Fields::Unnamed(v0) => Fields::Unnamed(v0.clone()),
810            Fields::Unit => Fields::Unit,
811        }
812    }
813}
814#[cfg(any(feature = "derive", feature = "full"))]
815#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
816impl Clone for FieldsNamed {
817    fn clone(&self) -> Self {
818        FieldsNamed {
819            brace_token: self.brace_token.clone(),
820            named: self.named.clone(),
821        }
822    }
823}
824#[cfg(any(feature = "derive", feature = "full"))]
825#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
826impl Clone for FieldsUnnamed {
827    fn clone(&self) -> Self {
828        FieldsUnnamed {
829            paren_token: self.paren_token.clone(),
830            unnamed: self.unnamed.clone(),
831        }
832    }
833}
834#[cfg(feature = "full")]
835#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
836impl Clone for File {
837    fn clone(&self) -> Self {
838        File {
839            shebang: self.shebang.clone(),
840            attrs: self.attrs.clone(),
841            items: self.items.clone(),
842        }
843    }
844}
845#[cfg(feature = "full")]
846#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
847impl Clone for FnArg {
848    fn clone(&self) -> Self {
849        match self {
850            FnArg::Receiver(v0) => FnArg::Receiver(v0.clone()),
851            FnArg::Typed(v0) => FnArg::Typed(v0.clone()),
852        }
853    }
854}
855#[cfg(feature = "full")]
856#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
857impl Clone for ForeignItem {
858    fn clone(&self) -> Self {
859        match self {
860            ForeignItem::Fn(v0) => ForeignItem::Fn(v0.clone()),
861            ForeignItem::Static(v0) => ForeignItem::Static(v0.clone()),
862            ForeignItem::Type(v0) => ForeignItem::Type(v0.clone()),
863            ForeignItem::Macro(v0) => ForeignItem::Macro(v0.clone()),
864            ForeignItem::Verbatim(v0) => ForeignItem::Verbatim(v0.clone()),
865        }
866    }
867}
868#[cfg(feature = "full")]
869#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
870impl Clone for ForeignItemFn {
871    fn clone(&self) -> Self {
872        ForeignItemFn {
873            attrs: self.attrs.clone(),
874            vis: self.vis.clone(),
875            sig: self.sig.clone(),
876            semi_token: self.semi_token.clone(),
877        }
878    }
879}
880#[cfg(feature = "full")]
881#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
882impl Clone for ForeignItemMacro {
883    fn clone(&self) -> Self {
884        ForeignItemMacro {
885            attrs: self.attrs.clone(),
886            mac: self.mac.clone(),
887            semi_token: self.semi_token.clone(),
888        }
889    }
890}
891#[cfg(feature = "full")]
892#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
893impl Clone for ForeignItemStatic {
894    fn clone(&self) -> Self {
895        ForeignItemStatic {
896            attrs: self.attrs.clone(),
897            vis: self.vis.clone(),
898            static_token: self.static_token.clone(),
899            mutability: self.mutability.clone(),
900            ident: self.ident.clone(),
901            colon_token: self.colon_token.clone(),
902            ty: self.ty.clone(),
903            semi_token: self.semi_token.clone(),
904        }
905    }
906}
907#[cfg(feature = "full")]
908#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
909impl Clone for ForeignItemType {
910    fn clone(&self) -> Self {
911        ForeignItemType {
912            attrs: self.attrs.clone(),
913            vis: self.vis.clone(),
914            type_token: self.type_token.clone(),
915            ident: self.ident.clone(),
916            generics: self.generics.clone(),
917            semi_token: self.semi_token.clone(),
918        }
919    }
920}
921#[cfg(any(feature = "derive", feature = "full"))]
922#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
923impl Clone for GenericArgument {
924    fn clone(&self) -> Self {
925        match self {
926            GenericArgument::Lifetime(v0) => GenericArgument::Lifetime(v0.clone()),
927            GenericArgument::Type(v0) => GenericArgument::Type(v0.clone()),
928            GenericArgument::Const(v0) => GenericArgument::Const(v0.clone()),
929            GenericArgument::AssocType(v0) => GenericArgument::AssocType(v0.clone()),
930            GenericArgument::AssocConst(v0) => GenericArgument::AssocConst(v0.clone()),
931            GenericArgument::Constraint(v0) => GenericArgument::Constraint(v0.clone()),
932        }
933    }
934}
935#[cfg(any(feature = "derive", feature = "full"))]
936#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
937impl Clone for GenericParam {
938    fn clone(&self) -> Self {
939        match self {
940            GenericParam::Lifetime(v0) => GenericParam::Lifetime(v0.clone()),
941            GenericParam::Type(v0) => GenericParam::Type(v0.clone()),
942            GenericParam::Const(v0) => GenericParam::Const(v0.clone()),
943        }
944    }
945}
946#[cfg(any(feature = "derive", feature = "full"))]
947#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
948impl Clone for Generics {
949    fn clone(&self) -> Self {
950        Generics {
951            lt_token: self.lt_token.clone(),
952            params: self.params.clone(),
953            gt_token: self.gt_token.clone(),
954            where_clause: self.where_clause.clone(),
955        }
956    }
957}
958#[cfg(feature = "full")]
959#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
960impl Clone for ImplItem {
961    fn clone(&self) -> Self {
962        match self {
963            ImplItem::Const(v0) => ImplItem::Const(v0.clone()),
964            ImplItem::Fn(v0) => ImplItem::Fn(v0.clone()),
965            ImplItem::Type(v0) => ImplItem::Type(v0.clone()),
966            ImplItem::Macro(v0) => ImplItem::Macro(v0.clone()),
967            ImplItem::Verbatim(v0) => ImplItem::Verbatim(v0.clone()),
968        }
969    }
970}
971#[cfg(feature = "full")]
972#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
973impl Clone for ImplItemConst {
974    fn clone(&self) -> Self {
975        ImplItemConst {
976            attrs: self.attrs.clone(),
977            vis: self.vis.clone(),
978            defaultness: self.defaultness.clone(),
979            const_token: self.const_token.clone(),
980            ident: self.ident.clone(),
981            generics: self.generics.clone(),
982            colon_token: self.colon_token.clone(),
983            ty: self.ty.clone(),
984            eq_token: self.eq_token.clone(),
985            expr: self.expr.clone(),
986            semi_token: self.semi_token.clone(),
987        }
988    }
989}
990#[cfg(feature = "full")]
991#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
992impl Clone for ImplItemFn {
993    fn clone(&self) -> Self {
994        ImplItemFn {
995            attrs: self.attrs.clone(),
996            vis: self.vis.clone(),
997            defaultness: self.defaultness.clone(),
998            sig: self.sig.clone(),
999            block: self.block.clone(),
1000        }
1001    }
1002}
1003#[cfg(feature = "full")]
1004#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1005impl Clone for ImplItemMacro {
1006    fn clone(&self) -> Self {
1007        ImplItemMacro {
1008            attrs: self.attrs.clone(),
1009            mac: self.mac.clone(),
1010            semi_token: self.semi_token.clone(),
1011        }
1012    }
1013}
1014#[cfg(feature = "full")]
1015#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1016impl Clone for ImplItemType {
1017    fn clone(&self) -> Self {
1018        ImplItemType {
1019            attrs: self.attrs.clone(),
1020            vis: self.vis.clone(),
1021            defaultness: self.defaultness.clone(),
1022            type_token: self.type_token.clone(),
1023            ident: self.ident.clone(),
1024            generics: self.generics.clone(),
1025            eq_token: self.eq_token.clone(),
1026            ty: self.ty.clone(),
1027            semi_token: self.semi_token.clone(),
1028        }
1029    }
1030}
1031#[cfg(feature = "full")]
1032#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1033impl Clone for ImplRestriction {
1034    fn clone(&self) -> Self {
1035        match *self {}
1036    }
1037}
1038#[cfg(any(feature = "derive", feature = "full"))]
1039#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1040impl Clone for Index {
1041    fn clone(&self) -> Self {
1042        Index {
1043            index: self.index.clone(),
1044            span: self.span.clone(),
1045        }
1046    }
1047}
1048#[cfg(feature = "full")]
1049#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1050impl Clone for Item {
1051    fn clone(&self) -> Self {
1052        match self {
1053            Item::Const(v0) => Item::Const(v0.clone()),
1054            Item::Enum(v0) => Item::Enum(v0.clone()),
1055            Item::ExternCrate(v0) => Item::ExternCrate(v0.clone()),
1056            Item::Fn(v0) => Item::Fn(v0.clone()),
1057            Item::ForeignMod(v0) => Item::ForeignMod(v0.clone()),
1058            Item::Impl(v0) => Item::Impl(v0.clone()),
1059            Item::Macro(v0) => Item::Macro(v0.clone()),
1060            Item::Mod(v0) => Item::Mod(v0.clone()),
1061            Item::Static(v0) => Item::Static(v0.clone()),
1062            Item::Struct(v0) => Item::Struct(v0.clone()),
1063            Item::Trait(v0) => Item::Trait(v0.clone()),
1064            Item::TraitAlias(v0) => Item::TraitAlias(v0.clone()),
1065            Item::Type(v0) => Item::Type(v0.clone()),
1066            Item::Union(v0) => Item::Union(v0.clone()),
1067            Item::Use(v0) => Item::Use(v0.clone()),
1068            Item::Verbatim(v0) => Item::Verbatim(v0.clone()),
1069        }
1070    }
1071}
1072#[cfg(feature = "full")]
1073#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1074impl Clone for ItemConst {
1075    fn clone(&self) -> Self {
1076        ItemConst {
1077            attrs: self.attrs.clone(),
1078            vis: self.vis.clone(),
1079            const_token: self.const_token.clone(),
1080            ident: self.ident.clone(),
1081            generics: self.generics.clone(),
1082            colon_token: self.colon_token.clone(),
1083            ty: self.ty.clone(),
1084            eq_token: self.eq_token.clone(),
1085            expr: self.expr.clone(),
1086            semi_token: self.semi_token.clone(),
1087        }
1088    }
1089}
1090#[cfg(feature = "full")]
1091#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1092impl Clone for ItemEnum {
1093    fn clone(&self) -> Self {
1094        ItemEnum {
1095            attrs: self.attrs.clone(),
1096            vis: self.vis.clone(),
1097            enum_token: self.enum_token.clone(),
1098            ident: self.ident.clone(),
1099            generics: self.generics.clone(),
1100            brace_token: self.brace_token.clone(),
1101            variants: self.variants.clone(),
1102        }
1103    }
1104}
1105#[cfg(feature = "full")]
1106#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1107impl Clone for ItemExternCrate {
1108    fn clone(&self) -> Self {
1109        ItemExternCrate {
1110            attrs: self.attrs.clone(),
1111            vis: self.vis.clone(),
1112            extern_token: self.extern_token.clone(),
1113            crate_token: self.crate_token.clone(),
1114            ident: self.ident.clone(),
1115            rename: self.rename.clone(),
1116            semi_token: self.semi_token.clone(),
1117        }
1118    }
1119}
1120#[cfg(feature = "full")]
1121#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1122impl Clone for ItemFn {
1123    fn clone(&self) -> Self {
1124        ItemFn {
1125            attrs: self.attrs.clone(),
1126            vis: self.vis.clone(),
1127            sig: self.sig.clone(),
1128            block: self.block.clone(),
1129        }
1130    }
1131}
1132#[cfg(feature = "full")]
1133#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1134impl Clone for ItemForeignMod {
1135    fn clone(&self) -> Self {
1136        ItemForeignMod {
1137            attrs: self.attrs.clone(),
1138            unsafety: self.unsafety.clone(),
1139            abi: self.abi.clone(),
1140            brace_token: self.brace_token.clone(),
1141            items: self.items.clone(),
1142        }
1143    }
1144}
1145#[cfg(feature = "full")]
1146#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1147impl Clone for ItemImpl {
1148    fn clone(&self) -> Self {
1149        ItemImpl {
1150            attrs: self.attrs.clone(),
1151            defaultness: self.defaultness.clone(),
1152            unsafety: self.unsafety.clone(),
1153            impl_token: self.impl_token.clone(),
1154            generics: self.generics.clone(),
1155            trait_: self.trait_.clone(),
1156            self_ty: self.self_ty.clone(),
1157            brace_token: self.brace_token.clone(),
1158            items: self.items.clone(),
1159        }
1160    }
1161}
1162#[cfg(feature = "full")]
1163#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1164impl Clone for ItemMacro {
1165    fn clone(&self) -> Self {
1166        ItemMacro {
1167            attrs: self.attrs.clone(),
1168            ident: self.ident.clone(),
1169            mac: self.mac.clone(),
1170            semi_token: self.semi_token.clone(),
1171        }
1172    }
1173}
1174#[cfg(feature = "full")]
1175#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1176impl Clone for ItemMod {
1177    fn clone(&self) -> Self {
1178        ItemMod {
1179            attrs: self.attrs.clone(),
1180            vis: self.vis.clone(),
1181            unsafety: self.unsafety.clone(),
1182            mod_token: self.mod_token.clone(),
1183            ident: self.ident.clone(),
1184            content: self.content.clone(),
1185            semi: self.semi.clone(),
1186        }
1187    }
1188}
1189#[cfg(feature = "full")]
1190#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1191impl Clone for ItemStatic {
1192    fn clone(&self) -> Self {
1193        ItemStatic {
1194            attrs: self.attrs.clone(),
1195            vis: self.vis.clone(),
1196            static_token: self.static_token.clone(),
1197            mutability: self.mutability.clone(),
1198            ident: self.ident.clone(),
1199            colon_token: self.colon_token.clone(),
1200            ty: self.ty.clone(),
1201            eq_token: self.eq_token.clone(),
1202            expr: self.expr.clone(),
1203            semi_token: self.semi_token.clone(),
1204        }
1205    }
1206}
1207#[cfg(feature = "full")]
1208#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1209impl Clone for ItemStruct {
1210    fn clone(&self) -> Self {
1211        ItemStruct {
1212            attrs: self.attrs.clone(),
1213            vis: self.vis.clone(),
1214            struct_token: self.struct_token.clone(),
1215            ident: self.ident.clone(),
1216            generics: self.generics.clone(),
1217            fields: self.fields.clone(),
1218            semi_token: self.semi_token.clone(),
1219        }
1220    }
1221}
1222#[cfg(feature = "full")]
1223#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1224impl Clone for ItemTrait {
1225    fn clone(&self) -> Self {
1226        ItemTrait {
1227            attrs: self.attrs.clone(),
1228            vis: self.vis.clone(),
1229            unsafety: self.unsafety.clone(),
1230            auto_token: self.auto_token.clone(),
1231            restriction: self.restriction.clone(),
1232            trait_token: self.trait_token.clone(),
1233            ident: self.ident.clone(),
1234            generics: self.generics.clone(),
1235            colon_token: self.colon_token.clone(),
1236            supertraits: self.supertraits.clone(),
1237            brace_token: self.brace_token.clone(),
1238            items: self.items.clone(),
1239        }
1240    }
1241}
1242#[cfg(feature = "full")]
1243#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1244impl Clone for ItemTraitAlias {
1245    fn clone(&self) -> Self {
1246        ItemTraitAlias {
1247            attrs: self.attrs.clone(),
1248            vis: self.vis.clone(),
1249            trait_token: self.trait_token.clone(),
1250            ident: self.ident.clone(),
1251            generics: self.generics.clone(),
1252            eq_token: self.eq_token.clone(),
1253            bounds: self.bounds.clone(),
1254            semi_token: self.semi_token.clone(),
1255        }
1256    }
1257}
1258#[cfg(feature = "full")]
1259#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1260impl Clone for ItemType {
1261    fn clone(&self) -> Self {
1262        ItemType {
1263            attrs: self.attrs.clone(),
1264            vis: self.vis.clone(),
1265            type_token: self.type_token.clone(),
1266            ident: self.ident.clone(),
1267            generics: self.generics.clone(),
1268            eq_token: self.eq_token.clone(),
1269            ty: self.ty.clone(),
1270            semi_token: self.semi_token.clone(),
1271        }
1272    }
1273}
1274#[cfg(feature = "full")]
1275#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1276impl Clone for ItemUnion {
1277    fn clone(&self) -> Self {
1278        ItemUnion {
1279            attrs: self.attrs.clone(),
1280            vis: self.vis.clone(),
1281            union_token: self.union_token.clone(),
1282            ident: self.ident.clone(),
1283            generics: self.generics.clone(),
1284            fields: self.fields.clone(),
1285        }
1286    }
1287}
1288#[cfg(feature = "full")]
1289#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1290impl Clone for ItemUse {
1291    fn clone(&self) -> Self {
1292        ItemUse {
1293            attrs: self.attrs.clone(),
1294            vis: self.vis.clone(),
1295            use_token: self.use_token.clone(),
1296            leading_colon: self.leading_colon.clone(),
1297            tree: self.tree.clone(),
1298            semi_token: self.semi_token.clone(),
1299        }
1300    }
1301}
1302#[cfg(feature = "full")]
1303#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1304impl Clone for Label {
1305    fn clone(&self) -> Self {
1306        Label {
1307            name: self.name.clone(),
1308            colon_token: self.colon_token.clone(),
1309        }
1310    }
1311}
1312#[cfg(any(feature = "derive", feature = "full"))]
1313#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1314impl Clone for LifetimeParam {
1315    fn clone(&self) -> Self {
1316        LifetimeParam {
1317            attrs: self.attrs.clone(),
1318            lifetime: self.lifetime.clone(),
1319            colon_token: self.colon_token.clone(),
1320            bounds: self.bounds.clone(),
1321        }
1322    }
1323}
1324#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1325impl Clone for Lit {
1326    fn clone(&self) -> Self {
1327        match self {
1328            Lit::Str(v0) => Lit::Str(v0.clone()),
1329            Lit::ByteStr(v0) => Lit::ByteStr(v0.clone()),
1330            Lit::Byte(v0) => Lit::Byte(v0.clone()),
1331            Lit::Char(v0) => Lit::Char(v0.clone()),
1332            Lit::Int(v0) => Lit::Int(v0.clone()),
1333            Lit::Float(v0) => Lit::Float(v0.clone()),
1334            Lit::Bool(v0) => Lit::Bool(v0.clone()),
1335            Lit::Verbatim(v0) => Lit::Verbatim(v0.clone()),
1336        }
1337    }
1338}
1339#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1340impl Clone for LitBool {
1341    fn clone(&self) -> Self {
1342        LitBool {
1343            value: self.value.clone(),
1344            span: self.span.clone(),
1345        }
1346    }
1347}
1348#[cfg(feature = "full")]
1349#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1350impl Clone for Local {
1351    fn clone(&self) -> Self {
1352        Local {
1353            attrs: self.attrs.clone(),
1354            let_token: self.let_token.clone(),
1355            pat: self.pat.clone(),
1356            init: self.init.clone(),
1357            semi_token: self.semi_token.clone(),
1358        }
1359    }
1360}
1361#[cfg(feature = "full")]
1362#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1363impl Clone for LocalInit {
1364    fn clone(&self) -> Self {
1365        LocalInit {
1366            eq_token: self.eq_token.clone(),
1367            expr: self.expr.clone(),
1368            diverge: self.diverge.clone(),
1369        }
1370    }
1371}
1372#[cfg(any(feature = "derive", feature = "full"))]
1373#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1374impl Clone for Macro {
1375    fn clone(&self) -> Self {
1376        Macro {
1377            path: self.path.clone(),
1378            bang_token: self.bang_token.clone(),
1379            delimiter: self.delimiter.clone(),
1380            tokens: self.tokens.clone(),
1381        }
1382    }
1383}
1384#[cfg(any(feature = "derive", feature = "full"))]
1385#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1386impl Clone for MacroDelimiter {
1387    fn clone(&self) -> Self {
1388        match self {
1389            MacroDelimiter::Paren(v0) => MacroDelimiter::Paren(v0.clone()),
1390            MacroDelimiter::Brace(v0) => MacroDelimiter::Brace(v0.clone()),
1391            MacroDelimiter::Bracket(v0) => MacroDelimiter::Bracket(v0.clone()),
1392        }
1393    }
1394}
1395#[cfg(any(feature = "derive", feature = "full"))]
1396#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1397impl Clone for Member {
1398    fn clone(&self) -> Self {
1399        match self {
1400            Member::Named(v0) => Member::Named(v0.clone()),
1401            Member::Unnamed(v0) => Member::Unnamed(v0.clone()),
1402        }
1403    }
1404}
1405#[cfg(any(feature = "derive", feature = "full"))]
1406#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1407impl Clone for Meta {
1408    fn clone(&self) -> Self {
1409        match self {
1410            Meta::Path(v0) => Meta::Path(v0.clone()),
1411            Meta::List(v0) => Meta::List(v0.clone()),
1412            Meta::NameValue(v0) => Meta::NameValue(v0.clone()),
1413        }
1414    }
1415}
1416#[cfg(any(feature = "derive", feature = "full"))]
1417#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1418impl Clone for MetaList {
1419    fn clone(&self) -> Self {
1420        MetaList {
1421            path: self.path.clone(),
1422            delimiter: self.delimiter.clone(),
1423            tokens: self.tokens.clone(),
1424        }
1425    }
1426}
1427#[cfg(any(feature = "derive", feature = "full"))]
1428#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1429impl Clone for MetaNameValue {
1430    fn clone(&self) -> Self {
1431        MetaNameValue {
1432            path: self.path.clone(),
1433            eq_token: self.eq_token.clone(),
1434            value: self.value.clone(),
1435        }
1436    }
1437}
1438#[cfg(any(feature = "derive", feature = "full"))]
1439#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1440impl Clone for ParenthesizedGenericArguments {
1441    fn clone(&self) -> Self {
1442        ParenthesizedGenericArguments {
1443            paren_token: self.paren_token.clone(),
1444            inputs: self.inputs.clone(),
1445            output: self.output.clone(),
1446        }
1447    }
1448}
1449#[cfg(feature = "full")]
1450#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1451impl Clone for Pat {
1452    fn clone(&self) -> Self {
1453        match self {
1454            Pat::Const(v0) => Pat::Const(v0.clone()),
1455            Pat::Ident(v0) => Pat::Ident(v0.clone()),
1456            Pat::Lit(v0) => Pat::Lit(v0.clone()),
1457            Pat::Macro(v0) => Pat::Macro(v0.clone()),
1458            Pat::Or(v0) => Pat::Or(v0.clone()),
1459            Pat::Paren(v0) => Pat::Paren(v0.clone()),
1460            Pat::Path(v0) => Pat::Path(v0.clone()),
1461            Pat::Range(v0) => Pat::Range(v0.clone()),
1462            Pat::Reference(v0) => Pat::Reference(v0.clone()),
1463            Pat::Rest(v0) => Pat::Rest(v0.clone()),
1464            Pat::Slice(v0) => Pat::Slice(v0.clone()),
1465            Pat::Struct(v0) => Pat::Struct(v0.clone()),
1466            Pat::Tuple(v0) => Pat::Tuple(v0.clone()),
1467            Pat::TupleStruct(v0) => Pat::TupleStruct(v0.clone()),
1468            Pat::Type(v0) => Pat::Type(v0.clone()),
1469            Pat::Verbatim(v0) => Pat::Verbatim(v0.clone()),
1470            Pat::Wild(v0) => Pat::Wild(v0.clone()),
1471        }
1472    }
1473}
1474#[cfg(feature = "full")]
1475#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1476impl Clone for PatIdent {
1477    fn clone(&self) -> Self {
1478        PatIdent {
1479            attrs: self.attrs.clone(),
1480            by_ref: self.by_ref.clone(),
1481            mutability: self.mutability.clone(),
1482            ident: self.ident.clone(),
1483            subpat: self.subpat.clone(),
1484        }
1485    }
1486}
1487#[cfg(feature = "full")]
1488#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1489impl Clone for PatOr {
1490    fn clone(&self) -> Self {
1491        PatOr {
1492            attrs: self.attrs.clone(),
1493            leading_vert: self.leading_vert.clone(),
1494            cases: self.cases.clone(),
1495        }
1496    }
1497}
1498#[cfg(feature = "full")]
1499#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1500impl Clone for PatParen {
1501    fn clone(&self) -> Self {
1502        PatParen {
1503            attrs: self.attrs.clone(),
1504            paren_token: self.paren_token.clone(),
1505            pat: self.pat.clone(),
1506        }
1507    }
1508}
1509#[cfg(feature = "full")]
1510#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1511impl Clone for PatReference {
1512    fn clone(&self) -> Self {
1513        PatReference {
1514            attrs: self.attrs.clone(),
1515            and_token: self.and_token.clone(),
1516            mutability: self.mutability.clone(),
1517            pat: self.pat.clone(),
1518        }
1519    }
1520}
1521#[cfg(feature = "full")]
1522#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1523impl Clone for PatRest {
1524    fn clone(&self) -> Self {
1525        PatRest {
1526            attrs: self.attrs.clone(),
1527            dot2_token: self.dot2_token.clone(),
1528        }
1529    }
1530}
1531#[cfg(feature = "full")]
1532#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1533impl Clone for PatSlice {
1534    fn clone(&self) -> Self {
1535        PatSlice {
1536            attrs: self.attrs.clone(),
1537            bracket_token: self.bracket_token.clone(),
1538            elems: self.elems.clone(),
1539        }
1540    }
1541}
1542#[cfg(feature = "full")]
1543#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1544impl Clone for PatStruct {
1545    fn clone(&self) -> Self {
1546        PatStruct {
1547            attrs: self.attrs.clone(),
1548            qself: self.qself.clone(),
1549            path: self.path.clone(),
1550            brace_token: self.brace_token.clone(),
1551            fields: self.fields.clone(),
1552            rest: self.rest.clone(),
1553        }
1554    }
1555}
1556#[cfg(feature = "full")]
1557#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1558impl Clone for PatTuple {
1559    fn clone(&self) -> Self {
1560        PatTuple {
1561            attrs: self.attrs.clone(),
1562            paren_token: self.paren_token.clone(),
1563            elems: self.elems.clone(),
1564        }
1565    }
1566}
1567#[cfg(feature = "full")]
1568#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1569impl Clone for PatTupleStruct {
1570    fn clone(&self) -> Self {
1571        PatTupleStruct {
1572            attrs: self.attrs.clone(),
1573            qself: self.qself.clone(),
1574            path: self.path.clone(),
1575            paren_token: self.paren_token.clone(),
1576            elems: self.elems.clone(),
1577        }
1578    }
1579}
1580#[cfg(feature = "full")]
1581#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1582impl Clone for PatType {
1583    fn clone(&self) -> Self {
1584        PatType {
1585            attrs: self.attrs.clone(),
1586            pat: self.pat.clone(),
1587            colon_token: self.colon_token.clone(),
1588            ty: self.ty.clone(),
1589        }
1590    }
1591}
1592#[cfg(feature = "full")]
1593#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1594impl Clone for PatWild {
1595    fn clone(&self) -> Self {
1596        PatWild {
1597            attrs: self.attrs.clone(),
1598            underscore_token: self.underscore_token.clone(),
1599        }
1600    }
1601}
1602#[cfg(any(feature = "derive", feature = "full"))]
1603#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1604impl Clone for Path {
1605    fn clone(&self) -> Self {
1606        Path {
1607            leading_colon: self.leading_colon.clone(),
1608            segments: self.segments.clone(),
1609        }
1610    }
1611}
1612#[cfg(any(feature = "derive", feature = "full"))]
1613#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1614impl Clone for PathArguments {
1615    fn clone(&self) -> Self {
1616        match self {
1617            PathArguments::None => PathArguments::None,
1618            PathArguments::AngleBracketed(v0) => {
1619                PathArguments::AngleBracketed(v0.clone())
1620            }
1621            PathArguments::Parenthesized(v0) => PathArguments::Parenthesized(v0.clone()),
1622        }
1623    }
1624}
1625#[cfg(any(feature = "derive", feature = "full"))]
1626#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1627impl Clone for PathSegment {
1628    fn clone(&self) -> Self {
1629        PathSegment {
1630            ident: self.ident.clone(),
1631            arguments: self.arguments.clone(),
1632        }
1633    }
1634}
1635#[cfg(any(feature = "derive", feature = "full"))]
1636#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1637impl Clone for PredicateLifetime {
1638    fn clone(&self) -> Self {
1639        PredicateLifetime {
1640            lifetime: self.lifetime.clone(),
1641            colon_token: self.colon_token.clone(),
1642            bounds: self.bounds.clone(),
1643        }
1644    }
1645}
1646#[cfg(any(feature = "derive", feature = "full"))]
1647#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1648impl Clone for PredicateType {
1649    fn clone(&self) -> Self {
1650        PredicateType {
1651            lifetimes: self.lifetimes.clone(),
1652            bounded_ty: self.bounded_ty.clone(),
1653            colon_token: self.colon_token.clone(),
1654            bounds: self.bounds.clone(),
1655        }
1656    }
1657}
1658#[cfg(any(feature = "derive", feature = "full"))]
1659#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1660impl Clone for QSelf {
1661    fn clone(&self) -> Self {
1662        QSelf {
1663            lt_token: self.lt_token.clone(),
1664            ty: self.ty.clone(),
1665            position: self.position.clone(),
1666            as_token: self.as_token.clone(),
1667            gt_token: self.gt_token.clone(),
1668        }
1669    }
1670}
1671#[cfg(feature = "full")]
1672#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1673impl Copy for RangeLimits {}
1674#[cfg(feature = "full")]
1675#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1676impl Clone for RangeLimits {
1677    fn clone(&self) -> Self {
1678        *self
1679    }
1680}
1681#[cfg(feature = "full")]
1682#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1683impl Clone for Receiver {
1684    fn clone(&self) -> Self {
1685        Receiver {
1686            attrs: self.attrs.clone(),
1687            reference: self.reference.clone(),
1688            mutability: self.mutability.clone(),
1689            self_token: self.self_token.clone(),
1690            colon_token: self.colon_token.clone(),
1691            ty: self.ty.clone(),
1692        }
1693    }
1694}
1695#[cfg(any(feature = "derive", feature = "full"))]
1696#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1697impl Clone for ReturnType {
1698    fn clone(&self) -> Self {
1699        match self {
1700            ReturnType::Default => ReturnType::Default,
1701            ReturnType::Type(v0, v1) => ReturnType::Type(v0.clone(), v1.clone()),
1702        }
1703    }
1704}
1705#[cfg(feature = "full")]
1706#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1707impl Clone for Signature {
1708    fn clone(&self) -> Self {
1709        Signature {
1710            constness: self.constness.clone(),
1711            asyncness: self.asyncness.clone(),
1712            unsafety: self.unsafety.clone(),
1713            abi: self.abi.clone(),
1714            fn_token: self.fn_token.clone(),
1715            ident: self.ident.clone(),
1716            generics: self.generics.clone(),
1717            paren_token: self.paren_token.clone(),
1718            inputs: self.inputs.clone(),
1719            variadic: self.variadic.clone(),
1720            output: self.output.clone(),
1721        }
1722    }
1723}
1724#[cfg(feature = "full")]
1725#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1726impl Clone for StaticMutability {
1727    fn clone(&self) -> Self {
1728        match self {
1729            StaticMutability::Mut(v0) => StaticMutability::Mut(v0.clone()),
1730            StaticMutability::None => StaticMutability::None,
1731        }
1732    }
1733}
1734#[cfg(feature = "full")]
1735#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1736impl Clone for Stmt {
1737    fn clone(&self) -> Self {
1738        match self {
1739            Stmt::Local(v0) => Stmt::Local(v0.clone()),
1740            Stmt::Item(v0) => Stmt::Item(v0.clone()),
1741            Stmt::Expr(v0, v1) => Stmt::Expr(v0.clone(), v1.clone()),
1742            Stmt::Macro(v0) => Stmt::Macro(v0.clone()),
1743        }
1744    }
1745}
1746#[cfg(feature = "full")]
1747#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1748impl Clone for StmtMacro {
1749    fn clone(&self) -> Self {
1750        StmtMacro {
1751            attrs: self.attrs.clone(),
1752            mac: self.mac.clone(),
1753            semi_token: self.semi_token.clone(),
1754        }
1755    }
1756}
1757#[cfg(any(feature = "derive", feature = "full"))]
1758#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1759impl Clone for TraitBound {
1760    fn clone(&self) -> Self {
1761        TraitBound {
1762            paren_token: self.paren_token.clone(),
1763            modifier: self.modifier.clone(),
1764            lifetimes: self.lifetimes.clone(),
1765            path: self.path.clone(),
1766        }
1767    }
1768}
1769#[cfg(any(feature = "derive", feature = "full"))]
1770#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1771impl Copy for TraitBoundModifier {}
1772#[cfg(any(feature = "derive", feature = "full"))]
1773#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1774impl Clone for TraitBoundModifier {
1775    fn clone(&self) -> Self {
1776        *self
1777    }
1778}
1779#[cfg(feature = "full")]
1780#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1781impl Clone for TraitItem {
1782    fn clone(&self) -> Self {
1783        match self {
1784            TraitItem::Const(v0) => TraitItem::Const(v0.clone()),
1785            TraitItem::Fn(v0) => TraitItem::Fn(v0.clone()),
1786            TraitItem::Type(v0) => TraitItem::Type(v0.clone()),
1787            TraitItem::Macro(v0) => TraitItem::Macro(v0.clone()),
1788            TraitItem::Verbatim(v0) => TraitItem::Verbatim(v0.clone()),
1789        }
1790    }
1791}
1792#[cfg(feature = "full")]
1793#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1794impl Clone for TraitItemConst {
1795    fn clone(&self) -> Self {
1796        TraitItemConst {
1797            attrs: self.attrs.clone(),
1798            const_token: self.const_token.clone(),
1799            ident: self.ident.clone(),
1800            generics: self.generics.clone(),
1801            colon_token: self.colon_token.clone(),
1802            ty: self.ty.clone(),
1803            default: self.default.clone(),
1804            semi_token: self.semi_token.clone(),
1805        }
1806    }
1807}
1808#[cfg(feature = "full")]
1809#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1810impl Clone for TraitItemFn {
1811    fn clone(&self) -> Self {
1812        TraitItemFn {
1813            attrs: self.attrs.clone(),
1814            sig: self.sig.clone(),
1815            default: self.default.clone(),
1816            semi_token: self.semi_token.clone(),
1817        }
1818    }
1819}
1820#[cfg(feature = "full")]
1821#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1822impl Clone for TraitItemMacro {
1823    fn clone(&self) -> Self {
1824        TraitItemMacro {
1825            attrs: self.attrs.clone(),
1826            mac: self.mac.clone(),
1827            semi_token: self.semi_token.clone(),
1828        }
1829    }
1830}
1831#[cfg(feature = "full")]
1832#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1833impl Clone for TraitItemType {
1834    fn clone(&self) -> Self {
1835        TraitItemType {
1836            attrs: self.attrs.clone(),
1837            type_token: self.type_token.clone(),
1838            ident: self.ident.clone(),
1839            generics: self.generics.clone(),
1840            colon_token: self.colon_token.clone(),
1841            bounds: self.bounds.clone(),
1842            default: self.default.clone(),
1843            semi_token: self.semi_token.clone(),
1844        }
1845    }
1846}
1847#[cfg(any(feature = "derive", feature = "full"))]
1848#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1849impl Clone for Type {
1850    fn clone(&self) -> Self {
1851        match self {
1852            Type::Array(v0) => Type::Array(v0.clone()),
1853            Type::BareFn(v0) => Type::BareFn(v0.clone()),
1854            Type::Group(v0) => Type::Group(v0.clone()),
1855            Type::ImplTrait(v0) => Type::ImplTrait(v0.clone()),
1856            Type::Infer(v0) => Type::Infer(v0.clone()),
1857            Type::Macro(v0) => Type::Macro(v0.clone()),
1858            Type::Never(v0) => Type::Never(v0.clone()),
1859            Type::Paren(v0) => Type::Paren(v0.clone()),
1860            Type::Path(v0) => Type::Path(v0.clone()),
1861            Type::Ptr(v0) => Type::Ptr(v0.clone()),
1862            Type::Reference(v0) => Type::Reference(v0.clone()),
1863            Type::Slice(v0) => Type::Slice(v0.clone()),
1864            Type::TraitObject(v0) => Type::TraitObject(v0.clone()),
1865            Type::Tuple(v0) => Type::Tuple(v0.clone()),
1866            Type::Verbatim(v0) => Type::Verbatim(v0.clone()),
1867        }
1868    }
1869}
1870#[cfg(any(feature = "derive", feature = "full"))]
1871#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1872impl Clone for TypeArray {
1873    fn clone(&self) -> Self {
1874        TypeArray {
1875            bracket_token: self.bracket_token.clone(),
1876            elem: self.elem.clone(),
1877            semi_token: self.semi_token.clone(),
1878            len: self.len.clone(),
1879        }
1880    }
1881}
1882#[cfg(any(feature = "derive", feature = "full"))]
1883#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1884impl Clone for TypeBareFn {
1885    fn clone(&self) -> Self {
1886        TypeBareFn {
1887            lifetimes: self.lifetimes.clone(),
1888            unsafety: self.unsafety.clone(),
1889            abi: self.abi.clone(),
1890            fn_token: self.fn_token.clone(),
1891            paren_token: self.paren_token.clone(),
1892            inputs: self.inputs.clone(),
1893            variadic: self.variadic.clone(),
1894            output: self.output.clone(),
1895        }
1896    }
1897}
1898#[cfg(any(feature = "derive", feature = "full"))]
1899#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1900impl Clone for TypeGroup {
1901    fn clone(&self) -> Self {
1902        TypeGroup {
1903            group_token: self.group_token.clone(),
1904            elem: self.elem.clone(),
1905        }
1906    }
1907}
1908#[cfg(any(feature = "derive", feature = "full"))]
1909#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1910impl Clone for TypeImplTrait {
1911    fn clone(&self) -> Self {
1912        TypeImplTrait {
1913            impl_token: self.impl_token.clone(),
1914            bounds: self.bounds.clone(),
1915        }
1916    }
1917}
1918#[cfg(any(feature = "derive", feature = "full"))]
1919#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1920impl Clone for TypeInfer {
1921    fn clone(&self) -> Self {
1922        TypeInfer {
1923            underscore_token: self.underscore_token.clone(),
1924        }
1925    }
1926}
1927#[cfg(any(feature = "derive", feature = "full"))]
1928#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1929impl Clone for TypeMacro {
1930    fn clone(&self) -> Self {
1931        TypeMacro { mac: self.mac.clone() }
1932    }
1933}
1934#[cfg(any(feature = "derive", feature = "full"))]
1935#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1936impl Clone for TypeNever {
1937    fn clone(&self) -> Self {
1938        TypeNever {
1939            bang_token: self.bang_token.clone(),
1940        }
1941    }
1942}
1943#[cfg(any(feature = "derive", feature = "full"))]
1944#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1945impl Clone for TypeParam {
1946    fn clone(&self) -> Self {
1947        TypeParam {
1948            attrs: self.attrs.clone(),
1949            ident: self.ident.clone(),
1950            colon_token: self.colon_token.clone(),
1951            bounds: self.bounds.clone(),
1952            eq_token: self.eq_token.clone(),
1953            default: self.default.clone(),
1954        }
1955    }
1956}
1957#[cfg(any(feature = "derive", feature = "full"))]
1958#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1959impl Clone for TypeParamBound {
1960    fn clone(&self) -> Self {
1961        match self {
1962            TypeParamBound::Trait(v0) => TypeParamBound::Trait(v0.clone()),
1963            TypeParamBound::Lifetime(v0) => TypeParamBound::Lifetime(v0.clone()),
1964            TypeParamBound::Verbatim(v0) => TypeParamBound::Verbatim(v0.clone()),
1965        }
1966    }
1967}
1968#[cfg(any(feature = "derive", feature = "full"))]
1969#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1970impl Clone for TypeParen {
1971    fn clone(&self) -> Self {
1972        TypeParen {
1973            paren_token: self.paren_token.clone(),
1974            elem: self.elem.clone(),
1975        }
1976    }
1977}
1978#[cfg(any(feature = "derive", feature = "full"))]
1979#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1980impl Clone for TypePath {
1981    fn clone(&self) -> Self {
1982        TypePath {
1983            qself: self.qself.clone(),
1984            path: self.path.clone(),
1985        }
1986    }
1987}
1988#[cfg(any(feature = "derive", feature = "full"))]
1989#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
1990impl Clone for TypePtr {
1991    fn clone(&self) -> Self {
1992        TypePtr {
1993            star_token: self.star_token.clone(),
1994            const_token: self.const_token.clone(),
1995            mutability: self.mutability.clone(),
1996            elem: self.elem.clone(),
1997        }
1998    }
1999}
2000#[cfg(any(feature = "derive", feature = "full"))]
2001#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2002impl Clone for TypeReference {
2003    fn clone(&self) -> Self {
2004        TypeReference {
2005            and_token: self.and_token.clone(),
2006            lifetime: self.lifetime.clone(),
2007            mutability: self.mutability.clone(),
2008            elem: self.elem.clone(),
2009        }
2010    }
2011}
2012#[cfg(any(feature = "derive", feature = "full"))]
2013#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2014impl Clone for TypeSlice {
2015    fn clone(&self) -> Self {
2016        TypeSlice {
2017            bracket_token: self.bracket_token.clone(),
2018            elem: self.elem.clone(),
2019        }
2020    }
2021}
2022#[cfg(any(feature = "derive", feature = "full"))]
2023#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2024impl Clone for TypeTraitObject {
2025    fn clone(&self) -> Self {
2026        TypeTraitObject {
2027            dyn_token: self.dyn_token.clone(),
2028            bounds: self.bounds.clone(),
2029        }
2030    }
2031}
2032#[cfg(any(feature = "derive", feature = "full"))]
2033#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2034impl Clone for TypeTuple {
2035    fn clone(&self) -> Self {
2036        TypeTuple {
2037            paren_token: self.paren_token.clone(),
2038            elems: self.elems.clone(),
2039        }
2040    }
2041}
2042#[cfg(any(feature = "derive", feature = "full"))]
2043#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2044impl Copy for UnOp {}
2045#[cfg(any(feature = "derive", feature = "full"))]
2046#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2047impl Clone for UnOp {
2048    fn clone(&self) -> Self {
2049        *self
2050    }
2051}
2052#[cfg(feature = "full")]
2053#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2054impl Clone for UseGlob {
2055    fn clone(&self) -> Self {
2056        UseGlob {
2057            star_token: self.star_token.clone(),
2058        }
2059    }
2060}
2061#[cfg(feature = "full")]
2062#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2063impl Clone for UseGroup {
2064    fn clone(&self) -> Self {
2065        UseGroup {
2066            brace_token: self.brace_token.clone(),
2067            items: self.items.clone(),
2068        }
2069    }
2070}
2071#[cfg(feature = "full")]
2072#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2073impl Clone for UseName {
2074    fn clone(&self) -> Self {
2075        UseName {
2076            ident: self.ident.clone(),
2077        }
2078    }
2079}
2080#[cfg(feature = "full")]
2081#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2082impl Clone for UsePath {
2083    fn clone(&self) -> Self {
2084        UsePath {
2085            ident: self.ident.clone(),
2086            colon2_token: self.colon2_token.clone(),
2087            tree: self.tree.clone(),
2088        }
2089    }
2090}
2091#[cfg(feature = "full")]
2092#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2093impl Clone for UseRename {
2094    fn clone(&self) -> Self {
2095        UseRename {
2096            ident: self.ident.clone(),
2097            as_token: self.as_token.clone(),
2098            rename: self.rename.clone(),
2099        }
2100    }
2101}
2102#[cfg(feature = "full")]
2103#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2104impl Clone for UseTree {
2105    fn clone(&self) -> Self {
2106        match self {
2107            UseTree::Path(v0) => UseTree::Path(v0.clone()),
2108            UseTree::Name(v0) => UseTree::Name(v0.clone()),
2109            UseTree::Rename(v0) => UseTree::Rename(v0.clone()),
2110            UseTree::Glob(v0) => UseTree::Glob(v0.clone()),
2111            UseTree::Group(v0) => UseTree::Group(v0.clone()),
2112        }
2113    }
2114}
2115#[cfg(feature = "full")]
2116#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2117impl Clone for Variadic {
2118    fn clone(&self) -> Self {
2119        Variadic {
2120            attrs: self.attrs.clone(),
2121            pat: self.pat.clone(),
2122            dots: self.dots.clone(),
2123            comma: self.comma.clone(),
2124        }
2125    }
2126}
2127#[cfg(any(feature = "derive", feature = "full"))]
2128#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2129impl Clone for Variant {
2130    fn clone(&self) -> Self {
2131        Variant {
2132            attrs: self.attrs.clone(),
2133            ident: self.ident.clone(),
2134            fields: self.fields.clone(),
2135            discriminant: self.discriminant.clone(),
2136        }
2137    }
2138}
2139#[cfg(any(feature = "derive", feature = "full"))]
2140#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2141impl Clone for VisRestricted {
2142    fn clone(&self) -> Self {
2143        VisRestricted {
2144            pub_token: self.pub_token.clone(),
2145            paren_token: self.paren_token.clone(),
2146            in_token: self.in_token.clone(),
2147            path: self.path.clone(),
2148        }
2149    }
2150}
2151#[cfg(any(feature = "derive", feature = "full"))]
2152#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2153impl Clone for Visibility {
2154    fn clone(&self) -> Self {
2155        match self {
2156            Visibility::Public(v0) => Visibility::Public(v0.clone()),
2157            Visibility::Restricted(v0) => Visibility::Restricted(v0.clone()),
2158            Visibility::Inherited => Visibility::Inherited,
2159        }
2160    }
2161}
2162#[cfg(any(feature = "derive", feature = "full"))]
2163#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2164impl Clone for WhereClause {
2165    fn clone(&self) -> Self {
2166        WhereClause {
2167            where_token: self.where_token.clone(),
2168            predicates: self.predicates.clone(),
2169        }
2170    }
2171}
2172#[cfg(any(feature = "derive", feature = "full"))]
2173#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
2174impl Clone for WherePredicate {
2175    fn clone(&self) -> Self {
2176        match self {
2177            WherePredicate::Lifetime(v0) => WherePredicate::Lifetime(v0.clone()),
2178            WherePredicate::Type(v0) => WherePredicate::Type(v0.clone()),
2179        }
2180    }
2181}
2182