Improve snapshot tests of Encapsulate derive macro

Author: regexident

tests/derive-tests/encapsulate/pass/enum/tuple_variants/one_field.out.rs renamed to tests/derive-tests/encapsulate/pass/enum/exclude_attr.out.rs

@@ -1,6 +1,4 @@
-use enumcapsulate::{
-    AsVariant, AsVariantMut, AsVariantRef, Encapsulate, FromVariant, IntoVariant,
-};
+use enumcapsulate::Encapsulate;
 pub struct VariantA;
 #[automatically_derived]
 impl ::core::clone::Clone for VariantA {
@@ -17,46 +15,41 @@ impl ::core::clone::Clone for VariantB {
         VariantB
     }
 }
-pub enum Enum {
-    VariantA(VariantA),
-    VariantB { b: VariantB },
-}
-impl ::core::convert::From<VariantA> for Enum {
-    fn from(inner: VariantA) -> Self {
-        Self::VariantA(inner)
-    }
-}
-impl ::core::convert::From<VariantB> for Enum {
-    fn from(inner: VariantB) -> Self {
-        Self::VariantB { b: inner }
+pub struct VariantC;
+#[automatically_derived]
+impl ::core::clone::Clone for VariantC {
+    #[inline]
+    fn clone(&self) -> VariantC {
+        VariantC
     }
 }
-impl ::core::convert::TryFrom<Enum> for VariantA {
-    type Error = Enum;
-    fn try_from(outer: Enum) -> Result<Self, Self::Error> {
-        match outer {
-            Enum::VariantA(inner, ..) => Ok(inner),
-            err => Err(err),
-        }
+pub struct VariantD;
+#[automatically_derived]
+impl ::core::clone::Clone for VariantD {
+    #[inline]
+    fn clone(&self) -> VariantD {
+        VariantD
     }
 }
-impl ::core::convert::TryFrom<Enum> for VariantB {
-    type Error = Enum;
-    fn try_from(outer: Enum) -> Result<Self, Self::Error> {
-        match outer {
-            Enum::VariantB { b: inner, .. } => Ok(inner),
-            err => Err(err),
-        }
-    }
+#[enumcapsulate(exclude(From, TryInto))]
+pub enum Enum {
+    OneTupleField(VariantA),
+    OneStructField { variant: VariantB },
+    #[enumcapsulate(exclude)]
+    ExcludedWildcard(VariantC),
+    #[enumcapsulate(exclude(FromVariant, AsVariant))]
+    ExcludedSelective(VariantD),
 }
 impl ::enumcapsulate::FromVariant<VariantA> for Enum {
     fn from_variant(inner: VariantA) -> Self {
-        Self::VariantA(inner)
+        Self::OneTupleField(inner)
     }
 }
 impl ::enumcapsulate::FromVariant<VariantB> for Enum {
     fn from_variant(inner: VariantB) -> Self {
-        Self::VariantB { b: inner }
+        Self::OneStructField {
+            variant: inner,
+        }
     }
 }
 impl ::enumcapsulate::AsVariant<VariantA> for Enum
@@ -65,7 +58,7 @@ where
 {
     fn as_variant(&self) -> Option<VariantA> {
         match self {
-            Enum::VariantA(inner, ..) => Some(inner.clone()),
+            Enum::OneTupleField(inner, ..) => Some(inner.clone()),
             _ => None,
         }
     }
@@ -76,63 +69,89 @@ where
 {
     fn as_variant(&self) -> Option<VariantB> {
         match self {
-            Enum::VariantB { b: inner, .. } => Some(inner.clone()),
+            Enum::OneStructField { variant: inner, .. } => Some(inner.clone()),
             _ => None,
         }
     }
 }
 impl ::enumcapsulate::AsVariantRef<VariantA> for Enum {
     fn as_variant_ref(&self) -> Option<&VariantA> {
         match self {
-            Enum::VariantA(inner, ..) => Some(inner),
+            Enum::OneTupleField(inner, ..) => Some(inner),
             _ => None,
         }
     }
 }
 impl ::enumcapsulate::AsVariantRef<VariantB> for Enum {
     fn as_variant_ref(&self) -> Option<&VariantB> {
         match self {
-            Enum::VariantB { b: inner, .. } => Some(inner),
+            Enum::OneStructField { variant: inner, .. } => Some(inner),
+            _ => None,
+        }
+    }
+}
+impl ::enumcapsulate::AsVariantRef<VariantD> for Enum {
+    fn as_variant_ref(&self) -> Option<&VariantD> {
+        match self {
+            Enum::ExcludedSelective(inner, ..) => Some(inner),
             _ => None,
         }
     }
 }
 impl ::enumcapsulate::AsVariantMut<VariantA> for Enum {
     fn as_variant_mut(&mut self) -> Option<&mut VariantA> {
         match self {
-            Enum::VariantA(inner, ..) => Some(inner),
+            Enum::OneTupleField(inner, ..) => Some(inner),
             _ => None,
         }
     }
 }
 impl ::enumcapsulate::AsVariantMut<VariantB> for Enum {
     fn as_variant_mut(&mut self) -> Option<&mut VariantB> {
         match self {
-            Enum::VariantB { b: inner, .. } => Some(inner),
+            Enum::OneStructField { variant: inner, .. } => Some(inner),
+            _ => None,
+        }
+    }
+}
+impl ::enumcapsulate::AsVariantMut<VariantD> for Enum {
+    fn as_variant_mut(&mut self) -> Option<&mut VariantD> {
+        match self {
+            Enum::ExcludedSelective(inner, ..) => Some(inner),
             _ => None,
         }
     }
 }
 impl ::enumcapsulate::IntoVariant<VariantA> for Enum {
     fn into_variant(self) -> Result<VariantA, Self> {
         match self {
-            Enum::VariantA(inner, ..) => Ok(inner),
+            Enum::OneTupleField(inner, ..) => Ok(inner),
             err => Err(err),
         }
     }
 }
 impl ::enumcapsulate::IntoVariant<VariantB> for Enum {
     fn into_variant(self) -> Result<VariantB, Self> {
         match self {
-            Enum::VariantB { b: inner, .. } => Ok(inner),
+            Enum::OneStructField { variant: inner, .. } => Ok(inner),
+            err => Err(err),
+        }
+    }
+}
+impl ::enumcapsulate::IntoVariant<VariantD> for Enum {
+    fn into_variant(self) -> Result<VariantD, Self> {
+        match self {
+            Enum::ExcludedSelective(inner, ..) => Ok(inner),
             err => Err(err),
         }
     }
 }
 impl ::enumcapsulate::VariantDowncast for Enum {}
 pub enum EnumDiscriminant {
-    VariantA,
-    VariantB,
+    OneTupleField,
+    OneStructField,
+    ExcludedWildcard,
+    ExcludedSelective,
 }
 #[automatically_derived]
 impl ::core::marker::Copy for EnumDiscriminant {}
@@ -176,8 +195,10 @@ impl ::core::fmt::Debug for EnumDiscriminant {
         ::core::fmt::Formatter::write_str(
             f,
             match self {
-                EnumDiscriminant::VariantA => "VariantA",
-                EnumDiscriminant::VariantB => "VariantB",
+                EnumDiscriminant::OneTupleField => "OneTupleField",
+                EnumDiscriminant::OneStructField => "OneStructField",
+                EnumDiscriminant::ExcludedWildcard => "ExcludedWildcard",
+                EnumDiscriminant::ExcludedSelective => "ExcludedSelective",
             },
         )
     }
@@ -186,18 +207,12 @@ impl ::enumcapsulate::VariantDiscriminant for Enum {
     type Discriminant = EnumDiscriminant;
     fn variant_discriminant(&self) -> Self::Discriminant {
         match self {
-            Enum::VariantA(..) => EnumDiscriminant::VariantA,
-            Enum::VariantB { .. } => EnumDiscriminant::VariantB,
+            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 check<T, U>()
-where
-    T: FromVariant<U> + IntoVariant<U> + From<U> + TryInto<U> + AsVariant<U>
-        + AsVariantRef<U> + AsVariantMut<U>,
-{}
-fn main() {
-    check::<Enum, VariantA>();
-    check::<Enum, VariantB>();
-}
+fn main() {}

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

@@ -0,0 +1,25 @@
+use enumcapsulate::Encapsulate;
+
+#[derive(Clone)]
+pub struct VariantA;
+#[derive(Clone)]
+pub struct VariantB;
+#[derive(Clone)]
+pub struct VariantC;
+#[derive(Clone)]
+pub struct VariantD;
+
+#[derive(Encapsulate)]
+#[enumcapsulate(exclude(From, TryInto))]
+pub enum Enum {
+    OneTupleField(VariantA),
+    OneStructField {
+        variant: VariantB,
+    },
+    #[enumcapsulate(exclude)]
+    ExcludedWildcard(VariantC),
+    #[enumcapsulate(exclude(FromVariant, AsVariant))]
+    ExcludedSelective(VariantD),
+}
+
+fn main() {}