cairo-lang-plugins 2.1.2

//! > Test expansion of derive.

//! > test_runner_name
test_expand_plugin

//! > cairo_code
#[derive(Copy, Drop)]
struct A{}

#[derive(Copy, Drop)]
struct B{}

#[derive(Clone, Destruct, PanicDestruct, PartialEq, Serde)]
struct TwoMemberStruct {
    a: A,
    b: B,
}

#[derive(Copy, Destruct, PanicDestruct)]
struct GenericStruct<T> {
    a: T,
}


trait SomeTrait<T, U> {}

#[derive(Drop, Clone, PartialEq, Serde)]
struct TwoMemberGenericStruct<T, U, impl USomeTrait: SomeTrait<U, T>> {
    a: T,
    b: U,
}

#[derive(Clone, Destruct, PanicDestruct, PartialEq, Serde)]
enum TwoVariantEnum {
    First: A,
    Second: B,
}

#[derive(Copy, Drop)]
extern type ExternType;

//! > generated_cairo_code
#[derive(Copy, Drop)]
struct A{}

impl ACopy<> of Copy::<A<>>;
impl ADrop<> of Drop::<A<>>;


#[derive(Copy, Drop)]
struct B{}

impl BCopy<> of Copy::<B<>>;
impl BDrop<> of Drop::<B<>>;


#[derive(Clone, Destruct, PanicDestruct, PartialEq, Serde)]
struct TwoMemberStruct {
    a: A,
    b: B,
}

impl TwoMemberStructClone<> of Clone::<TwoMemberStruct<>> {
    fn clone(self: @TwoMemberStruct<>) -> TwoMemberStruct<> {
        TwoMemberStruct {
            a: self.a.clone(),
            b: self.b.clone(),
        }
    }
}
impl TwoMemberStructDestruct<> of Destruct::<TwoMemberStruct<>> {
    fn destruct(self: TwoMemberStruct<>) nopanic {
        traits::Destruct::destruct(self.a);
        traits::Destruct::destruct(self.b);
    }
}
impl TwoMemberStructPanicDestruct<> of PanicDestruct::<TwoMemberStruct<>> {
    fn panic_destruct(self: TwoMemberStruct<>, ref panic: Panic) nopanic {
        traits::PanicDestruct::panic_destruct(self.a, ref panic);
        traits::PanicDestruct::panic_destruct(self.b, ref panic);
    }
}
impl TwoMemberStructPartialEq<> of PartialEq::<TwoMemberStruct<>> {
    #[inline(always)]
    fn eq(lhs: @TwoMemberStruct<>, rhs: @TwoMemberStruct<>) -> bool {
        lhs.a == rhs.a && lhs.b == rhs.b
    }
    #[inline(always)]
    fn ne(lhs: @TwoMemberStruct<>, rhs: @TwoMemberStruct<>) -> bool {
        !(lhs == rhs)
    }
}
impl TwoMemberStructSerde<> of serde::Serde::<TwoMemberStruct<>> {
    fn serialize(self: @TwoMemberStruct<>, ref output: array::Array<felt252>) {
        serde::Serde::serialize(self.a, ref output);
        serde::Serde::serialize(self.b, ref output)
    }
    fn deserialize(ref serialized: array::Span<felt252>) -> Option<TwoMemberStruct<>> {
        Option::Some(TwoMemberStruct {
            a: serde::Serde::deserialize(ref serialized)?,
            b: serde::Serde::deserialize(ref serialized)?,
        })
    }
}


#[derive(Copy, Destruct, PanicDestruct)]
struct GenericStruct<T> {
    a: T,
}

impl GenericStructCopy<T, impl TCopy: Copy<T>> of Copy::<GenericStruct<T, >>;
impl GenericStructDestruct<T, impl TDestruct: Destruct<T>> of Destruct::<GenericStruct<T, >> {
    fn destruct(self: GenericStruct<T, >) nopanic {
        traits::Destruct::destruct(self.a);
    }
}
impl GenericStructPanicDestruct<T, impl TPanicDestruct: PanicDestruct<T>> of PanicDestruct::<GenericStruct<T, >> {
    fn panic_destruct(self: GenericStruct<T, >, ref panic: Panic) nopanic {
        traits::PanicDestruct::panic_destruct(self.a, ref panic);
    }
}



trait SomeTrait<T, U> {}


#[derive(Drop, Clone, PartialEq, Serde)]
struct TwoMemberGenericStruct<T, U, impl USomeTrait: SomeTrait<U, T>> {
    a: T,
    b: U,
}

impl TwoMemberGenericStructDrop<T, U, impl USomeTrait: SomeTrait<U, T>, impl TDrop: Drop<T>, impl UDrop: Drop<U>> of Drop::<TwoMemberGenericStruct<T, U, impl USomeTrait: SomeTrait<U, T>, >>;
impl TwoMemberGenericStructClone<T, U, impl USomeTrait: SomeTrait<U, T>, impl TClone: Clone<T>, impl TDestruct: Destruct<T>, impl UClone: Clone<U>, impl UDestruct: Destruct<U>> of Clone::<TwoMemberGenericStruct<T, U, impl USomeTrait: SomeTrait<U, T>, >> {
    fn clone(self: @TwoMemberGenericStruct<T, U, impl USomeTrait: SomeTrait<U, T>, >) -> TwoMemberGenericStruct<T, U, impl USomeTrait: SomeTrait<U, T>, > {
        TwoMemberGenericStruct {
            a: self.a.clone(),
            b: self.b.clone(),
        }
    }
}
impl TwoMemberGenericStructPartialEq<T, U, impl USomeTrait: SomeTrait<U, T>, impl TPartialEq: PartialEq<T>, impl TDestruct: Destruct<T>, impl UPartialEq: PartialEq<U>, impl UDestruct: Destruct<U>> of PartialEq::<TwoMemberGenericStruct<T, U, impl USomeTrait: SomeTrait<U, T>, >> {
    #[inline(always)]
    fn eq(lhs: @TwoMemberGenericStruct<T, U, impl USomeTrait: SomeTrait<U, T>, >, rhs: @TwoMemberGenericStruct<T, U, impl USomeTrait: SomeTrait<U, T>, >) -> bool {
        lhs.a == rhs.a && lhs.b == rhs.b
    }
    #[inline(always)]
    fn ne(lhs: @TwoMemberGenericStruct<T, U, impl USomeTrait: SomeTrait<U, T>, >, rhs: @TwoMemberGenericStruct<T, U, impl USomeTrait: SomeTrait<U, T>, >) -> bool {
        !(lhs == rhs)
    }
}
impl TwoMemberGenericStructSerde<T, U, impl USomeTrait: SomeTrait<U, T>, impl TSerde: serde::Serde<T>, impl TDestruct: Destruct<T>, impl USerde: serde::Serde<U>, impl UDestruct: Destruct<U>> of serde::Serde::<TwoMemberGenericStruct<T, U, impl USomeTrait: SomeTrait<U, T>, >> {
    fn serialize(self: @TwoMemberGenericStruct<T, U, impl USomeTrait: SomeTrait<U, T>, >, ref output: array::Array<felt252>) {
        serde::Serde::serialize(self.a, ref output);
        serde::Serde::serialize(self.b, ref output)
    }
    fn deserialize(ref serialized: array::Span<felt252>) -> Option<TwoMemberGenericStruct<T, U, impl USomeTrait: SomeTrait<U, T>, >> {
        Option::Some(TwoMemberGenericStruct {
            a: serde::Serde::deserialize(ref serialized)?,
            b: serde::Serde::deserialize(ref serialized)?,
        })
    }
}


#[derive(Clone, Destruct, PanicDestruct, PartialEq, Serde)]
enum TwoVariantEnum {
    First: A,
    Second: B,
}

impl TwoVariantEnumClone of Clone::<TwoVariantEnum> {
    fn clone(self: @TwoVariantEnum) -> TwoVariantEnum {
        match self {
            TwoVariantEnum::First(x) => TwoVariantEnum::First(x.clone()),
            TwoVariantEnum::Second(x) => TwoVariantEnum::Second(x.clone()),
        }
    }
}
impl TwoVariantEnumDestruct of Destruct::<TwoVariantEnum> {
    fn destruct(self: TwoVariantEnum) nopanic {
        match self {
            TwoVariantEnum::First(x) => traits::Destruct::destruct(x),
            TwoVariantEnum::Second(x) => traits::Destruct::destruct(x),
        }
    }
}
impl TwoVariantEnumPanicDestruct of PanicDestruct::<TwoVariantEnum> {
    fn panic_destruct(self: TwoVariantEnum, ref panic: Panic) nopanic {
        match self {
            TwoVariantEnum::First(x) => traits::PanicDestruct::panic_destruct(x, ref panic),
            TwoVariantEnum::Second(x) => traits::PanicDestruct::panic_destruct(x, ref panic),
        }
    }
}
impl TwoVariantEnumPartialEq of PartialEq::<TwoVariantEnum> {
    fn eq(lhs: @TwoVariantEnum, rhs: @TwoVariantEnum) -> bool {
        match lhs {
            TwoVariantEnum::First(x) => match rhs {
                TwoVariantEnum::First(y) => x == y,
                TwoVariantEnum::Second(y) => false,
            },
            TwoVariantEnum::Second(x) => match rhs {
                TwoVariantEnum::First(y) => false,
                TwoVariantEnum::Second(y) => x == y,
            },
        }
    }
    #[inline(always)]
    fn ne(lhs: @TwoVariantEnum, rhs: @TwoVariantEnum) -> bool {
        !(lhs == rhs)
    }
}
impl TwoVariantEnumSerde of serde::Serde::<TwoVariantEnum> {
    fn serialize(self: @TwoVariantEnum, ref output: array::Array<felt252>) {
        match self {
            TwoVariantEnum::First(x) => { serde::Serde::serialize(@0, ref output); serde::Serde::serialize(x, ref output); },
            TwoVariantEnum::Second(x) => { serde::Serde::serialize(@1, ref output); serde::Serde::serialize(x, ref output); },
        }
    }
    fn deserialize(ref serialized: array::Span<felt252>) -> Option<TwoVariantEnum> {
        let idx: felt252 = serde::Serde::deserialize(ref serialized)?;
        Option::Some(
            if idx == 0 { TwoVariantEnum::First(serde::Serde::deserialize(ref serialized)?) }
            else if idx == 1 { TwoVariantEnum::Second(serde::Serde::deserialize(ref serialized)?) }
            else { return Option::None; }
        )
    }
}


#[derive(Copy, Drop)]
extern type ExternType;
impl ExternTypeCopy of Copy::<ExternType>;
impl ExternTypeDrop of Drop::<ExternType>;

//! > expected_diagnostics

//! > ==========================================================================

//! > Test diagnostics of derive.

//! > test_runner_name
test_expand_plugin

//! > cairo_code
#[derive()]
struct EmptyArgs{}

#[derive(1)]
struct NotPath{}

#[derive(Unsupported)]
struct UnsupportedTrait{}

#[derive(long::path)]
struct NonSimplePath{}

#[derive(Clone)]
extern type NotClonable;

//! > generated_cairo_code
#[derive()]
struct EmptyArgs{}


#[derive(1)]
struct NotPath{}


#[derive(Unsupported)]
struct UnsupportedTrait{}


#[derive(long::path)]
struct NonSimplePath{}


#[derive(Clone)]
extern type NotClonable;

//! > expected_diagnostics
error: Expected args.
 --> dummy_file.cairo:1:9
#[derive()]
        ^^

error: Expected path.
 --> dummy_file.cairo:4:10
#[derive(1)]
         ^

error: Unsupported trait for derive for extern types.
 --> dummy_file.cairo:13:10
#[derive(Clone)]
         ^***^