#![allow(clippy::clone_on_copy, clippy::expl_impl_clone_on_copy)]
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Abi {
fn clone(&self) -> Self {
crate::Abi {
extern_token: self.extern_token.clone(),
name: self.name.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::AngleBracketedGenericArguments {
fn clone(&self) -> Self {
crate::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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Arm {
fn clone(&self) -> Self {
crate::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_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Assert {
fn clone(&self) -> Self {
crate::Assert {
attrs: self.attrs.clone(),
assert_token: self.assert_token.clone(),
paren_token: self.paren_token.clone(),
expr: self.expr.clone(),
by_token: self.by_token.clone(),
prover: self.prover.clone(),
requires: self.requires.clone(),
body: self.body.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::AssertForall {
fn clone(&self) -> Self {
crate::AssertForall {
attrs: self.attrs.clone(),
assert_token: self.assert_token.clone(),
forall_token: self.forall_token.clone(),
or1_token: self.or1_token.clone(),
inputs: self.inputs.clone(),
or2_token: self.or2_token.clone(),
expr: self.expr.clone(),
implies: self.implies.clone(),
by_token: self.by_token.clone(),
body: self.body.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::AssocConst {
fn clone(&self) -> Self {
crate::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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::AssocType {
fn clone(&self) -> Self {
crate::AssocType {
ident: self.ident.clone(),
generics: self.generics.clone(),
eq_token: self.eq_token.clone(),
ty: self.ty.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Assume {
fn clone(&self) -> Self {
crate::Assume {
attrs: self.attrs.clone(),
assume_token: self.assume_token.clone(),
paren_token: self.paren_token.clone(),
expr: self.expr.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::AssumeSpecification {
fn clone(&self) -> Self {
crate::AssumeSpecification {
attrs: self.attrs.clone(),
vis: self.vis.clone(),
assume_specification: self.assume_specification.clone(),
generics: self.generics.clone(),
bracket_token: self.bracket_token.clone(),
qself: self.qself.clone(),
path: self.path.clone(),
inputs: self.inputs.clone(),
output: self.output.clone(),
requires: self.requires.clone(),
ensures: self.ensures.clone(),
default_ensures: self.default_ensures.clone(),
returns: self.returns.clone(),
invariants: self.invariants.clone(),
unwind: self.unwind.clone(),
semi: self.semi.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::AtomicSpec {
fn clone(&self) -> Self {
crate::AtomicSpec {
atomically_token: self.atomically_token.clone(),
paren_token: self.paren_token.clone(),
atomic_update: self.atomic_update.clone(),
block_token: self.block_token.clone(),
type_clause: self.type_clause.clone(),
perm_clause: self.perm_clause.clone(),
requires: self.requires.clone(),
ensures: self.ensures.clone(),
outer_mask: self.outer_mask.clone(),
inner_mask: self.inner_mask.clone(),
comma_token: self.comma_token.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::AtomicallyBlock {
fn clone(&self) -> Self {
crate::AtomicallyBlock {
label: self.label.clone(),
atomically_token: self.atomically_token.clone(),
loop_token: self.loop_token.clone(),
or1_token: self.or1_token.clone(),
update_fn_binder: self.update_fn_binder.clone(),
comma_token: self.comma_token.clone(),
or2_token: self.or2_token.clone(),
spec_au_binder: self.spec_au_binder.clone(),
invariant_except_breaks: self.invariant_except_breaks.clone(),
invariants: self.invariants.clone(),
ensures: self.ensures.clone(),
body: self.body.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Copy for crate::AttrStyle {}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::AttrStyle {
fn clone(&self) -> Self {
*self
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Attribute {
fn clone(&self) -> Self {
crate::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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::BareFnArg {
fn clone(&self) -> Self {
crate::BareFnArg {
attrs: self.attrs.clone(),
name: self.name.clone(),
ty: self.ty.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::BareVariadic {
fn clone(&self) -> Self {
crate::BareVariadic {
attrs: self.attrs.clone(),
name: self.name.clone(),
dots: self.dots.clone(),
comma: self.comma.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::BigAnd {
fn clone(&self) -> Self {
crate::BigAnd {
exprs: self.exprs.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::BigAndExpr {
fn clone(&self) -> Self {
crate::BigAndExpr {
tok: self.tok.clone(),
expr: self.expr.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::BigOr {
fn clone(&self) -> Self {
crate::BigOr {
exprs: self.exprs.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::BigOrExpr {
fn clone(&self) -> Self {
crate::BigOrExpr {
tok: self.tok.clone(),
expr: self.expr.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Copy for crate::BinOp {}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::BinOp {
fn clone(&self) -> Self {
*self
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Block {
fn clone(&self) -> Self {
crate::Block {
brace_token: self.brace_token.clone(),
stmts: self.stmts.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::BoundLifetimes {
fn clone(&self) -> Self {
crate::BoundLifetimes {
for_token: self.for_token.clone(),
lt_token: self.lt_token.clone(),
lifetimes: self.lifetimes.clone(),
gt_token: self.gt_token.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::BroadcastUse {
fn clone(&self) -> Self {
crate::BroadcastUse {
attrs: self.attrs.clone(),
broadcast_use_tokens: self.broadcast_use_tokens.clone(),
brace_token: self.brace_token.clone(),
paths: self.paths.clone(),
semi: self.semi.clone(),
warning: self.warning.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::CapturedParam {
fn clone(&self) -> Self {
match self {
crate::CapturedParam::Lifetime(v0) => {
crate::CapturedParam::Lifetime(v0.clone())
}
crate::CapturedParam::Ident(v0) => crate::CapturedParam::Ident(v0.clone()),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Closed {
fn clone(&self) -> Self {
crate::Closed {
token: self.token.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ClosureArg {
fn clone(&self) -> Self {
crate::ClosureArg {
tracked_token: self.tracked_token.clone(),
pat: self.pat.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ConstParam {
fn clone(&self) -> Self {
crate::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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Constraint {
fn clone(&self) -> Self {
crate::Constraint {
ident: self.ident.clone(),
generics: self.generics.clone(),
colon_token: self.colon_token.clone(),
bounds: self.bounds.clone(),
}
}
}
#[cfg(feature = "derive")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Data {
fn clone(&self) -> Self {
match self {
crate::Data::Struct(v0) => crate::Data::Struct(v0.clone()),
crate::Data::Enum(v0) => crate::Data::Enum(v0.clone()),
crate::Data::Union(v0) => crate::Data::Union(v0.clone()),
}
}
}
#[cfg(feature = "derive")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::DataEnum {
fn clone(&self) -> Self {
crate::DataEnum {
enum_token: self.enum_token.clone(),
brace_token: self.brace_token.clone(),
variants: self.variants.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::DataMode {
fn clone(&self) -> Self {
match self {
crate::DataMode::Ghost(v0) => crate::DataMode::Ghost(v0.clone()),
crate::DataMode::Tracked(v0) => crate::DataMode::Tracked(v0.clone()),
crate::DataMode::Exec(v0) => crate::DataMode::Exec(v0.clone()),
crate::DataMode::Default => crate::DataMode::Default,
}
}
}
#[cfg(feature = "derive")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::DataStruct {
fn clone(&self) -> Self {
crate::DataStruct {
struct_token: self.struct_token.clone(),
fields: self.fields.clone(),
semi_token: self.semi_token.clone(),
}
}
}
#[cfg(feature = "derive")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::DataUnion {
fn clone(&self) -> Self {
crate::DataUnion {
union_token: self.union_token.clone(),
fields: self.fields.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Decreases {
fn clone(&self) -> Self {
crate::Decreases {
token: self.token.clone(),
exprs: self.exprs.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::DefaultEnsures {
fn clone(&self) -> Self {
crate::DefaultEnsures {
token: self.token.clone(),
exprs: self.exprs.clone(),
}
}
}
#[cfg(feature = "derive")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::DeriveInput {
fn clone(&self) -> Self {
crate::DeriveInput {
attrs: self.attrs.clone(),
vis: self.vis.clone(),
mode: self.mode.clone(),
ident: self.ident.clone(),
generics: self.generics.clone(),
data: self.data.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Ensures {
fn clone(&self) -> Self {
crate::Ensures {
attrs: self.attrs.clone(),
token: self.token.clone(),
exprs: self.exprs.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Expr {
fn clone(&self) -> Self {
match self {
#[cfg(feature = "full")]
crate::Expr::Array(v0) => crate::Expr::Array(v0.clone()),
#[cfg(feature = "full")]
crate::Expr::Assign(v0) => crate::Expr::Assign(v0.clone()),
#[cfg(feature = "full")]
crate::Expr::Async(v0) => crate::Expr::Async(v0.clone()),
#[cfg(feature = "full")]
crate::Expr::Await(v0) => crate::Expr::Await(v0.clone()),
crate::Expr::Binary(v0) => crate::Expr::Binary(v0.clone()),
#[cfg(feature = "full")]
crate::Expr::Block(v0) => crate::Expr::Block(v0.clone()),
#[cfg(feature = "full")]
crate::Expr::Break(v0) => crate::Expr::Break(v0.clone()),
crate::Expr::Call(v0) => crate::Expr::Call(v0.clone()),
crate::Expr::Cast(v0) => crate::Expr::Cast(v0.clone()),
#[cfg(feature = "full")]
crate::Expr::Closure(v0) => crate::Expr::Closure(v0.clone()),
#[cfg(feature = "full")]
crate::Expr::Const(v0) => crate::Expr::Const(v0.clone()),
#[cfg(feature = "full")]
crate::Expr::Continue(v0) => crate::Expr::Continue(v0.clone()),
crate::Expr::Field(v0) => crate::Expr::Field(v0.clone()),
#[cfg(feature = "full")]
crate::Expr::ForLoop(v0) => crate::Expr::ForLoop(v0.clone()),
crate::Expr::Group(v0) => crate::Expr::Group(v0.clone()),
#[cfg(feature = "full")]
crate::Expr::If(v0) => crate::Expr::If(v0.clone()),
crate::Expr::Index(v0) => crate::Expr::Index(v0.clone()),
#[cfg(feature = "full")]
crate::Expr::Infer(v0) => crate::Expr::Infer(v0.clone()),
#[cfg(feature = "full")]
crate::Expr::Let(v0) => crate::Expr::Let(v0.clone()),
crate::Expr::Lit(v0) => crate::Expr::Lit(v0.clone()),
#[cfg(feature = "full")]
crate::Expr::Loop(v0) => crate::Expr::Loop(v0.clone()),
crate::Expr::Macro(v0) => crate::Expr::Macro(v0.clone()),
#[cfg(feature = "full")]
crate::Expr::Match(v0) => crate::Expr::Match(v0.clone()),
crate::Expr::MethodCall(v0) => crate::Expr::MethodCall(v0.clone()),
crate::Expr::Paren(v0) => crate::Expr::Paren(v0.clone()),
crate::Expr::Path(v0) => crate::Expr::Path(v0.clone()),
#[cfg(feature = "full")]
crate::Expr::Range(v0) => crate::Expr::Range(v0.clone()),
#[cfg(feature = "full")]
crate::Expr::RawAddr(v0) => crate::Expr::RawAddr(v0.clone()),
crate::Expr::Reference(v0) => crate::Expr::Reference(v0.clone()),
#[cfg(feature = "full")]
crate::Expr::Repeat(v0) => crate::Expr::Repeat(v0.clone()),
#[cfg(feature = "full")]
crate::Expr::Return(v0) => crate::Expr::Return(v0.clone()),
crate::Expr::Struct(v0) => crate::Expr::Struct(v0.clone()),
#[cfg(feature = "full")]
crate::Expr::Try(v0) => crate::Expr::Try(v0.clone()),
#[cfg(feature = "full")]
crate::Expr::TryBlock(v0) => crate::Expr::TryBlock(v0.clone()),
crate::Expr::Tuple(v0) => crate::Expr::Tuple(v0.clone()),
crate::Expr::Unary(v0) => crate::Expr::Unary(v0.clone()),
#[cfg(feature = "full")]
crate::Expr::Unsafe(v0) => crate::Expr::Unsafe(v0.clone()),
crate::Expr::Verbatim(v0) => crate::Expr::Verbatim(v0.clone()),
#[cfg(feature = "full")]
crate::Expr::While(v0) => crate::Expr::While(v0.clone()),
#[cfg(feature = "full")]
crate::Expr::Yield(v0) => crate::Expr::Yield(v0.clone()),
crate::Expr::Assume(v0) => crate::Expr::Assume(v0.clone()),
crate::Expr::Assert(v0) => crate::Expr::Assert(v0.clone()),
crate::Expr::AssertForall(v0) => crate::Expr::AssertForall(v0.clone()),
crate::Expr::RevealHide(v0) => crate::Expr::RevealHide(v0.clone()),
crate::Expr::View(v0) => crate::Expr::View(v0.clone()),
crate::Expr::BigAnd(v0) => crate::Expr::BigAnd(v0.clone()),
crate::Expr::BigOr(v0) => crate::Expr::BigOr(v0.clone()),
crate::Expr::Is(v0) => crate::Expr::Is(v0.clone()),
crate::Expr::IsNot(v0) => crate::Expr::IsNot(v0.clone()),
crate::Expr::Has(v0) => crate::Expr::Has(v0.clone()),
crate::Expr::HasNot(v0) => crate::Expr::HasNot(v0.clone()),
crate::Expr::Matches(v0) => crate::Expr::Matches(v0.clone()),
crate::Expr::GetField(v0) => crate::Expr::GetField(v0.clone()),
crate::Expr::Final(v0) => crate::Expr::Final(v0.clone()),
#[cfg(not(feature = "full"))]
_ => unreachable!(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprArray {
fn clone(&self) -> Self {
crate::ExprArray {
attrs: self.attrs.clone(),
bracket_token: self.bracket_token.clone(),
elems: self.elems.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprAssign {
fn clone(&self) -> Self {
crate::ExprAssign {
attrs: self.attrs.clone(),
left: self.left.clone(),
eq_token: self.eq_token.clone(),
right: self.right.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprAsync {
fn clone(&self) -> Self {
crate::ExprAsync {
attrs: self.attrs.clone(),
async_token: self.async_token.clone(),
capture: self.capture.clone(),
block: self.block.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprAwait {
fn clone(&self) -> Self {
crate::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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprBinary {
fn clone(&self) -> Self {
crate::ExprBinary {
attrs: self.attrs.clone(),
left: self.left.clone(),
op: self.op.clone(),
right: self.right.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprBlock {
fn clone(&self) -> Self {
crate::ExprBlock {
attrs: self.attrs.clone(),
label: self.label.clone(),
block: self.block.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprBreak {
fn clone(&self) -> Self {
crate::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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprCall {
fn clone(&self) -> Self {
crate::ExprCall {
attrs: self.attrs.clone(),
func: self.func.clone(),
paren_token: self.paren_token.clone(),
args: self.args.clone(),
atomically: self.atomically.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprCast {
fn clone(&self) -> Self {
crate::ExprCast {
attrs: self.attrs.clone(),
expr: self.expr.clone(),
as_token: self.as_token.clone(),
ty: self.ty.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprClosure {
fn clone(&self) -> Self {
crate::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(),
proof_fn: self.proof_fn.clone(),
options: self.options.clone(),
or1_token: self.or1_token.clone(),
inputs: self.inputs.clone(),
or2_token: self.or2_token.clone(),
output: self.output.clone(),
requires: self.requires.clone(),
ensures: self.ensures.clone(),
inner_attrs: self.inner_attrs.clone(),
body: self.body.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprConst {
fn clone(&self) -> Self {
crate::ExprConst {
attrs: self.attrs.clone(),
const_token: self.const_token.clone(),
block: self.block.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprContinue {
fn clone(&self) -> Self {
crate::ExprContinue {
attrs: self.attrs.clone(),
continue_token: self.continue_token.clone(),
label: self.label.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprField {
fn clone(&self) -> Self {
crate::ExprField {
attrs: self.attrs.clone(),
base: self.base.clone(),
dot_token: self.dot_token.clone(),
member: self.member.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprFinal {
fn clone(&self) -> Self {
crate::ExprFinal {
attrs: self.attrs.clone(),
final_token: self.final_token.clone(),
paren_token: self.paren_token.clone(),
arg: self.arg.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprForLoop {
fn clone(&self) -> Self {
crate::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_name: self.expr_name.clone(),
expr: self.expr.clone(),
invariant_except_break: self.invariant_except_break.clone(),
invariant: self.invariant.clone(),
ensures: self.ensures.clone(),
decreases: self.decreases.clone(),
body: self.body.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprGetField {
fn clone(&self) -> Self {
crate::ExprGetField {
attrs: self.attrs.clone(),
base: self.base.clone(),
arrow_token: self.arrow_token.clone(),
member: self.member.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprGroup {
fn clone(&self) -> Self {
crate::ExprGroup {
attrs: self.attrs.clone(),
group_token: self.group_token.clone(),
expr: self.expr.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprHas {
fn clone(&self) -> Self {
crate::ExprHas {
attrs: self.attrs.clone(),
lhs: self.lhs.clone(),
has_token: self.has_token.clone(),
rhs: self.rhs.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprHasNot {
fn clone(&self) -> Self {
crate::ExprHasNot {
attrs: self.attrs.clone(),
lhs: self.lhs.clone(),
has_not_token: self.has_not_token.clone(),
rhs: self.rhs.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprIf {
fn clone(&self) -> Self {
crate::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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprIndex {
fn clone(&self) -> Self {
crate::ExprIndex {
attrs: self.attrs.clone(),
expr: self.expr.clone(),
bracket_token: self.bracket_token.clone(),
index: self.index.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprInfer {
fn clone(&self) -> Self {
crate::ExprInfer {
attrs: self.attrs.clone(),
underscore_token: self.underscore_token.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprIs {
fn clone(&self) -> Self {
crate::ExprIs {
attrs: self.attrs.clone(),
base: self.base.clone(),
is_token: self.is_token.clone(),
variant_ident: self.variant_ident.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprIsNot {
fn clone(&self) -> Self {
crate::ExprIsNot {
attrs: self.attrs.clone(),
base: self.base.clone(),
is_not_token: self.is_not_token.clone(),
variant_ident: self.variant_ident.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprLet {
fn clone(&self) -> Self {
crate::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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprLit {
fn clone(&self) -> Self {
crate::ExprLit {
attrs: self.attrs.clone(),
lit: self.lit.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprLoop {
fn clone(&self) -> Self {
crate::ExprLoop {
attrs: self.attrs.clone(),
label: self.label.clone(),
loop_token: self.loop_token.clone(),
invariant_except_break: self.invariant_except_break.clone(),
invariant: self.invariant.clone(),
invariant_ensures: self.invariant_ensures.clone(),
ensures: self.ensures.clone(),
decreases: self.decreases.clone(),
body: self.body.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprMacro {
fn clone(&self) -> Self {
crate::ExprMacro {
attrs: self.attrs.clone(),
mac: self.mac.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprMatch {
fn clone(&self) -> Self {
crate::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_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprMatches {
fn clone(&self) -> Self {
crate::ExprMatches {
attrs: self.attrs.clone(),
lhs: self.lhs.clone(),
matches_token: self.matches_token.clone(),
pat: self.pat.clone(),
op_expr: self.op_expr.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprMethodCall {
fn clone(&self) -> Self {
crate::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(),
atomically: self.atomically.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprParen {
fn clone(&self) -> Self {
crate::ExprParen {
attrs: self.attrs.clone(),
paren_token: self.paren_token.clone(),
expr: self.expr.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprPath {
fn clone(&self) -> Self {
crate::ExprPath {
attrs: self.attrs.clone(),
qself: self.qself.clone(),
path: self.path.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprRange {
fn clone(&self) -> Self {
crate::ExprRange {
attrs: self.attrs.clone(),
start: self.start.clone(),
limits: self.limits.clone(),
end: self.end.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprRawAddr {
fn clone(&self) -> Self {
crate::ExprRawAddr {
attrs: self.attrs.clone(),
and_token: self.and_token.clone(),
raw: self.raw.clone(),
mutability: self.mutability.clone(),
expr: self.expr.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprReference {
fn clone(&self) -> Self {
crate::ExprReference {
attrs: self.attrs.clone(),
and_token: self.and_token.clone(),
mutability: self.mutability.clone(),
expr: self.expr.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprRepeat {
fn clone(&self) -> Self {
crate::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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprReturn {
fn clone(&self) -> Self {
crate::ExprReturn {
attrs: self.attrs.clone(),
return_token: self.return_token.clone(),
expr: self.expr.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprStruct {
fn clone(&self) -> Self {
crate::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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprTry {
fn clone(&self) -> Self {
crate::ExprTry {
attrs: self.attrs.clone(),
expr: self.expr.clone(),
question_token: self.question_token.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprTryBlock {
fn clone(&self) -> Self {
crate::ExprTryBlock {
attrs: self.attrs.clone(),
try_token: self.try_token.clone(),
block: self.block.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprTuple {
fn clone(&self) -> Self {
crate::ExprTuple {
attrs: self.attrs.clone(),
paren_token: self.paren_token.clone(),
elems: self.elems.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprUnary {
fn clone(&self) -> Self {
crate::ExprUnary {
attrs: self.attrs.clone(),
op: self.op.clone(),
expr: self.expr.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprUnsafe {
fn clone(&self) -> Self {
crate::ExprUnsafe {
attrs: self.attrs.clone(),
unsafe_token: self.unsafe_token.clone(),
block: self.block.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprWhile {
fn clone(&self) -> Self {
crate::ExprWhile {
attrs: self.attrs.clone(),
label: self.label.clone(),
while_token: self.while_token.clone(),
cond: self.cond.clone(),
invariant_except_break: self.invariant_except_break.clone(),
invariant: self.invariant.clone(),
invariant_ensures: self.invariant_ensures.clone(),
ensures: self.ensures.clone(),
decreases: self.decreases.clone(),
body: self.body.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ExprYield {
fn clone(&self) -> Self {
crate::ExprYield {
attrs: self.attrs.clone(),
yield_token: self.yield_token.clone(),
expr: self.expr.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Field {
fn clone(&self) -> Self {
crate::Field {
attrs: self.attrs.clone(),
vis: self.vis.clone(),
mode: self.mode.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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::FieldMutability {
fn clone(&self) -> Self {
match self {
crate::FieldMutability::None => crate::FieldMutability::None,
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::FieldPat {
fn clone(&self) -> Self {
crate::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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::FieldValue {
fn clone(&self) -> Self {
crate::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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Fields {
fn clone(&self) -> Self {
match self {
crate::Fields::Named(v0) => crate::Fields::Named(v0.clone()),
crate::Fields::Unnamed(v0) => crate::Fields::Unnamed(v0.clone()),
crate::Fields::Unit => crate::Fields::Unit,
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::FieldsNamed {
fn clone(&self) -> Self {
crate::FieldsNamed {
brace_token: self.brace_token.clone(),
named: self.named.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::FieldsUnnamed {
fn clone(&self) -> Self {
crate::FieldsUnnamed {
paren_token: self.paren_token.clone(),
unnamed: self.unnamed.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::File {
fn clone(&self) -> Self {
crate::File {
shebang: self.shebang.clone(),
attrs: self.attrs.clone(),
items: self.items.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::FnArg {
fn clone(&self) -> Self {
crate::FnArg {
tracked: self.tracked.clone(),
kind: self.kind.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::FnArgKind {
fn clone(&self) -> Self {
match self {
crate::FnArgKind::Receiver(v0) => crate::FnArgKind::Receiver(v0.clone()),
crate::FnArgKind::Typed(v0) => crate::FnArgKind::Typed(v0.clone()),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::FnMode {
fn clone(&self) -> Self {
match self {
crate::FnMode::Spec(v0) => crate::FnMode::Spec(v0.clone()),
crate::FnMode::SpecChecked(v0) => crate::FnMode::SpecChecked(v0.clone()),
crate::FnMode::Proof(v0) => crate::FnMode::Proof(v0.clone()),
crate::FnMode::ProofAxiom(v0) => crate::FnMode::ProofAxiom(v0.clone()),
crate::FnMode::Exec(v0) => crate::FnMode::Exec(v0.clone()),
crate::FnMode::Default => crate::FnMode::Default,
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::FnProofArg {
fn clone(&self) -> Self {
crate::FnProofArg {
tracked_token: self.tracked_token.clone(),
arg: self.arg.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::FnProofOptions {
fn clone(&self) -> Self {
crate::FnProofOptions {
bracket_token: self.bracket_token.clone(),
options: self.options.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ForeignItem {
fn clone(&self) -> Self {
match self {
crate::ForeignItem::Fn(v0) => crate::ForeignItem::Fn(v0.clone()),
crate::ForeignItem::Static(v0) => crate::ForeignItem::Static(v0.clone()),
crate::ForeignItem::Type(v0) => crate::ForeignItem::Type(v0.clone()),
crate::ForeignItem::Macro(v0) => crate::ForeignItem::Macro(v0.clone()),
crate::ForeignItem::Verbatim(v0) => crate::ForeignItem::Verbatim(v0.clone()),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ForeignItemFn {
fn clone(&self) -> Self {
crate::ForeignItemFn {
attrs: self.attrs.clone(),
vis: self.vis.clone(),
sig: self.sig.clone(),
semi_token: self.semi_token.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ForeignItemMacro {
fn clone(&self) -> Self {
crate::ForeignItemMacro {
attrs: self.attrs.clone(),
mac: self.mac.clone(),
semi_token: self.semi_token.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ForeignItemStatic {
fn clone(&self) -> Self {
crate::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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ForeignItemType {
fn clone(&self) -> Self {
crate::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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::GenericArgument {
fn clone(&self) -> Self {
match self {
crate::GenericArgument::Lifetime(v0) => {
crate::GenericArgument::Lifetime(v0.clone())
}
crate::GenericArgument::Type(v0) => crate::GenericArgument::Type(v0.clone()),
crate::GenericArgument::Const(v0) => {
crate::GenericArgument::Const(v0.clone())
}
crate::GenericArgument::AssocType(v0) => {
crate::GenericArgument::AssocType(v0.clone())
}
crate::GenericArgument::AssocConst(v0) => {
crate::GenericArgument::AssocConst(v0.clone())
}
crate::GenericArgument::Constraint(v0) => {
crate::GenericArgument::Constraint(v0.clone())
}
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::GenericParam {
fn clone(&self) -> Self {
match self {
crate::GenericParam::Lifetime(v0) => {
crate::GenericParam::Lifetime(v0.clone())
}
crate::GenericParam::Type(v0) => crate::GenericParam::Type(v0.clone()),
crate::GenericParam::Const(v0) => crate::GenericParam::Const(v0.clone()),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Generics {
fn clone(&self) -> Self {
crate::Generics {
lt_token: self.lt_token.clone(),
params: self.params.clone(),
gt_token: self.gt_token.clone(),
where_clause: self.where_clause.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Global {
fn clone(&self) -> Self {
crate::Global {
attrs: self.attrs.clone(),
global_token: self.global_token.clone(),
inner: self.inner.clone(),
semi: self.semi.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::GlobalInner {
fn clone(&self) -> Self {
match self {
crate::GlobalInner::SizeOf(v0) => crate::GlobalInner::SizeOf(v0.clone()),
crate::GlobalInner::Layout(v0) => crate::GlobalInner::Layout(v0.clone()),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::GlobalLayout {
fn clone(&self) -> Self {
crate::GlobalLayout {
layout_token: self.layout_token.clone(),
type_: self.type_.clone(),
is_token: self.is_token.clone(),
size: self.size.clone(),
align: self.align.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::GlobalSizeOf {
fn clone(&self) -> Self {
crate::GlobalSizeOf {
size_of_token: self.size_of_token.clone(),
type_: self.type_.clone(),
eq_token: self.eq_token.clone(),
expr_lit: self.expr_lit.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ImplItem {
fn clone(&self) -> Self {
match self {
crate::ImplItem::Const(v0) => crate::ImplItem::Const(v0.clone()),
crate::ImplItem::Fn(v0) => crate::ImplItem::Fn(v0.clone()),
crate::ImplItem::Type(v0) => crate::ImplItem::Type(v0.clone()),
crate::ImplItem::Macro(v0) => crate::ImplItem::Macro(v0.clone()),
crate::ImplItem::Verbatim(v0) => crate::ImplItem::Verbatim(v0.clone()),
crate::ImplItem::BroadcastGroup(v0) => {
crate::ImplItem::BroadcastGroup(v0.clone())
}
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ImplItemConst {
fn clone(&self) -> Self {
crate::ImplItemConst {
attrs: self.attrs.clone(),
vis: self.vis.clone(),
publish: self.publish.clone(),
mode: self.mode.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(),
ensures: self.ensures.clone(),
eq_token: self.eq_token.clone(),
block: self.block.clone(),
expr: self.expr.clone(),
semi_token: self.semi_token.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ImplItemFn {
fn clone(&self) -> Self {
crate::ImplItemFn {
attrs: self.attrs.clone(),
vis: self.vis.clone(),
defaultness: self.defaultness.clone(),
sig: self.sig.clone(),
block: self.block.clone(),
semi_token: self.semi_token.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ImplItemMacro {
fn clone(&self) -> Self {
crate::ImplItemMacro {
attrs: self.attrs.clone(),
mac: self.mac.clone(),
semi_token: self.semi_token.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ImplItemType {
fn clone(&self) -> Self {
crate::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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ImplRestriction {
fn clone(&self) -> Self {
match *self {}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Index {
fn clone(&self) -> Self {
crate::Index {
index: self.index.clone(),
span: self.span.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::InnerMask {
fn clone(&self) -> Self {
crate::InnerMask {
token: self.token.clone(),
set: self.set.clone(),
comma_token: self.comma_token.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Invariant {
fn clone(&self) -> Self {
crate::Invariant {
token: self.token.clone(),
exprs: self.exprs.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::InvariantEnsures {
fn clone(&self) -> Self {
crate::InvariantEnsures {
token: self.token.clone(),
exprs: self.exprs.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::InvariantExceptBreak {
fn clone(&self) -> Self {
crate::InvariantExceptBreak {
token: self.token.clone(),
exprs: self.exprs.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::InvariantNameSet {
fn clone(&self) -> Self {
match self {
crate::InvariantNameSet::Any(v0) => crate::InvariantNameSet::Any(v0.clone()),
crate::InvariantNameSet::None(v0) => {
crate::InvariantNameSet::None(v0.clone())
}
crate::InvariantNameSet::List(v0) => {
crate::InvariantNameSet::List(v0.clone())
}
crate::InvariantNameSet::ListCompl(v0) => {
crate::InvariantNameSet::ListCompl(v0.clone())
}
crate::InvariantNameSet::Set(v0) => crate::InvariantNameSet::Set(v0.clone()),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::InvariantNameSetAny {
fn clone(&self) -> Self {
crate::InvariantNameSetAny {
token: self.token.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::InvariantNameSetList {
fn clone(&self) -> Self {
crate::InvariantNameSetList {
bracket_token: self.bracket_token.clone(),
exprs: self.exprs.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::InvariantNameSetListCompl {
fn clone(&self) -> Self {
crate::InvariantNameSetListCompl {
any_token: self.any_token.clone(),
op_token: self.op_token.clone(),
bracket_token: self.bracket_token.clone(),
exprs: self.exprs.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::InvariantNameSetNone {
fn clone(&self) -> Self {
crate::InvariantNameSetNone {
token: self.token.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::InvariantNameSetSet {
fn clone(&self) -> Self {
crate::InvariantNameSetSet {
expr: self.expr.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Item {
fn clone(&self) -> Self {
match self {
crate::Item::Const(v0) => crate::Item::Const(v0.clone()),
crate::Item::Enum(v0) => crate::Item::Enum(v0.clone()),
crate::Item::ExternCrate(v0) => crate::Item::ExternCrate(v0.clone()),
crate::Item::Fn(v0) => crate::Item::Fn(v0.clone()),
crate::Item::ForeignMod(v0) => crate::Item::ForeignMod(v0.clone()),
crate::Item::Impl(v0) => crate::Item::Impl(v0.clone()),
crate::Item::Macro(v0) => crate::Item::Macro(v0.clone()),
crate::Item::Mod(v0) => crate::Item::Mod(v0.clone()),
crate::Item::Static(v0) => crate::Item::Static(v0.clone()),
crate::Item::Struct(v0) => crate::Item::Struct(v0.clone()),
crate::Item::Trait(v0) => crate::Item::Trait(v0.clone()),
crate::Item::TraitAlias(v0) => crate::Item::TraitAlias(v0.clone()),
crate::Item::Type(v0) => crate::Item::Type(v0.clone()),
crate::Item::Union(v0) => crate::Item::Union(v0.clone()),
crate::Item::Use(v0) => crate::Item::Use(v0.clone()),
crate::Item::Verbatim(v0) => crate::Item::Verbatim(v0.clone()),
crate::Item::Global(v0) => crate::Item::Global(v0.clone()),
crate::Item::BroadcastUse(v0) => crate::Item::BroadcastUse(v0.clone()),
crate::Item::BroadcastGroup(v0) => crate::Item::BroadcastGroup(v0.clone()),
crate::Item::AssumeSpecification(v0) => {
crate::Item::AssumeSpecification(v0.clone())
}
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ItemBroadcastGroup {
fn clone(&self) -> Self {
crate::ItemBroadcastGroup {
attrs: self.attrs.clone(),
vis: self.vis.clone(),
broadcast_group_tokens: self.broadcast_group_tokens.clone(),
ident: self.ident.clone(),
brace_token: self.brace_token.clone(),
paths: self.paths.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ItemConst {
fn clone(&self) -> Self {
crate::ItemConst {
attrs: self.attrs.clone(),
vis: self.vis.clone(),
publish: self.publish.clone(),
mode: self.mode.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(),
ensures: self.ensures.clone(),
eq_token: self.eq_token.clone(),
block: self.block.clone(),
expr: self.expr.clone(),
semi_token: self.semi_token.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ItemEnum {
fn clone(&self) -> Self {
crate::ItemEnum {
attrs: self.attrs.clone(),
vis: self.vis.clone(),
mode: self.mode.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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ItemExternCrate {
fn clone(&self) -> Self {
crate::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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ItemFn {
fn clone(&self) -> Self {
crate::ItemFn {
attrs: self.attrs.clone(),
vis: self.vis.clone(),
sig: self.sig.clone(),
block: self.block.clone(),
semi_token: self.semi_token.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ItemForeignMod {
fn clone(&self) -> Self {
crate::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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ItemImpl {
fn clone(&self) -> Self {
crate::ItemImpl {
attrs: self.attrs.clone(),
defaultness: self.defaultness.clone(),
unsafety: self.unsafety.clone(),
constness: self.constness.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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ItemMacro {
fn clone(&self) -> Self {
crate::ItemMacro {
attrs: self.attrs.clone(),
ident: self.ident.clone(),
mac: self.mac.clone(),
semi_token: self.semi_token.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ItemMod {
fn clone(&self) -> Self {
crate::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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ItemStatic {
fn clone(&self) -> Self {
crate::ItemStatic {
attrs: self.attrs.clone(),
vis: self.vis.clone(),
publish: self.publish.clone(),
mode: self.mode.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(),
ensures: self.ensures.clone(),
eq_token: self.eq_token.clone(),
block: self.block.clone(),
expr: self.expr.clone(),
semi_token: self.semi_token.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ItemStruct {
fn clone(&self) -> Self {
crate::ItemStruct {
attrs: self.attrs.clone(),
vis: self.vis.clone(),
mode: self.mode.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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ItemTrait {
fn clone(&self) -> Self {
crate::ItemTrait {
attrs: self.attrs.clone(),
vis: self.vis.clone(),
constness: self.constness.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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ItemTraitAlias {
fn clone(&self) -> Self {
crate::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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ItemType {
fn clone(&self) -> Self {
crate::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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ItemUnion {
fn clone(&self) -> Self {
crate::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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ItemUse {
fn clone(&self) -> Self {
crate::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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Label {
fn clone(&self) -> Self {
crate::Label {
name: self.name.clone(),
colon_token: self.colon_token.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::LifetimeParam {
fn clone(&self) -> Self {
crate::LifetimeParam {
attrs: self.attrs.clone(),
lifetime: self.lifetime.clone(),
colon_token: self.colon_token.clone(),
bounds: self.bounds.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Lit {
fn clone(&self) -> Self {
match self {
crate::Lit::Str(v0) => crate::Lit::Str(v0.clone()),
crate::Lit::ByteStr(v0) => crate::Lit::ByteStr(v0.clone()),
crate::Lit::CStr(v0) => crate::Lit::CStr(v0.clone()),
crate::Lit::Byte(v0) => crate::Lit::Byte(v0.clone()),
crate::Lit::Char(v0) => crate::Lit::Char(v0.clone()),
crate::Lit::Int(v0) => crate::Lit::Int(v0.clone()),
crate::Lit::Float(v0) => crate::Lit::Float(v0.clone()),
crate::Lit::Bool(v0) => crate::Lit::Bool(v0.clone()),
crate::Lit::Verbatim(v0) => crate::Lit::Verbatim(v0.clone()),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::LitBool {
fn clone(&self) -> Self {
crate::LitBool {
value: self.value.clone(),
span: self.span.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Local {
fn clone(&self) -> Self {
crate::Local {
attrs: self.attrs.clone(),
let_token: self.let_token.clone(),
tracked: self.tracked.clone(),
ghost: self.ghost.clone(),
pat: self.pat.clone(),
init: self.init.clone(),
semi_token: self.semi_token.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::LocalInit {
fn clone(&self) -> Self {
crate::LocalInit {
eq_token: self.eq_token.clone(),
expr: self.expr.clone(),
diverge: self.diverge.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::LoopSpec {
fn clone(&self) -> Self {
crate::LoopSpec {
iter_name: self.iter_name.clone(),
invariants: self.invariants.clone(),
invariant_except_breaks: self.invariant_except_breaks.clone(),
ensures: self.ensures.clone(),
decreases: self.decreases.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Macro {
fn clone(&self) -> Self {
crate::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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::MacroDelimiter {
fn clone(&self) -> Self {
match self {
crate::MacroDelimiter::Paren(v0) => crate::MacroDelimiter::Paren(v0.clone()),
crate::MacroDelimiter::Brace(v0) => crate::MacroDelimiter::Brace(v0.clone()),
crate::MacroDelimiter::Bracket(v0) => {
crate::MacroDelimiter::Bracket(v0.clone())
}
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::MatchesOpExpr {
fn clone(&self) -> Self {
crate::MatchesOpExpr {
op_token: self.op_token.clone(),
rhs: self.rhs.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::MatchesOpToken {
fn clone(&self) -> Self {
match self {
crate::MatchesOpToken::Implies(v0) => {
crate::MatchesOpToken::Implies(v0.clone())
}
crate::MatchesOpToken::AndAnd(v0) => {
crate::MatchesOpToken::AndAnd(v0.clone())
}
crate::MatchesOpToken::BigAnd => crate::MatchesOpToken::BigAnd,
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Member {
fn clone(&self) -> Self {
match self {
crate::Member::Named(v0) => crate::Member::Named(v0.clone()),
crate::Member::Unnamed(v0) => crate::Member::Unnamed(v0.clone()),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Meta {
fn clone(&self) -> Self {
match self {
crate::Meta::Path(v0) => crate::Meta::Path(v0.clone()),
crate::Meta::List(v0) => crate::Meta::List(v0.clone()),
crate::Meta::NameValue(v0) => crate::Meta::NameValue(v0.clone()),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::MetaList {
fn clone(&self) -> Self {
crate::MetaList {
path: self.path.clone(),
delimiter: self.delimiter.clone(),
tokens: self.tokens.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::MetaNameValue {
fn clone(&self) -> Self {
crate::MetaNameValue {
path: self.path.clone(),
eq_token: self.eq_token.clone(),
value: self.value.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Mode {
fn clone(&self) -> Self {
match self {
crate::Mode::Spec(v0) => crate::Mode::Spec(v0.clone()),
crate::Mode::Proof(v0) => crate::Mode::Proof(v0.clone()),
crate::Mode::Exec(v0) => crate::Mode::Exec(v0.clone()),
crate::Mode::Default => crate::Mode::Default,
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ModeExec {
fn clone(&self) -> Self {
crate::ModeExec {
exec_token: self.exec_token.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ModeGhost {
fn clone(&self) -> Self {
crate::ModeGhost {
ghost_token: self.ghost_token.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ModeProof {
fn clone(&self) -> Self {
crate::ModeProof {
proof_token: self.proof_token.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ModeProofAxiom {
fn clone(&self) -> Self {
crate::ModeProofAxiom {
axiom_token: self.axiom_token.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ModeSpec {
fn clone(&self) -> Self {
crate::ModeSpec {
spec_token: self.spec_token.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ModeSpecChecked {
fn clone(&self) -> Self {
crate::ModeSpecChecked {
spec_token: self.spec_token.clone(),
paren_token: self.paren_token.clone(),
checked: self.checked.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ModeTracked {
fn clone(&self) -> Self {
crate::ModeTracked {
tracked_token: self.tracked_token.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Open {
fn clone(&self) -> Self {
crate::Open {
token: self.token.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::OpenRestricted {
fn clone(&self) -> Self {
crate::OpenRestricted {
open_token: self.open_token.clone(),
paren_token: self.paren_token.clone(),
in_token: self.in_token.clone(),
path: self.path.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::OuterMask {
fn clone(&self) -> Self {
crate::OuterMask {
token: self.token.clone(),
set: self.set.clone(),
comma_token: self.comma_token.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ParenthesizedGenericArguments {
fn clone(&self) -> Self {
crate::ParenthesizedGenericArguments {
paren_token: self.paren_token.clone(),
inputs: self.inputs.clone(),
output: self.output.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Pat {
fn clone(&self) -> Self {
match self {
crate::Pat::Const(v0) => crate::Pat::Const(v0.clone()),
crate::Pat::Ident(v0) => crate::Pat::Ident(v0.clone()),
crate::Pat::Lit(v0) => crate::Pat::Lit(v0.clone()),
crate::Pat::Macro(v0) => crate::Pat::Macro(v0.clone()),
crate::Pat::Or(v0) => crate::Pat::Or(v0.clone()),
crate::Pat::Paren(v0) => crate::Pat::Paren(v0.clone()),
crate::Pat::Path(v0) => crate::Pat::Path(v0.clone()),
crate::Pat::Range(v0) => crate::Pat::Range(v0.clone()),
crate::Pat::Reference(v0) => crate::Pat::Reference(v0.clone()),
crate::Pat::Rest(v0) => crate::Pat::Rest(v0.clone()),
crate::Pat::Slice(v0) => crate::Pat::Slice(v0.clone()),
crate::Pat::Struct(v0) => crate::Pat::Struct(v0.clone()),
crate::Pat::Tuple(v0) => crate::Pat::Tuple(v0.clone()),
crate::Pat::TupleStruct(v0) => crate::Pat::TupleStruct(v0.clone()),
crate::Pat::Type(v0) => crate::Pat::Type(v0.clone()),
crate::Pat::Verbatim(v0) => crate::Pat::Verbatim(v0.clone()),
crate::Pat::Wild(v0) => crate::Pat::Wild(v0.clone()),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::PatIdent {
fn clone(&self) -> Self {
crate::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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::PatOr {
fn clone(&self) -> Self {
crate::PatOr {
attrs: self.attrs.clone(),
leading_vert: self.leading_vert.clone(),
cases: self.cases.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::PatParen {
fn clone(&self) -> Self {
crate::PatParen {
attrs: self.attrs.clone(),
paren_token: self.paren_token.clone(),
pat: self.pat.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::PatReference {
fn clone(&self) -> Self {
crate::PatReference {
attrs: self.attrs.clone(),
and_token: self.and_token.clone(),
mutability: self.mutability.clone(),
pat: self.pat.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::PatRest {
fn clone(&self) -> Self {
crate::PatRest {
attrs: self.attrs.clone(),
dot2_token: self.dot2_token.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::PatSlice {
fn clone(&self) -> Self {
crate::PatSlice {
attrs: self.attrs.clone(),
bracket_token: self.bracket_token.clone(),
elems: self.elems.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::PatStruct {
fn clone(&self) -> Self {
crate::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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::PatTuple {
fn clone(&self) -> Self {
crate::PatTuple {
attrs: self.attrs.clone(),
paren_token: self.paren_token.clone(),
elems: self.elems.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::PatTupleStruct {
fn clone(&self) -> Self {
crate::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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::PatType {
fn clone(&self) -> Self {
crate::PatType {
attrs: self.attrs.clone(),
pat: self.pat.clone(),
colon_token: self.colon_token.clone(),
ty: self.ty.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::PatWild {
fn clone(&self) -> Self {
crate::PatWild {
attrs: self.attrs.clone(),
underscore_token: self.underscore_token.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Path {
fn clone(&self) -> Self {
crate::Path {
leading_colon: self.leading_colon.clone(),
segments: self.segments.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::PathArguments {
fn clone(&self) -> Self {
match self {
crate::PathArguments::None => crate::PathArguments::None,
crate::PathArguments::AngleBracketed(v0) => {
crate::PathArguments::AngleBracketed(v0.clone())
}
crate::PathArguments::Parenthesized(v0) => {
crate::PathArguments::Parenthesized(v0.clone())
}
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::PathSegment {
fn clone(&self) -> Self {
crate::PathSegment {
ident: self.ident.clone(),
arguments: self.arguments.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::PermClause {
fn clone(&self) -> Self {
crate::PermClause {
old_perms: self.old_perms.clone(),
arrow_token: self.arrow_token.clone(),
new_perms: self.new_perms.clone(),
comma_token: self.comma_token.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::PermTuple {
fn clone(&self) -> Self {
crate::PermTuple {
paren_token: self.paren_token.clone(),
fields: self.fields.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::PermTupleField {
fn clone(&self) -> Self {
crate::PermTupleField {
ident: self.ident.clone(),
colon_token: self.colon_token.clone(),
ty: self.ty.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::PointerMutability {
fn clone(&self) -> Self {
match self {
crate::PointerMutability::Const(v0) => {
crate::PointerMutability::Const(v0.clone())
}
crate::PointerMutability::Mut(v0) => {
crate::PointerMutability::Mut(v0.clone())
}
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::PreciseCapture {
fn clone(&self) -> Self {
crate::PreciseCapture {
use_token: self.use_token.clone(),
lt_token: self.lt_token.clone(),
params: self.params.clone(),
gt_token: self.gt_token.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::PredTypeClause {
fn clone(&self) -> Self {
crate::PredTypeClause {
type_token: self.type_token.clone(),
ident: self.ident.clone(),
comma_token: self.comma_token.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::PredicateLifetime {
fn clone(&self) -> Self {
crate::PredicateLifetime {
lifetime: self.lifetime.clone(),
colon_token: self.colon_token.clone(),
bounds: self.bounds.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::PredicateType {
fn clone(&self) -> Self {
crate::PredicateType {
lifetimes: self.lifetimes.clone(),
bounded_ty: self.bounded_ty.clone(),
colon_token: self.colon_token.clone(),
bounds: self.bounds.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Prover {
fn clone(&self) -> Self {
crate::Prover {
by_token: self.by_token.clone(),
paren_token: self.paren_token.clone(),
id: self.id.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Publish {
fn clone(&self) -> Self {
match self {
crate::Publish::Closed(v0) => crate::Publish::Closed(v0.clone()),
crate::Publish::Open(v0) => crate::Publish::Open(v0.clone()),
crate::Publish::OpenRestricted(v0) => {
crate::Publish::OpenRestricted(v0.clone())
}
crate::Publish::Uninterp(v0) => crate::Publish::Uninterp(v0.clone()),
crate::Publish::Default => crate::Publish::Default,
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::QSelf {
fn clone(&self) -> Self {
crate::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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Copy for crate::RangeLimits {}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::RangeLimits {
fn clone(&self) -> Self {
*self
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Receiver {
fn clone(&self) -> Self {
crate::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_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Recommends {
fn clone(&self) -> Self {
crate::Recommends {
token: self.token.clone(),
exprs: self.exprs.clone(),
via: self.via.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Requires {
fn clone(&self) -> Self {
crate::Requires {
token: self.token.clone(),
exprs: self.exprs.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ReturnPat {
fn clone(&self) -> Self {
match self {
crate::ReturnPat::Default => crate::ReturnPat::Default,
crate::ReturnPat::Pat(v0, v1, v2, v3) => {
crate::ReturnPat::Pat(v0.clone(), v1.clone(), v2.clone(), v3.clone())
}
crate::ReturnPat::Type(v0, v1) => {
crate::ReturnPat::Type(v0.clone(), v1.clone())
}
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ReturnType {
fn clone(&self) -> Self {
match self {
crate::ReturnType::Default => crate::ReturnType::Default,
crate::ReturnType::Type(v0, v1, v2, v3) => {
crate::ReturnType::Type(v0.clone(), v1.clone(), v2.clone(), v3.clone())
}
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::ReturnValue {
fn clone(&self) -> Self {
crate::ReturnValue {
token: self.token.clone(),
pat: self.pat.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Returns {
fn clone(&self) -> Self {
crate::Returns {
token: self.token.clone(),
exprs: self.exprs.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::RevealHide {
fn clone(&self) -> Self {
crate::RevealHide {
attrs: self.attrs.clone(),
reveal_token: self.reveal_token.clone(),
reveal_with_fuel_token: self.reveal_with_fuel_token.clone(),
hide_token: self.hide_token.clone(),
paren_token: self.paren_token.clone(),
path: self.path.clone(),
fuel: self.fuel.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Signature {
fn clone(&self) -> Self {
crate::Signature {
publish: self.publish.clone(),
constness: self.constness.clone(),
asyncness: self.asyncness.clone(),
unsafety: self.unsafety.clone(),
abi: self.abi.clone(),
broadcast: self.broadcast.clone(),
mode: self.mode.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(),
spec: self.spec.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::SignatureDecreases {
fn clone(&self) -> Self {
crate::SignatureDecreases {
decreases: self.decreases.clone(),
when: self.when.clone(),
via: self.via.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::SignatureInvariants {
fn clone(&self) -> Self {
crate::SignatureInvariants {
token: self.token.clone(),
set: self.set.clone(),
comma: self.comma.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::SignatureSpec {
fn clone(&self) -> Self {
crate::SignatureSpec {
prover: self.prover.clone(),
atomic_spec: self.atomic_spec.clone(),
requires: self.requires.clone(),
recommends: self.recommends.clone(),
ensures: self.ensures.clone(),
default_ensures: self.default_ensures.clone(),
returns: self.returns.clone(),
decreases: self.decreases.clone(),
invariants: self.invariants.clone(),
unwind: self.unwind.clone(),
with: self.with.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::SignatureSpecAttr {
fn clone(&self) -> Self {
crate::SignatureSpecAttr {
ret_pat: self.ret_pat.clone(),
spec: self.spec.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::SignatureUnwind {
fn clone(&self) -> Self {
crate::SignatureUnwind {
token: self.token.clone(),
when: self.when.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Specification {
fn clone(&self) -> Self {
crate::Specification {
exprs: self.exprs.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::StaticMutability {
fn clone(&self) -> Self {
match self {
crate::StaticMutability::Mut(v0) => crate::StaticMutability::Mut(v0.clone()),
crate::StaticMutability::None => crate::StaticMutability::None,
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Stmt {
fn clone(&self) -> Self {
match self {
crate::Stmt::Local(v0) => crate::Stmt::Local(v0.clone()),
crate::Stmt::Item(v0) => crate::Stmt::Item(v0.clone()),
crate::Stmt::Expr(v0, v1) => crate::Stmt::Expr(v0.clone(), v1.clone()),
crate::Stmt::Macro(v0) => crate::Stmt::Macro(v0.clone()),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::StmtMacro {
fn clone(&self) -> Self {
crate::StmtMacro {
attrs: self.attrs.clone(),
mac: self.mac.clone(),
semi_token: self.semi_token.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::TraitBound {
fn clone(&self) -> Self {
crate::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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Copy for crate::TraitBoundModifier {}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::TraitBoundModifier {
fn clone(&self) -> Self {
*self
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::TraitItem {
fn clone(&self) -> Self {
match self {
crate::TraitItem::Const(v0) => crate::TraitItem::Const(v0.clone()),
crate::TraitItem::Fn(v0) => crate::TraitItem::Fn(v0.clone()),
crate::TraitItem::Type(v0) => crate::TraitItem::Type(v0.clone()),
crate::TraitItem::Macro(v0) => crate::TraitItem::Macro(v0.clone()),
crate::TraitItem::Verbatim(v0) => crate::TraitItem::Verbatim(v0.clone()),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::TraitItemConst {
fn clone(&self) -> Self {
crate::TraitItemConst {
attrs: self.attrs.clone(),
publish: self.publish.clone(),
mode: self.mode.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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::TraitItemFn {
fn clone(&self) -> Self {
crate::TraitItemFn {
attrs: self.attrs.clone(),
sig: self.sig.clone(),
default: self.default.clone(),
semi_token: self.semi_token.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::TraitItemMacro {
fn clone(&self) -> Self {
crate::TraitItemMacro {
attrs: self.attrs.clone(),
mac: self.mac.clone(),
semi_token: self.semi_token.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::TraitItemType {
fn clone(&self) -> Self {
crate::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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Type {
fn clone(&self) -> Self {
match self {
crate::Type::Array(v0) => crate::Type::Array(v0.clone()),
crate::Type::BareFn(v0) => crate::Type::BareFn(v0.clone()),
crate::Type::Group(v0) => crate::Type::Group(v0.clone()),
crate::Type::ImplTrait(v0) => crate::Type::ImplTrait(v0.clone()),
crate::Type::Infer(v0) => crate::Type::Infer(v0.clone()),
crate::Type::Macro(v0) => crate::Type::Macro(v0.clone()),
crate::Type::Never(v0) => crate::Type::Never(v0.clone()),
crate::Type::Paren(v0) => crate::Type::Paren(v0.clone()),
crate::Type::Path(v0) => crate::Type::Path(v0.clone()),
crate::Type::Ptr(v0) => crate::Type::Ptr(v0.clone()),
crate::Type::Reference(v0) => crate::Type::Reference(v0.clone()),
crate::Type::Slice(v0) => crate::Type::Slice(v0.clone()),
crate::Type::TraitObject(v0) => crate::Type::TraitObject(v0.clone()),
crate::Type::Tuple(v0) => crate::Type::Tuple(v0.clone()),
crate::Type::Verbatim(v0) => crate::Type::Verbatim(v0.clone()),
crate::Type::FnSpec(v0) => crate::Type::FnSpec(v0.clone()),
crate::Type::FnProof(v0) => crate::Type::FnProof(v0.clone()),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::TypeArray {
fn clone(&self) -> Self {
crate::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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::TypeBareFn {
fn clone(&self) -> Self {
crate::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_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::TypeFnProof {
fn clone(&self) -> Self {
crate::TypeFnProof {
proof_fn_token: self.proof_fn_token.clone(),
generics: self.generics.clone(),
options: self.options.clone(),
paren_token: self.paren_token.clone(),
inputs: self.inputs.clone(),
output: self.output.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::TypeFnSpec {
fn clone(&self) -> Self {
crate::TypeFnSpec {
fn_spec_token: self.fn_spec_token.clone(),
spec_fn_token: self.spec_fn_token.clone(),
paren_token: self.paren_token.clone(),
inputs: self.inputs.clone(),
output: self.output.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::TypeGroup {
fn clone(&self) -> Self {
crate::TypeGroup {
group_token: self.group_token.clone(),
elem: self.elem.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::TypeImplTrait {
fn clone(&self) -> Self {
crate::TypeImplTrait {
impl_token: self.impl_token.clone(),
bounds: self.bounds.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::TypeInfer {
fn clone(&self) -> Self {
crate::TypeInfer {
underscore_token: self.underscore_token.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::TypeMacro {
fn clone(&self) -> Self {
crate::TypeMacro {
mac: self.mac.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::TypeNever {
fn clone(&self) -> Self {
crate::TypeNever {
bang_token: self.bang_token.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::TypeParam {
fn clone(&self) -> Self {
crate::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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::TypeParamBound {
fn clone(&self) -> Self {
match self {
crate::TypeParamBound::Trait(v0) => crate::TypeParamBound::Trait(v0.clone()),
crate::TypeParamBound::Lifetime(v0) => {
crate::TypeParamBound::Lifetime(v0.clone())
}
#[cfg(feature = "full")]
crate::TypeParamBound::PreciseCapture(v0) => {
crate::TypeParamBound::PreciseCapture(v0.clone())
}
crate::TypeParamBound::Verbatim(v0) => {
crate::TypeParamBound::Verbatim(v0.clone())
}
#[cfg(not(feature = "full"))]
_ => unreachable!(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::TypeParen {
fn clone(&self) -> Self {
crate::TypeParen {
paren_token: self.paren_token.clone(),
elem: self.elem.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::TypePath {
fn clone(&self) -> Self {
crate::TypePath {
qself: self.qself.clone(),
path: self.path.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::TypePtr {
fn clone(&self) -> Self {
crate::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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::TypeReference {
fn clone(&self) -> Self {
crate::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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::TypeSlice {
fn clone(&self) -> Self {
crate::TypeSlice {
bracket_token: self.bracket_token.clone(),
elem: self.elem.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::TypeTraitObject {
fn clone(&self) -> Self {
crate::TypeTraitObject {
dyn_token: self.dyn_token.clone(),
bounds: self.bounds.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::TypeTuple {
fn clone(&self) -> Self {
crate::TypeTuple {
paren_token: self.paren_token.clone(),
elems: self.elems.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Copy for crate::UnOp {}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::UnOp {
fn clone(&self) -> Self {
*self
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Uninterp {
fn clone(&self) -> Self {
crate::Uninterp {
token: self.token.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::UseGlob {
fn clone(&self) -> Self {
crate::UseGlob {
star_token: self.star_token.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::UseGroup {
fn clone(&self) -> Self {
crate::UseGroup {
brace_token: self.brace_token.clone(),
items: self.items.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::UseName {
fn clone(&self) -> Self {
crate::UseName {
ident: self.ident.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::UsePath {
fn clone(&self) -> Self {
crate::UsePath {
ident: self.ident.clone(),
colon2_token: self.colon2_token.clone(),
tree: self.tree.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::UseRename {
fn clone(&self) -> Self {
crate::UseRename {
ident: self.ident.clone(),
as_token: self.as_token.clone(),
rename: self.rename.clone(),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::UseTree {
fn clone(&self) -> Self {
match self {
crate::UseTree::Path(v0) => crate::UseTree::Path(v0.clone()),
crate::UseTree::Name(v0) => crate::UseTree::Name(v0.clone()),
crate::UseTree::Rename(v0) => crate::UseTree::Rename(v0.clone()),
crate::UseTree::Glob(v0) => crate::UseTree::Glob(v0.clone()),
crate::UseTree::Group(v0) => crate::UseTree::Group(v0.clone()),
}
}
}
#[cfg(feature = "full")]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Variadic {
fn clone(&self) -> Self {
crate::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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Variant {
fn clone(&self) -> Self {
crate::Variant {
attrs: self.attrs.clone(),
ident: self.ident.clone(),
fields: self.fields.clone(),
discriminant: self.discriminant.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::View {
fn clone(&self) -> Self {
crate::View {
attrs: self.attrs.clone(),
expr: self.expr.clone(),
at_token: self.at_token.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::VisRestricted {
fn clone(&self) -> Self {
crate::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(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::Visibility {
fn clone(&self) -> Self {
match self {
crate::Visibility::Public(v0) => crate::Visibility::Public(v0.clone()),
crate::Visibility::Restricted(v0) => {
crate::Visibility::Restricted(v0.clone())
}
crate::Visibility::Inherited => crate::Visibility::Inherited,
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::WhereClause {
fn clone(&self) -> Self {
crate::WhereClause {
where_token: self.where_token.clone(),
predicates: self.predicates.clone(),
}
}
}
#[cfg(any(feature = "derive", feature = "full"))]
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::WherePredicate {
fn clone(&self) -> Self {
match self {
crate::WherePredicate::Lifetime(v0) => {
crate::WherePredicate::Lifetime(v0.clone())
}
crate::WherePredicate::Type(v0) => crate::WherePredicate::Type(v0.clone()),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::WithSpecOnExpr {
fn clone(&self) -> Self {
crate::WithSpecOnExpr {
with: self.with.clone(),
inputs: self.inputs.clone(),
outputs: self.outputs.clone(),
follows: self.follows.clone(),
erased_fields: self.erased_fields.clone(),
}
}
}
#[cfg_attr(docsrs, doc(cfg(feature = "clone-impls")))]
impl Clone for crate::WithSpecOnFn {
fn clone(&self) -> Self {
crate::WithSpecOnFn {
with: self.with.clone(),
inputs: self.inputs.clone(),
outputs: self.outputs.clone(),
}
}
}