syn/gen/
clone.rs

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

syn/gen/
clone.rs
