From a990de90fe41456a23e58bd087d2f107d321f3a1 Mon Sep 17 00:00:00 2001
From: Valentin Popov <valentin@popov.link>
Date: Fri, 19 Jul 2024 16:37:58 +0400
Subject: Deleted vendor folder

---
 vendor/syn/src/gen/clone.rs | 2181 -------------------------------------------
 1 file changed, 2181 deletions(-)
 delete mode 100644 vendor/syn/src/gen/clone.rs

(limited to 'vendor/syn/src/gen/clone.rs')

diff --git a/vendor/syn/src/gen/clone.rs b/vendor/syn/src/gen/clone.rs
deleted file mode 100644
index 9593679..0000000
--- a/vendor/syn/src/gen/clone.rs
+++ /dev/null
@@ -1,2181 +0,0 @@
-// This file is @generated by syn-internal-codegen.
-// It is not intended for manual editing.
-
-#![allow(clippy::clone_on_copy, clippy::expl_impl_clone_on_copy)]
-use crate::*;
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Abi {
-    fn clone(&self) -> Self {
-        Abi {
-            extern_token: self.extern_token.clone(),
-            name: self.name.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for AngleBracketedGenericArguments {
-    fn clone(&self) -> Self {
-        AngleBracketedGenericArguments {
-            colon2_token: self.colon2_token.clone(),
-            lt_token: self.lt_token.clone(),
-            args: self.args.clone(),
-            gt_token: self.gt_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Arm {
-    fn clone(&self) -> Self {
-        Arm {
-            attrs: self.attrs.clone(),
-            pat: self.pat.clone(),
-            guard: self.guard.clone(),
-            fat_arrow_token: self.fat_arrow_token.clone(),
-            body: self.body.clone(),
-            comma: self.comma.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for AssocConst {
-    fn clone(&self) -> Self {
-        AssocConst {
-            ident: self.ident.clone(),
-            generics: self.generics.clone(),
-            eq_token: self.eq_token.clone(),
-            value: self.value.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for AssocType {
-    fn clone(&self) -> Self {
-        AssocType {
-            ident: self.ident.clone(),
-            generics: self.generics.clone(),
-            eq_token: self.eq_token.clone(),
-            ty: self.ty.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Copy for AttrStyle {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for AttrStyle {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Attribute {
-    fn clone(&self) -> Self {
-        Attribute {
-            pound_token: self.pound_token.clone(),
-            style: self.style.clone(),
-            bracket_token: self.bracket_token.clone(),
-            meta: self.meta.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for BareFnArg {
-    fn clone(&self) -> Self {
-        BareFnArg {
-            attrs: self.attrs.clone(),
-            name: self.name.clone(),
-            ty: self.ty.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for BareVariadic {
-    fn clone(&self) -> Self {
-        BareVariadic {
-            attrs: self.attrs.clone(),
-            name: self.name.clone(),
-            dots: self.dots.clone(),
-            comma: self.comma.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Copy for BinOp {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for BinOp {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Block {
-    fn clone(&self) -> Self {
-        Block {
-            brace_token: self.brace_token.clone(),
-            stmts: self.stmts.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for BoundLifetimes {
-    fn clone(&self) -> Self {
-        BoundLifetimes {
-            for_token: self.for_token.clone(),
-            lt_token: self.lt_token.clone(),
-            lifetimes: self.lifetimes.clone(),
-            gt_token: self.gt_token.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ConstParam {
-    fn clone(&self) -> Self {
-        ConstParam {
-            attrs: self.attrs.clone(),
-            const_token: self.const_token.clone(),
-            ident: self.ident.clone(),
-            colon_token: self.colon_token.clone(),
-            ty: self.ty.clone(),
-            eq_token: self.eq_token.clone(),
-            default: self.default.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Constraint {
-    fn clone(&self) -> Self {
-        Constraint {
-            ident: self.ident.clone(),
-            generics: self.generics.clone(),
-            colon_token: self.colon_token.clone(),
-            bounds: self.bounds.clone(),
-        }
-    }
-}
-#[cfg(feature = "derive")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Data {
-    fn clone(&self) -> Self {
-        match self {
-            Data::Struct(v0) => Data::Struct(v0.clone()),
-            Data::Enum(v0) => Data::Enum(v0.clone()),
-            Data::Union(v0) => Data::Union(v0.clone()),
-        }
-    }
-}
-#[cfg(feature = "derive")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for DataEnum {
-    fn clone(&self) -> Self {
-        DataEnum {
-            enum_token: self.enum_token.clone(),
-            brace_token: self.brace_token.clone(),
-            variants: self.variants.clone(),
-        }
-    }
-}
-#[cfg(feature = "derive")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for DataStruct {
-    fn clone(&self) -> Self {
-        DataStruct {
-            struct_token: self.struct_token.clone(),
-            fields: self.fields.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "derive")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for DataUnion {
-    fn clone(&self) -> Self {
-        DataUnion {
-            union_token: self.union_token.clone(),
-            fields: self.fields.clone(),
-        }
-    }
-}
-#[cfg(feature = "derive")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for DeriveInput {
-    fn clone(&self) -> Self {
-        DeriveInput {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            ident: self.ident.clone(),
-            generics: self.generics.clone(),
-            data: self.data.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Expr {
-    fn clone(&self) -> Self {
-        match self {
-            #[cfg(feature = "full")]
-            Expr::Array(v0) => Expr::Array(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Assign(v0) => Expr::Assign(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Async(v0) => Expr::Async(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Await(v0) => Expr::Await(v0.clone()),
-            Expr::Binary(v0) => Expr::Binary(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Block(v0) => Expr::Block(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Break(v0) => Expr::Break(v0.clone()),
-            Expr::Call(v0) => Expr::Call(v0.clone()),
-            Expr::Cast(v0) => Expr::Cast(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Closure(v0) => Expr::Closure(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Const(v0) => Expr::Const(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Continue(v0) => Expr::Continue(v0.clone()),
-            Expr::Field(v0) => Expr::Field(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::ForLoop(v0) => Expr::ForLoop(v0.clone()),
-            Expr::Group(v0) => Expr::Group(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::If(v0) => Expr::If(v0.clone()),
-            Expr::Index(v0) => Expr::Index(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Infer(v0) => Expr::Infer(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Let(v0) => Expr::Let(v0.clone()),
-            Expr::Lit(v0) => Expr::Lit(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Loop(v0) => Expr::Loop(v0.clone()),
-            Expr::Macro(v0) => Expr::Macro(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Match(v0) => Expr::Match(v0.clone()),
-            Expr::MethodCall(v0) => Expr::MethodCall(v0.clone()),
-            Expr::Paren(v0) => Expr::Paren(v0.clone()),
-            Expr::Path(v0) => Expr::Path(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Range(v0) => Expr::Range(v0.clone()),
-            Expr::Reference(v0) => Expr::Reference(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Repeat(v0) => Expr::Repeat(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Return(v0) => Expr::Return(v0.clone()),
-            Expr::Struct(v0) => Expr::Struct(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Try(v0) => Expr::Try(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::TryBlock(v0) => Expr::TryBlock(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Tuple(v0) => Expr::Tuple(v0.clone()),
-            Expr::Unary(v0) => Expr::Unary(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Unsafe(v0) => Expr::Unsafe(v0.clone()),
-            Expr::Verbatim(v0) => Expr::Verbatim(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::While(v0) => Expr::While(v0.clone()),
-            #[cfg(feature = "full")]
-            Expr::Yield(v0) => Expr::Yield(v0.clone()),
-            #[cfg(not(feature = "full"))]
-            _ => unreachable!(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprArray {
-    fn clone(&self) -> Self {
-        ExprArray {
-            attrs: self.attrs.clone(),
-            bracket_token: self.bracket_token.clone(),
-            elems: self.elems.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprAssign {
-    fn clone(&self) -> Self {
-        ExprAssign {
-            attrs: self.attrs.clone(),
-            left: self.left.clone(),
-            eq_token: self.eq_token.clone(),
-            right: self.right.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprAsync {
-    fn clone(&self) -> Self {
-        ExprAsync {
-            attrs: self.attrs.clone(),
-            async_token: self.async_token.clone(),
-            capture: self.capture.clone(),
-            block: self.block.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprAwait {
-    fn clone(&self) -> Self {
-        ExprAwait {
-            attrs: self.attrs.clone(),
-            base: self.base.clone(),
-            dot_token: self.dot_token.clone(),
-            await_token: self.await_token.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprBinary {
-    fn clone(&self) -> Self {
-        ExprBinary {
-            attrs: self.attrs.clone(),
-            left: self.left.clone(),
-            op: self.op.clone(),
-            right: self.right.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprBlock {
-    fn clone(&self) -> Self {
-        ExprBlock {
-            attrs: self.attrs.clone(),
-            label: self.label.clone(),
-            block: self.block.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprBreak {
-    fn clone(&self) -> Self {
-        ExprBreak {
-            attrs: self.attrs.clone(),
-            break_token: self.break_token.clone(),
-            label: self.label.clone(),
-            expr: self.expr.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprCall {
-    fn clone(&self) -> Self {
-        ExprCall {
-            attrs: self.attrs.clone(),
-            func: self.func.clone(),
-            paren_token: self.paren_token.clone(),
-            args: self.args.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprCast {
-    fn clone(&self) -> Self {
-        ExprCast {
-            attrs: self.attrs.clone(),
-            expr: self.expr.clone(),
-            as_token: self.as_token.clone(),
-            ty: self.ty.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprClosure {
-    fn clone(&self) -> Self {
-        ExprClosure {
-            attrs: self.attrs.clone(),
-            lifetimes: self.lifetimes.clone(),
-            constness: self.constness.clone(),
-            movability: self.movability.clone(),
-            asyncness: self.asyncness.clone(),
-            capture: self.capture.clone(),
-            or1_token: self.or1_token.clone(),
-            inputs: self.inputs.clone(),
-            or2_token: self.or2_token.clone(),
-            output: self.output.clone(),
-            body: self.body.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprConst {
-    fn clone(&self) -> Self {
-        ExprConst {
-            attrs: self.attrs.clone(),
-            const_token: self.const_token.clone(),
-            block: self.block.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprContinue {
-    fn clone(&self) -> Self {
-        ExprContinue {
-            attrs: self.attrs.clone(),
-            continue_token: self.continue_token.clone(),
-            label: self.label.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprField {
-    fn clone(&self) -> Self {
-        ExprField {
-            attrs: self.attrs.clone(),
-            base: self.base.clone(),
-            dot_token: self.dot_token.clone(),
-            member: self.member.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprForLoop {
-    fn clone(&self) -> Self {
-        ExprForLoop {
-            attrs: self.attrs.clone(),
-            label: self.label.clone(),
-            for_token: self.for_token.clone(),
-            pat: self.pat.clone(),
-            in_token: self.in_token.clone(),
-            expr: self.expr.clone(),
-            body: self.body.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprGroup {
-    fn clone(&self) -> Self {
-        ExprGroup {
-            attrs: self.attrs.clone(),
-            group_token: self.group_token.clone(),
-            expr: self.expr.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprIf {
-    fn clone(&self) -> Self {
-        ExprIf {
-            attrs: self.attrs.clone(),
-            if_token: self.if_token.clone(),
-            cond: self.cond.clone(),
-            then_branch: self.then_branch.clone(),
-            else_branch: self.else_branch.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprIndex {
-    fn clone(&self) -> Self {
-        ExprIndex {
-            attrs: self.attrs.clone(),
-            expr: self.expr.clone(),
-            bracket_token: self.bracket_token.clone(),
-            index: self.index.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprInfer {
-    fn clone(&self) -> Self {
-        ExprInfer {
-            attrs: self.attrs.clone(),
-            underscore_token: self.underscore_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprLet {
-    fn clone(&self) -> Self {
-        ExprLet {
-            attrs: self.attrs.clone(),
-            let_token: self.let_token.clone(),
-            pat: self.pat.clone(),
-            eq_token: self.eq_token.clone(),
-            expr: self.expr.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprLit {
-    fn clone(&self) -> Self {
-        ExprLit {
-            attrs: self.attrs.clone(),
-            lit: self.lit.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprLoop {
-    fn clone(&self) -> Self {
-        ExprLoop {
-            attrs: self.attrs.clone(),
-            label: self.label.clone(),
-            loop_token: self.loop_token.clone(),
-            body: self.body.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprMacro {
-    fn clone(&self) -> Self {
-        ExprMacro {
-            attrs: self.attrs.clone(),
-            mac: self.mac.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprMatch {
-    fn clone(&self) -> Self {
-        ExprMatch {
-            attrs: self.attrs.clone(),
-            match_token: self.match_token.clone(),
-            expr: self.expr.clone(),
-            brace_token: self.brace_token.clone(),
-            arms: self.arms.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprMethodCall {
-    fn clone(&self) -> Self {
-        ExprMethodCall {
-            attrs: self.attrs.clone(),
-            receiver: self.receiver.clone(),
-            dot_token: self.dot_token.clone(),
-            method: self.method.clone(),
-            turbofish: self.turbofish.clone(),
-            paren_token: self.paren_token.clone(),
-            args: self.args.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprParen {
-    fn clone(&self) -> Self {
-        ExprParen {
-            attrs: self.attrs.clone(),
-            paren_token: self.paren_token.clone(),
-            expr: self.expr.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprPath {
-    fn clone(&self) -> Self {
-        ExprPath {
-            attrs: self.attrs.clone(),
-            qself: self.qself.clone(),
-            path: self.path.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprRange {
-    fn clone(&self) -> Self {
-        ExprRange {
-            attrs: self.attrs.clone(),
-            start: self.start.clone(),
-            limits: self.limits.clone(),
-            end: self.end.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprReference {
-    fn clone(&self) -> Self {
-        ExprReference {
-            attrs: self.attrs.clone(),
-            and_token: self.and_token.clone(),
-            mutability: self.mutability.clone(),
-            expr: self.expr.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprRepeat {
-    fn clone(&self) -> Self {
-        ExprRepeat {
-            attrs: self.attrs.clone(),
-            bracket_token: self.bracket_token.clone(),
-            expr: self.expr.clone(),
-            semi_token: self.semi_token.clone(),
-            len: self.len.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprReturn {
-    fn clone(&self) -> Self {
-        ExprReturn {
-            attrs: self.attrs.clone(),
-            return_token: self.return_token.clone(),
-            expr: self.expr.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprStruct {
-    fn clone(&self) -> Self {
-        ExprStruct {
-            attrs: self.attrs.clone(),
-            qself: self.qself.clone(),
-            path: self.path.clone(),
-            brace_token: self.brace_token.clone(),
-            fields: self.fields.clone(),
-            dot2_token: self.dot2_token.clone(),
-            rest: self.rest.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprTry {
-    fn clone(&self) -> Self {
-        ExprTry {
-            attrs: self.attrs.clone(),
-            expr: self.expr.clone(),
-            question_token: self.question_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprTryBlock {
-    fn clone(&self) -> Self {
-        ExprTryBlock {
-            attrs: self.attrs.clone(),
-            try_token: self.try_token.clone(),
-            block: self.block.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprTuple {
-    fn clone(&self) -> Self {
-        ExprTuple {
-            attrs: self.attrs.clone(),
-            paren_token: self.paren_token.clone(),
-            elems: self.elems.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprUnary {
-    fn clone(&self) -> Self {
-        ExprUnary {
-            attrs: self.attrs.clone(),
-            op: self.op.clone(),
-            expr: self.expr.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprUnsafe {
-    fn clone(&self) -> Self {
-        ExprUnsafe {
-            attrs: self.attrs.clone(),
-            unsafe_token: self.unsafe_token.clone(),
-            block: self.block.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprWhile {
-    fn clone(&self) -> Self {
-        ExprWhile {
-            attrs: self.attrs.clone(),
-            label: self.label.clone(),
-            while_token: self.while_token.clone(),
-            cond: self.cond.clone(),
-            body: self.body.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ExprYield {
-    fn clone(&self) -> Self {
-        ExprYield {
-            attrs: self.attrs.clone(),
-            yield_token: self.yield_token.clone(),
-            expr: self.expr.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Field {
-    fn clone(&self) -> Self {
-        Field {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            mutability: self.mutability.clone(),
-            ident: self.ident.clone(),
-            colon_token: self.colon_token.clone(),
-            ty: self.ty.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for FieldMutability {
-    fn clone(&self) -> Self {
-        match self {
-            FieldMutability::None => FieldMutability::None,
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for FieldPat {
-    fn clone(&self) -> Self {
-        FieldPat {
-            attrs: self.attrs.clone(),
-            member: self.member.clone(),
-            colon_token: self.colon_token.clone(),
-            pat: self.pat.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for FieldValue {
-    fn clone(&self) -> Self {
-        FieldValue {
-            attrs: self.attrs.clone(),
-            member: self.member.clone(),
-            colon_token: self.colon_token.clone(),
-            expr: self.expr.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Fields {
-    fn clone(&self) -> Self {
-        match self {
-            Fields::Named(v0) => Fields::Named(v0.clone()),
-            Fields::Unnamed(v0) => Fields::Unnamed(v0.clone()),
-            Fields::Unit => Fields::Unit,
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for FieldsNamed {
-    fn clone(&self) -> Self {
-        FieldsNamed {
-            brace_token: self.brace_token.clone(),
-            named: self.named.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for FieldsUnnamed {
-    fn clone(&self) -> Self {
-        FieldsUnnamed {
-            paren_token: self.paren_token.clone(),
-            unnamed: self.unnamed.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for File {
-    fn clone(&self) -> Self {
-        File {
-            shebang: self.shebang.clone(),
-            attrs: self.attrs.clone(),
-            items: self.items.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for FnArg {
-    fn clone(&self) -> Self {
-        match self {
-            FnArg::Receiver(v0) => FnArg::Receiver(v0.clone()),
-            FnArg::Typed(v0) => FnArg::Typed(v0.clone()),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ForeignItem {
-    fn clone(&self) -> Self {
-        match self {
-            ForeignItem::Fn(v0) => ForeignItem::Fn(v0.clone()),
-            ForeignItem::Static(v0) => ForeignItem::Static(v0.clone()),
-            ForeignItem::Type(v0) => ForeignItem::Type(v0.clone()),
-            ForeignItem::Macro(v0) => ForeignItem::Macro(v0.clone()),
-            ForeignItem::Verbatim(v0) => ForeignItem::Verbatim(v0.clone()),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ForeignItemFn {
-    fn clone(&self) -> Self {
-        ForeignItemFn {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            sig: self.sig.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ForeignItemMacro {
-    fn clone(&self) -> Self {
-        ForeignItemMacro {
-            attrs: self.attrs.clone(),
-            mac: self.mac.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ForeignItemStatic {
-    fn clone(&self) -> Self {
-        ForeignItemStatic {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            static_token: self.static_token.clone(),
-            mutability: self.mutability.clone(),
-            ident: self.ident.clone(),
-            colon_token: self.colon_token.clone(),
-            ty: self.ty.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ForeignItemType {
-    fn clone(&self) -> Self {
-        ForeignItemType {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            type_token: self.type_token.clone(),
-            ident: self.ident.clone(),
-            generics: self.generics.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for GenericArgument {
-    fn clone(&self) -> Self {
-        match self {
-            GenericArgument::Lifetime(v0) => GenericArgument::Lifetime(v0.clone()),
-            GenericArgument::Type(v0) => GenericArgument::Type(v0.clone()),
-            GenericArgument::Const(v0) => GenericArgument::Const(v0.clone()),
-            GenericArgument::AssocType(v0) => GenericArgument::AssocType(v0.clone()),
-            GenericArgument::AssocConst(v0) => GenericArgument::AssocConst(v0.clone()),
-            GenericArgument::Constraint(v0) => GenericArgument::Constraint(v0.clone()),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for GenericParam {
-    fn clone(&self) -> Self {
-        match self {
-            GenericParam::Lifetime(v0) => GenericParam::Lifetime(v0.clone()),
-            GenericParam::Type(v0) => GenericParam::Type(v0.clone()),
-            GenericParam::Const(v0) => GenericParam::Const(v0.clone()),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Generics {
-    fn clone(&self) -> Self {
-        Generics {
-            lt_token: self.lt_token.clone(),
-            params: self.params.clone(),
-            gt_token: self.gt_token.clone(),
-            where_clause: self.where_clause.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ImplItem {
-    fn clone(&self) -> Self {
-        match self {
-            ImplItem::Const(v0) => ImplItem::Const(v0.clone()),
-            ImplItem::Fn(v0) => ImplItem::Fn(v0.clone()),
-            ImplItem::Type(v0) => ImplItem::Type(v0.clone()),
-            ImplItem::Macro(v0) => ImplItem::Macro(v0.clone()),
-            ImplItem::Verbatim(v0) => ImplItem::Verbatim(v0.clone()),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ImplItemConst {
-    fn clone(&self) -> Self {
-        ImplItemConst {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            defaultness: self.defaultness.clone(),
-            const_token: self.const_token.clone(),
-            ident: self.ident.clone(),
-            generics: self.generics.clone(),
-            colon_token: self.colon_token.clone(),
-            ty: self.ty.clone(),
-            eq_token: self.eq_token.clone(),
-            expr: self.expr.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ImplItemFn {
-    fn clone(&self) -> Self {
-        ImplItemFn {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            defaultness: self.defaultness.clone(),
-            sig: self.sig.clone(),
-            block: self.block.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ImplItemMacro {
-    fn clone(&self) -> Self {
-        ImplItemMacro {
-            attrs: self.attrs.clone(),
-            mac: self.mac.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ImplItemType {
-    fn clone(&self) -> Self {
-        ImplItemType {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            defaultness: self.defaultness.clone(),
-            type_token: self.type_token.clone(),
-            ident: self.ident.clone(),
-            generics: self.generics.clone(),
-            eq_token: self.eq_token.clone(),
-            ty: self.ty.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ImplRestriction {
-    fn clone(&self) -> Self {
-        match *self {}
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Index {
-    fn clone(&self) -> Self {
-        Index {
-            index: self.index.clone(),
-            span: self.span.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Item {
-    fn clone(&self) -> Self {
-        match self {
-            Item::Const(v0) => Item::Const(v0.clone()),
-            Item::Enum(v0) => Item::Enum(v0.clone()),
-            Item::ExternCrate(v0) => Item::ExternCrate(v0.clone()),
-            Item::Fn(v0) => Item::Fn(v0.clone()),
-            Item::ForeignMod(v0) => Item::ForeignMod(v0.clone()),
-            Item::Impl(v0) => Item::Impl(v0.clone()),
-            Item::Macro(v0) => Item::Macro(v0.clone()),
-            Item::Mod(v0) => Item::Mod(v0.clone()),
-            Item::Static(v0) => Item::Static(v0.clone()),
-            Item::Struct(v0) => Item::Struct(v0.clone()),
-            Item::Trait(v0) => Item::Trait(v0.clone()),
-            Item::TraitAlias(v0) => Item::TraitAlias(v0.clone()),
-            Item::Type(v0) => Item::Type(v0.clone()),
-            Item::Union(v0) => Item::Union(v0.clone()),
-            Item::Use(v0) => Item::Use(v0.clone()),
-            Item::Verbatim(v0) => Item::Verbatim(v0.clone()),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ItemConst {
-    fn clone(&self) -> Self {
-        ItemConst {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            const_token: self.const_token.clone(),
-            ident: self.ident.clone(),
-            generics: self.generics.clone(),
-            colon_token: self.colon_token.clone(),
-            ty: self.ty.clone(),
-            eq_token: self.eq_token.clone(),
-            expr: self.expr.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ItemEnum {
-    fn clone(&self) -> Self {
-        ItemEnum {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            enum_token: self.enum_token.clone(),
-            ident: self.ident.clone(),
-            generics: self.generics.clone(),
-            brace_token: self.brace_token.clone(),
-            variants: self.variants.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ItemExternCrate {
-    fn clone(&self) -> Self {
-        ItemExternCrate {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            extern_token: self.extern_token.clone(),
-            crate_token: self.crate_token.clone(),
-            ident: self.ident.clone(),
-            rename: self.rename.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ItemFn {
-    fn clone(&self) -> Self {
-        ItemFn {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            sig: self.sig.clone(),
-            block: self.block.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ItemForeignMod {
-    fn clone(&self) -> Self {
-        ItemForeignMod {
-            attrs: self.attrs.clone(),
-            unsafety: self.unsafety.clone(),
-            abi: self.abi.clone(),
-            brace_token: self.brace_token.clone(),
-            items: self.items.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ItemImpl {
-    fn clone(&self) -> Self {
-        ItemImpl {
-            attrs: self.attrs.clone(),
-            defaultness: self.defaultness.clone(),
-            unsafety: self.unsafety.clone(),
-            impl_token: self.impl_token.clone(),
-            generics: self.generics.clone(),
-            trait_: self.trait_.clone(),
-            self_ty: self.self_ty.clone(),
-            brace_token: self.brace_token.clone(),
-            items: self.items.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ItemMacro {
-    fn clone(&self) -> Self {
-        ItemMacro {
-            attrs: self.attrs.clone(),
-            ident: self.ident.clone(),
-            mac: self.mac.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ItemMod {
-    fn clone(&self) -> Self {
-        ItemMod {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            unsafety: self.unsafety.clone(),
-            mod_token: self.mod_token.clone(),
-            ident: self.ident.clone(),
-            content: self.content.clone(),
-            semi: self.semi.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ItemStatic {
-    fn clone(&self) -> Self {
-        ItemStatic {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            static_token: self.static_token.clone(),
-            mutability: self.mutability.clone(),
-            ident: self.ident.clone(),
-            colon_token: self.colon_token.clone(),
-            ty: self.ty.clone(),
-            eq_token: self.eq_token.clone(),
-            expr: self.expr.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ItemStruct {
-    fn clone(&self) -> Self {
-        ItemStruct {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            struct_token: self.struct_token.clone(),
-            ident: self.ident.clone(),
-            generics: self.generics.clone(),
-            fields: self.fields.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ItemTrait {
-    fn clone(&self) -> Self {
-        ItemTrait {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            unsafety: self.unsafety.clone(),
-            auto_token: self.auto_token.clone(),
-            restriction: self.restriction.clone(),
-            trait_token: self.trait_token.clone(),
-            ident: self.ident.clone(),
-            generics: self.generics.clone(),
-            colon_token: self.colon_token.clone(),
-            supertraits: self.supertraits.clone(),
-            brace_token: self.brace_token.clone(),
-            items: self.items.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ItemTraitAlias {
-    fn clone(&self) -> Self {
-        ItemTraitAlias {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            trait_token: self.trait_token.clone(),
-            ident: self.ident.clone(),
-            generics: self.generics.clone(),
-            eq_token: self.eq_token.clone(),
-            bounds: self.bounds.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ItemType {
-    fn clone(&self) -> Self {
-        ItemType {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            type_token: self.type_token.clone(),
-            ident: self.ident.clone(),
-            generics: self.generics.clone(),
-            eq_token: self.eq_token.clone(),
-            ty: self.ty.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ItemUnion {
-    fn clone(&self) -> Self {
-        ItemUnion {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            union_token: self.union_token.clone(),
-            ident: self.ident.clone(),
-            generics: self.generics.clone(),
-            fields: self.fields.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ItemUse {
-    fn clone(&self) -> Self {
-        ItemUse {
-            attrs: self.attrs.clone(),
-            vis: self.vis.clone(),
-            use_token: self.use_token.clone(),
-            leading_colon: self.leading_colon.clone(),
-            tree: self.tree.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Label {
-    fn clone(&self) -> Self {
-        Label {
-            name: self.name.clone(),
-            colon_token: self.colon_token.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for LifetimeParam {
-    fn clone(&self) -> Self {
-        LifetimeParam {
-            attrs: self.attrs.clone(),
-            lifetime: self.lifetime.clone(),
-            colon_token: self.colon_token.clone(),
-            bounds: self.bounds.clone(),
-        }
-    }
-}
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Lit {
-    fn clone(&self) -> Self {
-        match self {
-            Lit::Str(v0) => Lit::Str(v0.clone()),
-            Lit::ByteStr(v0) => Lit::ByteStr(v0.clone()),
-            Lit::Byte(v0) => Lit::Byte(v0.clone()),
-            Lit::Char(v0) => Lit::Char(v0.clone()),
-            Lit::Int(v0) => Lit::Int(v0.clone()),
-            Lit::Float(v0) => Lit::Float(v0.clone()),
-            Lit::Bool(v0) => Lit::Bool(v0.clone()),
-            Lit::Verbatim(v0) => Lit::Verbatim(v0.clone()),
-        }
-    }
-}
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for LitBool {
-    fn clone(&self) -> Self {
-        LitBool {
-            value: self.value.clone(),
-            span: self.span.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Local {
-    fn clone(&self) -> Self {
-        Local {
-            attrs: self.attrs.clone(),
-            let_token: self.let_token.clone(),
-            pat: self.pat.clone(),
-            init: self.init.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for LocalInit {
-    fn clone(&self) -> Self {
-        LocalInit {
-            eq_token: self.eq_token.clone(),
-            expr: self.expr.clone(),
-            diverge: self.diverge.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Macro {
-    fn clone(&self) -> Self {
-        Macro {
-            path: self.path.clone(),
-            bang_token: self.bang_token.clone(),
-            delimiter: self.delimiter.clone(),
-            tokens: self.tokens.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for MacroDelimiter {
-    fn clone(&self) -> Self {
-        match self {
-            MacroDelimiter::Paren(v0) => MacroDelimiter::Paren(v0.clone()),
-            MacroDelimiter::Brace(v0) => MacroDelimiter::Brace(v0.clone()),
-            MacroDelimiter::Bracket(v0) => MacroDelimiter::Bracket(v0.clone()),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Member {
-    fn clone(&self) -> Self {
-        match self {
-            Member::Named(v0) => Member::Named(v0.clone()),
-            Member::Unnamed(v0) => Member::Unnamed(v0.clone()),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Meta {
-    fn clone(&self) -> Self {
-        match self {
-            Meta::Path(v0) => Meta::Path(v0.clone()),
-            Meta::List(v0) => Meta::List(v0.clone()),
-            Meta::NameValue(v0) => Meta::NameValue(v0.clone()),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for MetaList {
-    fn clone(&self) -> Self {
-        MetaList {
-            path: self.path.clone(),
-            delimiter: self.delimiter.clone(),
-            tokens: self.tokens.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for MetaNameValue {
-    fn clone(&self) -> Self {
-        MetaNameValue {
-            path: self.path.clone(),
-            eq_token: self.eq_token.clone(),
-            value: self.value.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ParenthesizedGenericArguments {
-    fn clone(&self) -> Self {
-        ParenthesizedGenericArguments {
-            paren_token: self.paren_token.clone(),
-            inputs: self.inputs.clone(),
-            output: self.output.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Pat {
-    fn clone(&self) -> Self {
-        match self {
-            Pat::Const(v0) => Pat::Const(v0.clone()),
-            Pat::Ident(v0) => Pat::Ident(v0.clone()),
-            Pat::Lit(v0) => Pat::Lit(v0.clone()),
-            Pat::Macro(v0) => Pat::Macro(v0.clone()),
-            Pat::Or(v0) => Pat::Or(v0.clone()),
-            Pat::Paren(v0) => Pat::Paren(v0.clone()),
-            Pat::Path(v0) => Pat::Path(v0.clone()),
-            Pat::Range(v0) => Pat::Range(v0.clone()),
-            Pat::Reference(v0) => Pat::Reference(v0.clone()),
-            Pat::Rest(v0) => Pat::Rest(v0.clone()),
-            Pat::Slice(v0) => Pat::Slice(v0.clone()),
-            Pat::Struct(v0) => Pat::Struct(v0.clone()),
-            Pat::Tuple(v0) => Pat::Tuple(v0.clone()),
-            Pat::TupleStruct(v0) => Pat::TupleStruct(v0.clone()),
-            Pat::Type(v0) => Pat::Type(v0.clone()),
-            Pat::Verbatim(v0) => Pat::Verbatim(v0.clone()),
-            Pat::Wild(v0) => Pat::Wild(v0.clone()),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for PatIdent {
-    fn clone(&self) -> Self {
-        PatIdent {
-            attrs: self.attrs.clone(),
-            by_ref: self.by_ref.clone(),
-            mutability: self.mutability.clone(),
-            ident: self.ident.clone(),
-            subpat: self.subpat.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for PatOr {
-    fn clone(&self) -> Self {
-        PatOr {
-            attrs: self.attrs.clone(),
-            leading_vert: self.leading_vert.clone(),
-            cases: self.cases.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for PatParen {
-    fn clone(&self) -> Self {
-        PatParen {
-            attrs: self.attrs.clone(),
-            paren_token: self.paren_token.clone(),
-            pat: self.pat.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for PatReference {
-    fn clone(&self) -> Self {
-        PatReference {
-            attrs: self.attrs.clone(),
-            and_token: self.and_token.clone(),
-            mutability: self.mutability.clone(),
-            pat: self.pat.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for PatRest {
-    fn clone(&self) -> Self {
-        PatRest {
-            attrs: self.attrs.clone(),
-            dot2_token: self.dot2_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for PatSlice {
-    fn clone(&self) -> Self {
-        PatSlice {
-            attrs: self.attrs.clone(),
-            bracket_token: self.bracket_token.clone(),
-            elems: self.elems.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for PatStruct {
-    fn clone(&self) -> Self {
-        PatStruct {
-            attrs: self.attrs.clone(),
-            qself: self.qself.clone(),
-            path: self.path.clone(),
-            brace_token: self.brace_token.clone(),
-            fields: self.fields.clone(),
-            rest: self.rest.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for PatTuple {
-    fn clone(&self) -> Self {
-        PatTuple {
-            attrs: self.attrs.clone(),
-            paren_token: self.paren_token.clone(),
-            elems: self.elems.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for PatTupleStruct {
-    fn clone(&self) -> Self {
-        PatTupleStruct {
-            attrs: self.attrs.clone(),
-            qself: self.qself.clone(),
-            path: self.path.clone(),
-            paren_token: self.paren_token.clone(),
-            elems: self.elems.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for PatType {
-    fn clone(&self) -> Self {
-        PatType {
-            attrs: self.attrs.clone(),
-            pat: self.pat.clone(),
-            colon_token: self.colon_token.clone(),
-            ty: self.ty.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for PatWild {
-    fn clone(&self) -> Self {
-        PatWild {
-            attrs: self.attrs.clone(),
-            underscore_token: self.underscore_token.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Path {
-    fn clone(&self) -> Self {
-        Path {
-            leading_colon: self.leading_colon.clone(),
-            segments: self.segments.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for PathArguments {
-    fn clone(&self) -> Self {
-        match self {
-            PathArguments::None => PathArguments::None,
-            PathArguments::AngleBracketed(v0) => {
-                PathArguments::AngleBracketed(v0.clone())
-            }
-            PathArguments::Parenthesized(v0) => PathArguments::Parenthesized(v0.clone()),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for PathSegment {
-    fn clone(&self) -> Self {
-        PathSegment {
-            ident: self.ident.clone(),
-            arguments: self.arguments.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for PredicateLifetime {
-    fn clone(&self) -> Self {
-        PredicateLifetime {
-            lifetime: self.lifetime.clone(),
-            colon_token: self.colon_token.clone(),
-            bounds: self.bounds.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for PredicateType {
-    fn clone(&self) -> Self {
-        PredicateType {
-            lifetimes: self.lifetimes.clone(),
-            bounded_ty: self.bounded_ty.clone(),
-            colon_token: self.colon_token.clone(),
-            bounds: self.bounds.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for QSelf {
-    fn clone(&self) -> Self {
-        QSelf {
-            lt_token: self.lt_token.clone(),
-            ty: self.ty.clone(),
-            position: self.position.clone(),
-            as_token: self.as_token.clone(),
-            gt_token: self.gt_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Copy for RangeLimits {}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for RangeLimits {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Receiver {
-    fn clone(&self) -> Self {
-        Receiver {
-            attrs: self.attrs.clone(),
-            reference: self.reference.clone(),
-            mutability: self.mutability.clone(),
-            self_token: self.self_token.clone(),
-            colon_token: self.colon_token.clone(),
-            ty: self.ty.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for ReturnType {
-    fn clone(&self) -> Self {
-        match self {
-            ReturnType::Default => ReturnType::Default,
-            ReturnType::Type(v0, v1) => ReturnType::Type(v0.clone(), v1.clone()),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Signature {
-    fn clone(&self) -> Self {
-        Signature {
-            constness: self.constness.clone(),
-            asyncness: self.asyncness.clone(),
-            unsafety: self.unsafety.clone(),
-            abi: self.abi.clone(),
-            fn_token: self.fn_token.clone(),
-            ident: self.ident.clone(),
-            generics: self.generics.clone(),
-            paren_token: self.paren_token.clone(),
-            inputs: self.inputs.clone(),
-            variadic: self.variadic.clone(),
-            output: self.output.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for StaticMutability {
-    fn clone(&self) -> Self {
-        match self {
-            StaticMutability::Mut(v0) => StaticMutability::Mut(v0.clone()),
-            StaticMutability::None => StaticMutability::None,
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Stmt {
-    fn clone(&self) -> Self {
-        match self {
-            Stmt::Local(v0) => Stmt::Local(v0.clone()),
-            Stmt::Item(v0) => Stmt::Item(v0.clone()),
-            Stmt::Expr(v0, v1) => Stmt::Expr(v0.clone(), v1.clone()),
-            Stmt::Macro(v0) => Stmt::Macro(v0.clone()),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for StmtMacro {
-    fn clone(&self) -> Self {
-        StmtMacro {
-            attrs: self.attrs.clone(),
-            mac: self.mac.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TraitBound {
-    fn clone(&self) -> Self {
-        TraitBound {
-            paren_token: self.paren_token.clone(),
-            modifier: self.modifier.clone(),
-            lifetimes: self.lifetimes.clone(),
-            path: self.path.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Copy for TraitBoundModifier {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TraitBoundModifier {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TraitItem {
-    fn clone(&self) -> Self {
-        match self {
-            TraitItem::Const(v0) => TraitItem::Const(v0.clone()),
-            TraitItem::Fn(v0) => TraitItem::Fn(v0.clone()),
-            TraitItem::Type(v0) => TraitItem::Type(v0.clone()),
-            TraitItem::Macro(v0) => TraitItem::Macro(v0.clone()),
-            TraitItem::Verbatim(v0) => TraitItem::Verbatim(v0.clone()),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TraitItemConst {
-    fn clone(&self) -> Self {
-        TraitItemConst {
-            attrs: self.attrs.clone(),
-            const_token: self.const_token.clone(),
-            ident: self.ident.clone(),
-            generics: self.generics.clone(),
-            colon_token: self.colon_token.clone(),
-            ty: self.ty.clone(),
-            default: self.default.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TraitItemFn {
-    fn clone(&self) -> Self {
-        TraitItemFn {
-            attrs: self.attrs.clone(),
-            sig: self.sig.clone(),
-            default: self.default.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TraitItemMacro {
-    fn clone(&self) -> Self {
-        TraitItemMacro {
-            attrs: self.attrs.clone(),
-            mac: self.mac.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TraitItemType {
-    fn clone(&self) -> Self {
-        TraitItemType {
-            attrs: self.attrs.clone(),
-            type_token: self.type_token.clone(),
-            ident: self.ident.clone(),
-            generics: self.generics.clone(),
-            colon_token: self.colon_token.clone(),
-            bounds: self.bounds.clone(),
-            default: self.default.clone(),
-            semi_token: self.semi_token.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Type {
-    fn clone(&self) -> Self {
-        match self {
-            Type::Array(v0) => Type::Array(v0.clone()),
-            Type::BareFn(v0) => Type::BareFn(v0.clone()),
-            Type::Group(v0) => Type::Group(v0.clone()),
-            Type::ImplTrait(v0) => Type::ImplTrait(v0.clone()),
-            Type::Infer(v0) => Type::Infer(v0.clone()),
-            Type::Macro(v0) => Type::Macro(v0.clone()),
-            Type::Never(v0) => Type::Never(v0.clone()),
-            Type::Paren(v0) => Type::Paren(v0.clone()),
-            Type::Path(v0) => Type::Path(v0.clone()),
-            Type::Ptr(v0) => Type::Ptr(v0.clone()),
-            Type::Reference(v0) => Type::Reference(v0.clone()),
-            Type::Slice(v0) => Type::Slice(v0.clone()),
-            Type::TraitObject(v0) => Type::TraitObject(v0.clone()),
-            Type::Tuple(v0) => Type::Tuple(v0.clone()),
-            Type::Verbatim(v0) => Type::Verbatim(v0.clone()),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TypeArray {
-    fn clone(&self) -> Self {
-        TypeArray {
-            bracket_token: self.bracket_token.clone(),
-            elem: self.elem.clone(),
-            semi_token: self.semi_token.clone(),
-            len: self.len.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TypeBareFn {
-    fn clone(&self) -> Self {
-        TypeBareFn {
-            lifetimes: self.lifetimes.clone(),
-            unsafety: self.unsafety.clone(),
-            abi: self.abi.clone(),
-            fn_token: self.fn_token.clone(),
-            paren_token: self.paren_token.clone(),
-            inputs: self.inputs.clone(),
-            variadic: self.variadic.clone(),
-            output: self.output.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TypeGroup {
-    fn clone(&self) -> Self {
-        TypeGroup {
-            group_token: self.group_token.clone(),
-            elem: self.elem.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TypeImplTrait {
-    fn clone(&self) -> Self {
-        TypeImplTrait {
-            impl_token: self.impl_token.clone(),
-            bounds: self.bounds.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TypeInfer {
-    fn clone(&self) -> Self {
-        TypeInfer {
-            underscore_token: self.underscore_token.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TypeMacro {
-    fn clone(&self) -> Self {
-        TypeMacro { mac: self.mac.clone() }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TypeNever {
-    fn clone(&self) -> Self {
-        TypeNever {
-            bang_token: self.bang_token.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TypeParam {
-    fn clone(&self) -> Self {
-        TypeParam {
-            attrs: self.attrs.clone(),
-            ident: self.ident.clone(),
-            colon_token: self.colon_token.clone(),
-            bounds: self.bounds.clone(),
-            eq_token: self.eq_token.clone(),
-            default: self.default.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TypeParamBound {
-    fn clone(&self) -> Self {
-        match self {
-            TypeParamBound::Trait(v0) => TypeParamBound::Trait(v0.clone()),
-            TypeParamBound::Lifetime(v0) => TypeParamBound::Lifetime(v0.clone()),
-            TypeParamBound::Verbatim(v0) => TypeParamBound::Verbatim(v0.clone()),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TypeParen {
-    fn clone(&self) -> Self {
-        TypeParen {
-            paren_token: self.paren_token.clone(),
-            elem: self.elem.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TypePath {
-    fn clone(&self) -> Self {
-        TypePath {
-            qself: self.qself.clone(),
-            path: self.path.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TypePtr {
-    fn clone(&self) -> Self {
-        TypePtr {
-            star_token: self.star_token.clone(),
-            const_token: self.const_token.clone(),
-            mutability: self.mutability.clone(),
-            elem: self.elem.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TypeReference {
-    fn clone(&self) -> Self {
-        TypeReference {
-            and_token: self.and_token.clone(),
-            lifetime: self.lifetime.clone(),
-            mutability: self.mutability.clone(),
-            elem: self.elem.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TypeSlice {
-    fn clone(&self) -> Self {
-        TypeSlice {
-            bracket_token: self.bracket_token.clone(),
-            elem: self.elem.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TypeTraitObject {
-    fn clone(&self) -> Self {
-        TypeTraitObject {
-            dyn_token: self.dyn_token.clone(),
-            bounds: self.bounds.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for TypeTuple {
-    fn clone(&self) -> Self {
-        TypeTuple {
-            paren_token: self.paren_token.clone(),
-            elems: self.elems.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Copy for UnOp {}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for UnOp {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for UseGlob {
-    fn clone(&self) -> Self {
-        UseGlob {
-            star_token: self.star_token.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for UseGroup {
-    fn clone(&self) -> Self {
-        UseGroup {
-            brace_token: self.brace_token.clone(),
-            items: self.items.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for UseName {
-    fn clone(&self) -> Self {
-        UseName {
-            ident: self.ident.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for UsePath {
-    fn clone(&self) -> Self {
-        UsePath {
-            ident: self.ident.clone(),
-            colon2_token: self.colon2_token.clone(),
-            tree: self.tree.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for UseRename {
-    fn clone(&self) -> Self {
-        UseRename {
-            ident: self.ident.clone(),
-            as_token: self.as_token.clone(),
-            rename: self.rename.clone(),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for UseTree {
-    fn clone(&self) -> Self {
-        match self {
-            UseTree::Path(v0) => UseTree::Path(v0.clone()),
-            UseTree::Name(v0) => UseTree::Name(v0.clone()),
-            UseTree::Rename(v0) => UseTree::Rename(v0.clone()),
-            UseTree::Glob(v0) => UseTree::Glob(v0.clone()),
-            UseTree::Group(v0) => UseTree::Group(v0.clone()),
-        }
-    }
-}
-#[cfg(feature = "full")]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Variadic {
-    fn clone(&self) -> Self {
-        Variadic {
-            attrs: self.attrs.clone(),
-            pat: self.pat.clone(),
-            dots: self.dots.clone(),
-            comma: self.comma.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Variant {
-    fn clone(&self) -> Self {
-        Variant {
-            attrs: self.attrs.clone(),
-            ident: self.ident.clone(),
-            fields: self.fields.clone(),
-            discriminant: self.discriminant.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for VisRestricted {
-    fn clone(&self) -> Self {
-        VisRestricted {
-            pub_token: self.pub_token.clone(),
-            paren_token: self.paren_token.clone(),
-            in_token: self.in_token.clone(),
-            path: self.path.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for Visibility {
-    fn clone(&self) -> Self {
-        match self {
-            Visibility::Public(v0) => Visibility::Public(v0.clone()),
-            Visibility::Restricted(v0) => Visibility::Restricted(v0.clone()),
-            Visibility::Inherited => Visibility::Inherited,
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for WhereClause {
-    fn clone(&self) -> Self {
-        WhereClause {
-            where_token: self.where_token.clone(),
-            predicates: self.predicates.clone(),
-        }
-    }
-}
-#[cfg(any(feature = "derive", feature = "full"))]
-#[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
-impl Clone for WherePredicate {
-    fn clone(&self) -> Self {
-        match self {
-            WherePredicate::Lifetime(v0) => WherePredicate::Lifetime(v0.clone()),
-            WherePredicate::Type(v0) => WherePredicate::Type(v0.clone()),
-        }
-    }
-}
-- 
cgit v1.2.3