// 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()),
        }
    }
}