Remove VariantDiscriminant from list of traits derived by the Encapsulate umbrella macro

Author: regexident

macros/src/enum_deriver.rs

@@ -646,9 +646,6 @@ impl EnumDeriver {
         let variant_downcast = enum_config
             .is_included(macro_name::VARIANT_DOWNCAST)
             .then_some(self.derive_variant_downcast()?);
-        let variant_discriminant = enum_config
-            .is_included(macro_name::VARIANT_DISCRIMINANT)
-            .then_some(self.derive_variant_discriminant()?);
 
         Ok(quote::quote! {
             #from
@@ -659,7 +656,6 @@ impl EnumDeriver {
             #as_variant_mut
             #into_variant
             #variant_downcast
-            #variant_discriminant
         })
     }
 

tests/derive-tests/encapsulate/pass/enum/exclude_attr.out.rs

@@ -147,72 +147,4 @@ impl ::enumcapsulate::IntoVariant<VariantD> for Enum {
     }
 }
 impl ::enumcapsulate::VariantDowncast for Enum {}
-pub enum EnumDiscriminant {
-    OneTupleField,
-    OneStructField,
-    ExcludedWildcard,
-    ExcludedSelective,
-}
-#[automatically_derived]
-impl ::core::marker::Copy for EnumDiscriminant {}
-#[automatically_derived]
-impl ::core::clone::Clone for EnumDiscriminant {
-    #[inline]
-    fn clone(&self) -> EnumDiscriminant {
-        *self
-    }
-}
-#[automatically_derived]
-impl ::core::cmp::Eq for EnumDiscriminant {
-    #[inline]
-    #[doc(hidden)]
-    #[coverage(off)]
-    fn assert_receiver_is_total_eq(&self) -> () {}
-}
-#[automatically_derived]
-impl ::core::marker::StructuralPartialEq for EnumDiscriminant {}
-#[automatically_derived]
-impl ::core::cmp::PartialEq for EnumDiscriminant {
-    #[inline]
-    fn eq(&self, other: &EnumDiscriminant) -> bool {
-        let __self_tag = ::core::intrinsics::discriminant_value(self);
-        let __arg1_tag = ::core::intrinsics::discriminant_value(other);
-        __self_tag == __arg1_tag
-    }
-}
-#[automatically_derived]
-impl ::core::hash::Hash for EnumDiscriminant {
-    #[inline]
-    fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
-        let __self_tag = ::core::intrinsics::discriminant_value(self);
-        ::core::hash::Hash::hash(&__self_tag, state)
-    }
-}
-#[automatically_derived]
-impl ::core::fmt::Debug for EnumDiscriminant {
-    #[inline]
-    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-        ::core::fmt::Formatter::write_str(
-            f,
-            match self {
-                EnumDiscriminant::OneTupleField => "OneTupleField",
-                EnumDiscriminant::OneStructField => "OneStructField",
-                EnumDiscriminant::ExcludedWildcard => "ExcludedWildcard",
-                EnumDiscriminant::ExcludedSelective => "ExcludedSelective",
-            },
-        )
-    }
-}
-impl ::enumcapsulate::VariantDiscriminant for Enum {
-    type Discriminant = EnumDiscriminant;
-    fn variant_discriminant(&self) -> Self::Discriminant {
-        match self {
-            Enum::OneTupleField(..) => EnumDiscriminant::OneTupleField,
-            Enum::OneStructField { .. } => EnumDiscriminant::OneStructField,
-            Enum::ExcludedWildcard(..) => EnumDiscriminant::ExcludedWildcard,
-            Enum::ExcludedSelective(..) => EnumDiscriminant::ExcludedSelective,
-            _ => ::core::panicking::panic("internal error: entered unreachable code"),
-        }
-    }
-}
 fn main() {}

tests/derive-tests/encapsulate/pass/enum/generics.out.rs

@@ -388,125 +388,4 @@ impl<'l, const N: usize, T> ::enumcapsulate::VariantDowncast for Enum<'l, N, T>
 where
     T: HasAssoc,
 {}
-pub enum EnumDiscriminant {
-    Unit,
-    OwnedSpecificType,
-    BorrowedSpecificType,
-    OwnedWithGenericLifetime,
-    OwnedGenericTypeWithConstParam,
-    OwnedGenericTypeWithTypeParam,
-    OwnedGenericTypeWithMixedParams,
-    OwnedGenericParam,
-    BorrowedGenericParam,
-    OwnedAssocTypeOfGenericParam,
-    OwnedAssocTypeOfGenericParamBehindCast,
-    OwnedAssocTypeOfSpecificTypeBehindCast,
-}
-#[automatically_derived]
-impl ::core::marker::Copy for EnumDiscriminant {}
-#[automatically_derived]
-impl ::core::clone::Clone for EnumDiscriminant {
-    #[inline]
-    fn clone(&self) -> EnumDiscriminant {
-        *self
-    }
-}
-#[automatically_derived]
-impl ::core::cmp::Eq for EnumDiscriminant {
-    #[inline]
-    #[doc(hidden)]
-    #[coverage(off)]
-    fn assert_receiver_is_total_eq(&self) -> () {}
-}
-#[automatically_derived]
-impl ::core::marker::StructuralPartialEq for EnumDiscriminant {}
-#[automatically_derived]
-impl ::core::cmp::PartialEq for EnumDiscriminant {
-    #[inline]
-    fn eq(&self, other: &EnumDiscriminant) -> bool {
-        let __self_tag = ::core::intrinsics::discriminant_value(self);
-        let __arg1_tag = ::core::intrinsics::discriminant_value(other);
-        __self_tag == __arg1_tag
-    }
-}
-#[automatically_derived]
-impl ::core::hash::Hash for EnumDiscriminant {
-    #[inline]
-    fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
-        let __self_tag = ::core::intrinsics::discriminant_value(self);
-        ::core::hash::Hash::hash(&__self_tag, state)
-    }
-}
-#[automatically_derived]
-impl ::core::fmt::Debug for EnumDiscriminant {
-    #[inline]
-    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-        ::core::fmt::Formatter::write_str(
-            f,
-            match self {
-                EnumDiscriminant::Unit => "Unit",
-                EnumDiscriminant::OwnedSpecificType => "OwnedSpecificType",
-                EnumDiscriminant::BorrowedSpecificType => "BorrowedSpecificType",
-                EnumDiscriminant::OwnedWithGenericLifetime => "OwnedWithGenericLifetime",
-                EnumDiscriminant::OwnedGenericTypeWithConstParam => {
-                    "OwnedGenericTypeWithConstParam"
-                }
-                EnumDiscriminant::OwnedGenericTypeWithTypeParam => {
-                    "OwnedGenericTypeWithTypeParam"
-                }
-                EnumDiscriminant::OwnedGenericTypeWithMixedParams => {
-                    "OwnedGenericTypeWithMixedParams"
-                }
-                EnumDiscriminant::OwnedGenericParam => "OwnedGenericParam",
-                EnumDiscriminant::BorrowedGenericParam => "BorrowedGenericParam",
-                EnumDiscriminant::OwnedAssocTypeOfGenericParam => {
-                    "OwnedAssocTypeOfGenericParam"
-                }
-                EnumDiscriminant::OwnedAssocTypeOfGenericParamBehindCast => {
-                    "OwnedAssocTypeOfGenericParamBehindCast"
-                }
-                EnumDiscriminant::OwnedAssocTypeOfSpecificTypeBehindCast => {
-                    "OwnedAssocTypeOfSpecificTypeBehindCast"
-                }
-            },
-        )
-    }
-}
-impl<'l, const N: usize, T> ::enumcapsulate::VariantDiscriminant for Enum<'l, N, T>
-where
-    T: HasAssoc,
-{
-    type Discriminant = EnumDiscriminant;
-    fn variant_discriminant(&self) -> Self::Discriminant {
-        match self {
-            Enum::Unit => EnumDiscriminant::Unit,
-            Enum::OwnedSpecificType(..) => EnumDiscriminant::OwnedSpecificType,
-            Enum::BorrowedSpecificType(..) => EnumDiscriminant::BorrowedSpecificType,
-            Enum::OwnedWithGenericLifetime(..) => {
-                EnumDiscriminant::OwnedWithGenericLifetime
-            }
-            Enum::OwnedGenericTypeWithConstParam(..) => {
-                EnumDiscriminant::OwnedGenericTypeWithConstParam
-            }
-            Enum::OwnedGenericTypeWithTypeParam(..) => {
-                EnumDiscriminant::OwnedGenericTypeWithTypeParam
-            }
-            Enum::OwnedGenericTypeWithMixedParams(..) => {
-                EnumDiscriminant::OwnedGenericTypeWithMixedParams
-            }
-            Enum::OwnedGenericParam(..) => EnumDiscriminant::OwnedGenericParam,
-            Enum::BorrowedGenericParam(..) => EnumDiscriminant::BorrowedGenericParam,
-            Enum::OwnedAssocTypeOfGenericParam(..) => {
-                EnumDiscriminant::OwnedAssocTypeOfGenericParam
-            }
-            Enum::OwnedAssocTypeOfGenericParamBehindCast(..) => {
-                EnumDiscriminant::OwnedAssocTypeOfGenericParamBehindCast
-            }
-            Enum::OwnedAssocTypeOfSpecificTypeBehindCast(..) => {
-                EnumDiscriminant::OwnedAssocTypeOfSpecificTypeBehindCast
-            }
-            _ => ::core::panicking::panic("internal error: entered unreachable code"),
-        }
-    }
-}
 fn main() {}

tests/derive-tests/encapsulate/pass/enum/mixed_variants.out.rs

@@ -275,90 +275,4 @@ impl ::enumcapsulate::IntoVariant<VariantD> for Enum {
     }
 }
 impl ::enumcapsulate::VariantDowncast for Enum {}
-pub enum EnumDiscriminant {
-    Unit,
-    ZeroTupleFields,
-    ZeroStructFields,
-    OneTupleField,
-    OneStructField,
-    TwoTupleFields,
-    TwoStructFields,
-    Excluded,
-    IncludedTuple,
-    IncludedStruct,
-}
-#[automatically_derived]
-impl ::core::marker::Copy for EnumDiscriminant {}
-#[automatically_derived]
-impl ::core::clone::Clone for EnumDiscriminant {
-    #[inline]
-    fn clone(&self) -> EnumDiscriminant {
-        *self
-    }
-}
-#[automatically_derived]
-impl ::core::cmp::Eq for EnumDiscriminant {
-    #[inline]
-    #[doc(hidden)]
-    #[coverage(off)]
-    fn assert_receiver_is_total_eq(&self) -> () {}
-}
-#[automatically_derived]
-impl ::core::marker::StructuralPartialEq for EnumDiscriminant {}
-#[automatically_derived]
-impl ::core::cmp::PartialEq for EnumDiscriminant {
-    #[inline]
-    fn eq(&self, other: &EnumDiscriminant) -> bool {
-        let __self_tag = ::core::intrinsics::discriminant_value(self);
-        let __arg1_tag = ::core::intrinsics::discriminant_value(other);
-        __self_tag == __arg1_tag
-    }
-}
-#[automatically_derived]
-impl ::core::hash::Hash for EnumDiscriminant {
-    #[inline]
-    fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
-        let __self_tag = ::core::intrinsics::discriminant_value(self);
-        ::core::hash::Hash::hash(&__self_tag, state)
-    }
-}
-#[automatically_derived]
-impl ::core::fmt::Debug for EnumDiscriminant {
-    #[inline]
-    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-        ::core::fmt::Formatter::write_str(
-            f,
-            match self {
-                EnumDiscriminant::Unit => "Unit",
-                EnumDiscriminant::ZeroTupleFields => "ZeroTupleFields",
-                EnumDiscriminant::ZeroStructFields => "ZeroStructFields",
-                EnumDiscriminant::OneTupleField => "OneTupleField",
-                EnumDiscriminant::OneStructField => "OneStructField",
-                EnumDiscriminant::TwoTupleFields => "TwoTupleFields",
-                EnumDiscriminant::TwoStructFields => "TwoStructFields",
-                EnumDiscriminant::Excluded => "Excluded",
-                EnumDiscriminant::IncludedTuple => "IncludedTuple",
-                EnumDiscriminant::IncludedStruct => "IncludedStruct",
-            },
-        )
-    }
-}
-impl ::enumcapsulate::VariantDiscriminant for Enum {
-    type Discriminant = EnumDiscriminant;
-    fn variant_discriminant(&self) -> Self::Discriminant {
-        match self {
-            Enum::Unit => EnumDiscriminant::Unit,
-            Enum::ZeroTupleFields(..) => EnumDiscriminant::ZeroTupleFields,
-            Enum::ZeroStructFields { .. } => EnumDiscriminant::ZeroStructFields,
-            Enum::OneTupleField(..) => EnumDiscriminant::OneTupleField,
-            Enum::OneStructField { .. } => EnumDiscriminant::OneStructField,
-            Enum::TwoTupleFields(..) => EnumDiscriminant::TwoTupleFields,
-            Enum::TwoStructFields { .. } => EnumDiscriminant::TwoStructFields,
-            Enum::Excluded(..) => EnumDiscriminant::Excluded,
-            Enum::IncludedTuple(..) => EnumDiscriminant::IncludedTuple,
-            Enum::IncludedStruct { .. } => EnumDiscriminant::IncludedStruct,
-            _ => ::core::panicking::panic("internal error: entered unreachable code"),
-        }
-    }
-}
 fn main() {}

tests/derive-tests/encapsulate/pass/enum/zero_variants.out.rs

@@ -3,54 +3,6 @@ use enumcapsulate::{
 };
 pub enum Enum {}
 impl ::enumcapsulate::VariantDowncast for Enum {}
-pub enum EnumDiscriminant {}
-#[automatically_derived]
-impl ::core::marker::Copy for EnumDiscriminant {}
-#[automatically_derived]
-impl ::core::clone::Clone for EnumDiscriminant {
-    #[inline]
-    fn clone(&self) -> EnumDiscriminant {
-        *self
-    }
-}
-#[automatically_derived]
-impl ::core::cmp::Eq for EnumDiscriminant {
-    #[inline]
-    #[doc(hidden)]
-    #[coverage(off)]
-    fn assert_receiver_is_total_eq(&self) -> () {}
-}
-#[automatically_derived]
-impl ::core::marker::StructuralPartialEq for EnumDiscriminant {}
-#[automatically_derived]
-impl ::core::cmp::PartialEq for EnumDiscriminant {
-    #[inline]
-    fn eq(&self, other: &EnumDiscriminant) -> bool {
-        match *self {}
-    }
-}
-#[automatically_derived]
-impl ::core::hash::Hash for EnumDiscriminant {
-    #[inline]
-    fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
-        match *self {}
-    }
-}
-#[automatically_derived]
-impl ::core::fmt::Debug for EnumDiscriminant {
-    #[inline]
-    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-        match *self {}
-    }
-}
-impl ::enumcapsulate::VariantDiscriminant for Enum {
-    type Discriminant = EnumDiscriminant;
-    fn variant_discriminant(&self) -> Self::Discriminant {
-        match self {
-            _ => ::core::panicking::panic("internal error: entered unreachable code"),
-        }
-    }
-}
 fn check<T>()
 where
     T: VariantDowncast,