From 238cfbc94809611e75df87fd0c9a6dd9110bbdc1 Mon Sep 17 00:00:00 2001
From: Vincent Esche <regexident@gmail.com>
Date: Fri, 29 Nov 2024 11:57:22 +0100
Subject: [PATCH 1/5] Fix formatting

---
 macros/src/enum_deriver.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/macros/src/enum_deriver.rs b/macros/src/enum_deriver.rs
index aba6d0c..db44342 100644
--- a/macros/src/enum_deriver.rs
+++ b/macros/src/enum_deriver.rs
@@ -379,6 +379,7 @@ impl EnumDeriver {
             if self.uses_generic_const_or_type(inner_ty) {
                 continue;
             }
+
             let pattern = match &variant.fields {
                 Fields::Named(_) => {
                     let field = inner_ident;

From eab55a19a70e5aba7efcb04ffcb44e8844b0e363 Mon Sep 17 00:00:00 2001
From: Vincent Esche <regexident@gmail.com>
Date: Fri, 29 Nov 2024 17:11:32 +0100
Subject: [PATCH 2/5] Refactor derive macro's input parsing

---
 macros/Cargo.toml                             |   2 +-
 macros/src/config.rs                          | 126 +++++++++++-------
 macros/src/config/tests.rs                    | 109 ++++++++-------
 macros/src/enum_deriver.rs                    | 107 ++++++---------
 macros/src/lib.rs                             |  47 +++----
 macros/src/utils.rs                           |   6 +-
 .../as_variant/fail/struct.err.txt            |   6 +-
 .../as_variant/fail/union.err.txt             |   6 +-
 .../as_variant_mut/fail/struct.err.txt        |   6 +-
 .../as_variant_mut/fail/union.err.txt         |   6 +-
 .../as_variant_ref/fail/struct.err.txt        |   6 +-
 .../as_variant_ref/fail/union.err.txt         |   6 +-
 tests/derive-tests/from/fail/struct.err.txt   |   6 +-
 tests/derive-tests/from/fail/union.err.txt    |   6 +-
 .../from_variant/fail/struct.err.txt          |   6 +-
 .../from_variant/fail/union.err.txt           |   6 +-
 .../into_variant/fail/struct.err.txt          |   6 +-
 .../into_variant/fail/union.err.txt           |   6 +-
 .../derive-tests/try_into/fail/struct.err.txt |   6 +-
 .../derive-tests/try_into/fail/union.err.txt  |   6 +-
 .../variant_downcast/fail/struct.err.txt      |   6 +-
 .../variant_downcast/fail/union.err.txt       |   6 +-
 22 files changed, 257 insertions(+), 236 deletions(-)

diff --git a/macros/Cargo.toml b/macros/Cargo.toml
index 9db9f62..43b7a94 100644
--- a/macros/Cargo.toml
+++ b/macros/Cargo.toml
@@ -20,4 +20,4 @@ proc-macro = true
 [dependencies]
 proc-macro2 = { version = "1.0.81", features = ["span-locations"] }
 quote = "1.0.36"
-syn = { version = "2.0.60", features = ["derive", "visit"] }
+syn = { version = "2.0.60", features = ["full", "visit"] }
diff --git a/macros/src/config.rs b/macros/src/config.rs
index 4a043a3..e0e88bd 100644
--- a/macros/src/config.rs
+++ b/macros/src/config.rs
@@ -30,31 +30,57 @@ pub(crate) enum VariantFieldConfig {
     Index(usize),
 }
 
-#[derive(Clone, Default, Debug)]
+#[derive(Clone, Default, PartialEq, Eq, Debug)]
+pub(crate) struct MacroSelectionConfig {
+    pub idents: Vec<syn::Ident>,
+}
+
+impl MacroSelectionConfig {
+    pub fn is_empty(&self) -> bool {
+        self.idents.is_empty()
+    }
+
+    pub fn contains(&self, name: &str) -> bool {
+        self.idents.iter().any(|ident| ident == name)
+    }
+
+    pub fn extend_idents(&mut self, iter: impl IntoIterator<Item = syn::Ident>) {
+        self.idents.extend(iter);
+    }
+
+    pub(crate) fn idents(&self) -> &[syn::Ident] {
+        &self.idents
+    }
+}
+
+pub(crate) type EnumExcludeConfig = MacroSelectionConfig;
+pub(crate) type VariantExcludeConfig = MacroSelectionConfig;
+pub(crate) type VariantIncludeConfig = MacroSelectionConfig;
+
+#[derive(Clone, Default)]
 pub(crate) struct EnumConfig {
     // #[enumcapsulate(exclude(…))]
-    pub exclude: Option<Vec<syn::Ident>>,
+    pub exclude: Option<EnumExcludeConfig>,
 }
 
 impl EnumConfig {
     pub fn is_excluded(&self, name: &str) -> bool {
-        if let Some(excluded) = &self.exclude {
-            return excluded.iter().any(|ident| ident == name);
-        } else {
-            false
-        }
+        self.exclude
+            .as_ref()
+            .map(|excluded| excluded.contains(name))
+            .unwrap_or(false)
     }
 }
 
-#[derive(Clone, Default, Debug)]
+#[derive(Clone, Default)]
 pub(crate) struct VariantConfig {
     // #[enumcapsulate(exclude(…))]
-    pub exclude: Option<Vec<syn::Ident>>,
+    pub exclude: Option<VariantExcludeConfig>,
 
     // #[enumcapsulate(include(…))]
-    pub include: Option<Vec<syn::Ident>>,
+    pub include: Option<VariantIncludeConfig>,
 
-    // #[enumcapsulate(field(… = …))]
+    // #[enumcapsulate(field(…))]
     pub field: Option<VariantFieldConfig>,
 }
 
@@ -73,49 +99,48 @@ impl VariantConfig {
     }
 
     pub fn is_excluded_explicitly(&self, name: &str) -> bool {
-        if let Some(excluded) = &self.exclude {
-            if excluded.is_empty() {
-                if let Some(included) = &self.include {
-                    return !included.iter().any(|ident| ident == name);
-                } else {
-                    return true;
-                }
-            }
+        let Some(excluded) = &self.exclude else {
+            return false;
+        };
 
-            excluded.iter().any(|ident| ident == name)
-        } else {
-            false
+        if excluded.is_empty() {
+            if let Some(included) = &self.include {
+                return !included.contains(name);
+            } else {
+                return true;
+            }
         }
+
+        excluded.contains(name)
     }
 
     pub fn is_included_explicitly(&self, name: &str) -> bool {
-        if let Some(included) = &self.include {
-            if included.is_empty() {
-                if let Some(excluded) = &self.exclude {
-                    return !excluded.iter().any(|ident| ident == name);
-                } else {
-                    return true;
-                }
-            }
+        let Some(included) = &self.include else {
+            return false;
+        };
 
-            included.iter().any(|ident| ident == name)
-        } else {
-            false
+        if included.is_empty() {
+            if let Some(excluded) = &self.exclude {
+                return !excluded.contains(name);
+            } else {
+                return true;
+            }
         }
+
+        included.contains(name)
     }
 }
 
-pub(crate) fn config_for_enum_with_attrs(
-    enum_attrs: &[syn::Attribute],
-) -> Result<EnumConfig, syn::Error> {
+pub(crate) fn config_for_enum(enum_item: &syn::ItemEnum) -> Result<EnumConfig, syn::Error> {
     let mut config = EnumConfig::default();
 
-    parse_enumcapsulate_attrs(enum_attrs, |meta| {
+    parse_enumcapsulate_attrs(&enum_item.attrs, |meta| {
         if meta.path.is_ident(attr::EXCLUDE) {
             // #[enumcapsulate(exclude(…))]
 
             let mut exclude = config.exclude.take().unwrap_or_default();
-            exclude.extend(macro_idents_for_enum(&meta)?.into_iter());
+            exclude.extend_idents(macro_selection_config_for_enum(&meta)?.idents);
+
             config.exclude = Some(exclude);
         } else {
             return Err(meta.error("unrecognized attribute"));
@@ -141,17 +166,19 @@ pub(crate) fn config_for_variant(variant: &syn::Variant) -> Result<VariantConfig
             // #[enumcapsulate(exclude(…))]
 
             let mut exclude = config.exclude.take().unwrap_or_default();
-            let conflicting = config.include.as_deref().unwrap_or(&[]);
 
-            exclude.extend(macro_idents_for_variant(&meta, conflicting)?.into_iter());
+            let opposite = config.include.as_ref();
+            exclude.extend_idents(macro_selection_config_for_variant(&meta, opposite)?.idents);
+
             config.exclude = Some(exclude);
         } else if meta.path.is_ident(attr::INCLUDE) {
             // #[enumcapsulate(include(…))]
 
             let mut include = config.include.take().unwrap_or_default();
-            let conflicting = config.exclude.as_deref().unwrap_or(&[]);
 
-            include.extend(macro_idents_for_variant(&meta, conflicting)?.into_iter());
+            let opposite: Option<&MacroSelectionConfig> = config.exclude.as_ref();
+            include.extend_idents(macro_selection_config_for_variant(&meta, opposite)?.idents);
+
             config.include = Some(include);
         } else if meta.path.is_ident(attr::FIELD) {
             // #[enumcapsulate(field(…))]
@@ -233,29 +260,30 @@ pub(crate) fn parse_enumcapsulate_attrs(
     Ok(())
 }
 
-pub(crate) fn macro_idents_for_enum(
+pub(crate) fn macro_selection_config_for_enum(
     meta: &syn::meta::ParseNestedMeta<'_>,
-) -> Result<Vec<syn::Ident>, syn::Error> {
+) -> Result<MacroSelectionConfig, syn::Error> {
     let idents = parse_idents_from_meta_list(meta)?;
 
     let recognized = RECOGNIZED_ENUM_LEVEL_MACROS;
     ensure_only_recognized_ident_names(&idents, recognized)?;
 
-    Ok(idents)
+    Ok(MacroSelectionConfig { idents })
 }
 
-pub(crate) fn macro_idents_for_variant(
+pub(crate) fn macro_selection_config_for_variant(
     meta: &syn::meta::ParseNestedMeta<'_>,
-    conflict_list: &[syn::Ident],
-) -> Result<Vec<syn::Ident>, syn::Error> {
+    opposite: Option<&MacroSelectionConfig>,
+) -> Result<MacroSelectionConfig, syn::Error> {
     let idents = parse_idents_from_meta_list(meta)?;
 
     let recognized = RECOGNIZED_VARIANT_LEVEL_MACROS;
     ensure_only_recognized_ident_names(&idents, recognized)?;
 
+    let conflict_list = opposite.map(|config| config.idents()).unwrap_or(&[]);
     ensure_no_conflicting_idents(&idents, conflict_list)?;
 
-    Ok(idents)
+    Ok(MacroSelectionConfig { idents })
 }
 
 pub(crate) fn ensure_only_recognized_ident_names(
diff --git a/macros/src/config/tests.rs b/macros/src/config/tests.rs
index 1297721..22b1f9f 100644
--- a/macros/src/config/tests.rs
+++ b/macros/src/config/tests.rs
@@ -1,8 +1,8 @@
 use syn::parse_quote;
 
-mod macro_idents {
-    use crate::config::*;
+use crate::config::*;
 
+mod macro_idents {
     use super::*;
 
     #[test]
@@ -118,15 +118,15 @@ mod macro_idents {
 }
 
 mod enum_config {
-    use syn::parse_quote;
-
-    use crate::{config_for_enum_with_attrs, EnumConfig};
+    use super::*;
 
     #[test]
     fn accepts_empty_attrs() -> Result<(), syn::Error> {
-        let attrs: Vec<syn::Attribute> = parse_quote! {};
+        let item: syn::ItemEnum = parse_quote! {
+            enum Dummy {}
+        };
 
-        let config = config_for_enum_with_attrs(&attrs)?;
+        let config = config_for_enum(&item)?;
 
         assert_eq!(config.exclude, None);
 
@@ -135,43 +135,47 @@ mod enum_config {
 
     #[test]
     fn accepts_empty_exclude_attrs() -> Result<(), syn::Error> {
-        let attrs: Vec<syn::Attribute> = parse_quote! {
+        let item: syn::ItemEnum = parse_quote! {
             #[enumcapsulate(exclude)]
+            enum Dummy {}
         };
 
-        let config = config_for_enum_with_attrs(&attrs)?;
+        let config = config_for_enum(&item)?;
 
-        assert_eq!(config.exclude, Some(vec![]));
+        let actual: Vec<syn::Ident> = config.exclude.unwrap().idents;
+        let expected: Vec<syn::Ident> = vec![];
+
+        assert_eq!(actual, expected);
 
         Ok(())
     }
 
     #[test]
     fn accepts_non_empty_exclude_attrs() -> Result<(), syn::Error> {
-        let attrs: Vec<syn::Attribute> = parse_quote! {
+        let item: syn::ItemEnum = parse_quote! {
             #[enumcapsulate(exclude(AsVariant, IntoVariant))]
+            enum Dummy {}
         };
 
-        let config = config_for_enum_with_attrs(&attrs)?;
+        let config = config_for_enum(&item)?;
 
-        assert_eq!(
-            config.exclude,
-            Some(vec![
-                parse_quote! { AsVariant },
-                parse_quote! { IntoVariant }
-            ])
-        );
+        let actual = config.exclude.unwrap().idents;
+        let expected: Vec<syn::Ident> =
+            vec![parse_quote! { AsVariant }, parse_quote! { IntoVariant }];
+
+        assert_eq!(actual, expected);
 
         Ok(())
     }
 
     #[test]
     fn rejects_unrecognized_exclude_attrs() -> Result<(), syn::Error> {
-        let attrs: Vec<syn::Attribute> = parse_quote! {
+        let item: syn::ItemEnum = parse_quote! {
             #[enumcapsulate(exclude(IntoVariant, Unrecognized))]
+            enum Dummy {}
         };
 
-        let error = config_for_enum_with_attrs(&attrs).err().unwrap();
+        let error = config_for_enum(&item).err().unwrap();
 
         assert_eq!(error.to_string(), "unrecognized macro derive");
 
@@ -181,10 +185,9 @@ mod enum_config {
     #[test]
     fn is_excluded() {
         let config = EnumConfig {
-            exclude: Some(vec![
-                parse_quote! { FromVariant },
-                parse_quote! { IntoVariant },
-            ]),
+            exclude: Some(MacroSelectionConfig {
+                idents: vec![parse_quote! { FromVariant }, parse_quote! { IntoVariant }],
+            }),
         };
 
         assert_eq!(config.is_excluded("FromVariant"), true);
@@ -194,9 +197,7 @@ mod enum_config {
 }
 
 mod variant_config {
-    use syn::parse_quote;
-
-    use crate::{config_for_variant, EnumConfig, VariantConfig, VariantFieldConfig};
+    use super::*;
 
     #[test]
     fn accepts_empty_attrs() -> Result<(), syn::Error> {
@@ -330,8 +331,14 @@ mod variant_config {
 
         let config = config_for_variant(&variant)?;
 
-        assert_eq!(config.exclude, Some(vec![]));
-        assert_eq!(config.include, Some(vec![]));
+        assert_eq!(
+            config.exclude.unwrap(),
+            MacroSelectionConfig { idents: vec![] }
+        );
+        assert_eq!(
+            config.include.unwrap(),
+            MacroSelectionConfig { idents: vec![] }
+        );
         assert_eq!(config.field, None);
 
         Ok(())
@@ -348,15 +355,16 @@ mod variant_config {
         let config = config_for_variant(&variant)?;
 
         assert_eq!(
-            config.exclude,
-            Some(vec![parse_quote! { From }, parse_quote! { TryInto }])
+            config.exclude.unwrap(),
+            MacroSelectionConfig {
+                idents: vec![parse_quote! { From }, parse_quote! { TryInto }]
+            }
         );
         assert_eq!(
-            config.include,
-            Some(vec![
-                parse_quote! { FromVariant },
-                parse_quote! { IntoVariant }
-            ])
+            config.include.unwrap(),
+            MacroSelectionConfig {
+                idents: vec![parse_quote! { FromVariant }, parse_quote! { IntoVariant }]
+            }
         );
 
         Ok(())
@@ -426,7 +434,9 @@ mod variant_config {
         #[test]
         fn only_enum_excludes() {
             let enum_config = EnumConfig {
-                exclude: Some(vec![parse_quote! { AsVariant }]),
+                exclude: Some(MacroSelectionConfig {
+                    idents: vec![parse_quote! { AsVariant }],
+                }),
             };
 
             let config = VariantConfig {
@@ -443,12 +453,14 @@ mod variant_config {
         #[test]
         fn blanket_overridden_enum_excludes() {
             let enum_config = EnumConfig {
-                exclude: Some(vec![parse_quote! { AsVariant }]),
+                exclude: Some(MacroSelectionConfig {
+                    idents: vec![parse_quote! { AsVariant }],
+                }),
             };
 
             let config = VariantConfig {
                 exclude: None,
-                include: Some(vec![]),
+                include: Some(MacroSelectionConfig { idents: vec![] }),
                 field: None,
             };
 
@@ -460,15 +472,16 @@ mod variant_config {
         #[test]
         fn selective_overridden_enum_excludes() {
             let enum_config = EnumConfig {
-                exclude: Some(vec![
-                    parse_quote! { AsVariant },
-                    parse_quote! { IntoVariant },
-                ]),
+                exclude: Some(MacroSelectionConfig {
+                    idents: vec![parse_quote! { AsVariant }, parse_quote! { IntoVariant }],
+                }),
             };
 
             let config = VariantConfig {
                 exclude: None,
-                include: Some(vec![parse_quote! { AsVariant }]),
+                include: Some(MacroSelectionConfig {
+                    idents: vec![parse_quote! { AsVariant }],
+                }),
                 field: None,
             };
 
@@ -482,8 +495,10 @@ mod variant_config {
             let enum_config = EnumConfig { exclude: None };
 
             let config = VariantConfig {
-                exclude: Some(vec![]),
-                include: Some(vec![parse_quote! { AsVariant }]),
+                exclude: Some(MacroSelectionConfig { idents: vec![] }),
+                include: Some(MacroSelectionConfig {
+                    idents: vec![parse_quote! { AsVariant }],
+                }),
                 field: None,
             };
 
diff --git a/macros/src/enum_deriver.rs b/macros/src/enum_deriver.rs
index db44342..52014a1 100644
--- a/macros/src/enum_deriver.rs
+++ b/macros/src/enum_deriver.rs
@@ -1,41 +1,30 @@
 use proc_macro2::TokenStream as TokenStream2;
 use quote::quote;
-use syn::{parse_quote_spanned, visit::Visit as _, DataEnum, DeriveInput, Fields, Type, Variant};
+use syn::{parse_quote_spanned, visit::Visit as _, Fields, Type, Variant};
 
-use crate::{
-    config_for_enum_with_attrs, config_for_variant, macro_name, position_of_selected_field,
-    TypeVisitor,
-};
+use crate::*;
 
 pub(crate) struct EnumDeriver {
-    input: DeriveInput,
+    item: syn::ItemEnum,
 }
 
-impl From<DeriveInput> for EnumDeriver {
-    fn from(input: DeriveInput) -> Self {
-        Self { input }
+impl From<syn::ItemEnum> for EnumDeriver {
+    fn from(item: syn::ItemEnum) -> Self {
+        Self { item }
     }
 }
 
 impl EnumDeriver {
-    fn variants(&self) -> Result<Vec<&Variant>, syn::Error> {
-        let syn::Data::Enum(DataEnum { variants, .. }) = &self.input.data else {
-            return Err(syn::Error::new(
-                self.input.ident.span(),
-                "Only enums can use this derive",
-            ));
-        };
-
-        Ok(Vec::from_iter(variants.iter()))
+    fn variants(&self) -> Vec<&Variant> {
+        self.item.variants.iter().collect()
     }
 
     pub fn derive_from(&self) -> Result<TokenStream2, syn::Error> {
         const DERIVE_MACRO_NAME: &str = macro_name::FROM;
 
-        let derive_input = &self.input;
-        let enum_ident = &derive_input.ident;
+        let enum_ident = &self.item.ident;
 
-        let enum_config = config_for_enum_with_attrs(&self.input.attrs)?;
+        let enum_config = config_for_enum(&self.item)?;
 
         if enum_config.is_excluded(DERIVE_MACRO_NAME) {
             return Ok(TokenStream2::default());
@@ -44,11 +33,11 @@ impl EnumDeriver {
         let outer = enum_ident;
         let outer_ty: Type = parse_quote_spanned! { outer.span() => #outer };
 
-        let (impl_generics, type_generics, where_clause) = self.input.generics.split_for_impl();
+        let (impl_generics, type_generics, where_clause) = self.item.generics.split_for_impl();
 
         let mut impls: Vec<TokenStream2> = vec![];
 
-        for variant in self.variants()? {
+        for variant in self.variants() {
             let variant_ident = &variant.ident;
             let inner = variant_ident;
 
@@ -115,19 +104,18 @@ impl EnumDeriver {
     pub fn derive_try_into(&self) -> Result<TokenStream2, syn::Error> {
         const DERIVE_MACRO_NAME: &str = macro_name::TRY_INTO;
 
-        let derive_input = &self.input;
-        let enum_ident = &derive_input.ident;
+        let enum_ident = &self.item.ident;
 
-        let enum_config = config_for_enum_with_attrs(&self.input.attrs)?;
+        let enum_config = config_for_enum(&self.item)?;
 
         let outer = enum_ident;
         let outer_ty: Type = parse_quote_spanned! { outer.span() => #outer };
 
-        let (impl_generics, type_generics, where_clause) = self.input.generics.split_for_impl();
+        let (impl_generics, type_generics, where_clause) = self.item.generics.split_for_impl();
 
         let mut impls: Vec<TokenStream2> = vec![];
 
-        for variant in self.variants()? {
+        for variant in self.variants() {
             let variant_ident = &variant.ident;
             let inner = variant_ident;
 
@@ -188,19 +176,18 @@ impl EnumDeriver {
     pub fn derive_from_variant(&self) -> Result<TokenStream2, syn::Error> {
         const DERIVE_MACRO_NAME: &str = macro_name::FROM_VARIANT;
 
-        let derive_input = &self.input;
-        let enum_ident = &derive_input.ident;
+        let enum_ident = &self.item.ident;
 
-        let enum_config = config_for_enum_with_attrs(&self.input.attrs)?;
+        let enum_config = config_for_enum(&self.item)?;
 
         let outer = enum_ident;
         let outer_ty: Type = parse_quote_spanned! { outer.span() => #outer };
 
-        let (impl_generics, type_generics, where_clause) = self.input.generics.split_for_impl();
+        let (impl_generics, type_generics, where_clause) = self.item.generics.split_for_impl();
 
         let mut impls: Vec<TokenStream2> = vec![];
 
-        for variant in self.variants()? {
+        for variant in self.variants() {
             let variant_ident = &variant.ident;
             let inner = variant_ident;
 
@@ -267,19 +254,18 @@ impl EnumDeriver {
     pub fn derive_as_variant(&self) -> Result<TokenStream2, syn::Error> {
         const DERIVE_MACRO_NAME: &str = macro_name::AS_VARIANT;
 
-        let derive_input = &self.input;
-        let enum_ident = &derive_input.ident;
+        let enum_ident = &self.item.ident;
 
-        let enum_config = config_for_enum_with_attrs(&self.input.attrs)?;
+        let enum_config = config_for_enum(&self.item)?;
 
         let outer = enum_ident;
         let outer_ty: Type = parse_quote_spanned! { outer.span() => #outer };
 
-        let (impl_generics, type_generics, where_clause) = self.input.generics.split_for_impl();
+        let (impl_generics, type_generics, where_clause) = self.item.generics.split_for_impl();
 
         let mut impls: Vec<TokenStream2> = vec![];
 
-        for variant in self.variants()? {
+        for variant in self.variants() {
             let variant_ident = &variant.ident;
             let inner = variant_ident;
 
@@ -343,19 +329,18 @@ impl EnumDeriver {
     pub fn derive_as_variant_ref(&self) -> Result<TokenStream2, syn::Error> {
         const DERIVE_MACRO_NAME: &str = macro_name::AS_VARIANT_REF;
 
-        let derive_input = &self.input;
-        let enum_ident = &derive_input.ident;
+        let enum_ident = &self.item.ident;
 
-        let enum_config = config_for_enum_with_attrs(&derive_input.attrs)?;
+        let enum_config = config_for_enum(&self.item)?;
 
         let outer = enum_ident;
         let outer_ty: Type = parse_quote_spanned! { outer.span() => #outer };
 
-        let (impl_generics, type_generics, where_clause) = self.input.generics.split_for_impl();
+        let (impl_generics, type_generics, where_clause) = self.item.generics.split_for_impl();
 
         let mut impls: Vec<TokenStream2> = vec![];
 
-        for variant in self.variants()? {
+        for variant in self.variants() {
             let variant_ident = &variant.ident;
             let inner = variant_ident;
 
@@ -414,19 +399,18 @@ impl EnumDeriver {
     pub fn derive_as_variant_mut(&self) -> Result<TokenStream2, syn::Error> {
         const DERIVE_MACRO_NAME: &str = macro_name::AS_VARIANT_MUT;
 
-        let derive_input = &self.input;
-        let enum_ident = &derive_input.ident;
+        let enum_ident = &self.item.ident;
 
-        let enum_config = config_for_enum_with_attrs(&self.input.attrs)?;
+        let enum_config = config_for_enum(&self.item)?;
 
         let outer = enum_ident;
         let outer_ty: Type = parse_quote_spanned! { outer.span() => #outer };
 
-        let (impl_generics, type_generics, where_clause) = self.input.generics.split_for_impl();
+        let (impl_generics, type_generics, where_clause) = self.item.generics.split_for_impl();
 
         let mut impls: Vec<TokenStream2> = vec![];
 
-        for variant in self.variants()? {
+        for variant in self.variants() {
             let variant_ident = &variant.ident;
             let inner = variant_ident;
 
@@ -485,19 +469,18 @@ impl EnumDeriver {
     pub fn derive_into_variant(&self) -> Result<TokenStream2, syn::Error> {
         const DERIVE_MACRO_NAME: &str = macro_name::INTO_VARIANT;
 
-        let derive_input = &self.input;
-        let enum_ident = &derive_input.ident;
+        let enum_ident = &self.item.ident;
 
-        let enum_config = config_for_enum_with_attrs(&self.input.attrs)?;
+        let enum_config = config_for_enum(&self.item)?;
 
         let outer = enum_ident;
         let outer_ty: Type = parse_quote_spanned! { outer.span() => #outer };
 
-        let (impl_generics, type_generics, where_clause) = self.input.generics.split_for_impl();
+        let (impl_generics, type_generics, where_clause) = self.item.generics.split_for_impl();
 
         let mut impls: Vec<TokenStream2> = vec![];
 
-        for variant in self.variants()? {
+        for variant in self.variants() {
             let variant_ident = &variant.ident;
             let inner = variant_ident;
 
@@ -556,10 +539,9 @@ impl EnumDeriver {
     pub fn derive_variant_downcast(&self) -> Result<TokenStream2, syn::Error> {
         const DERIVE_MACRO_NAME: &str = macro_name::VARIANT_DOWNCAST;
 
-        let derive_input = &self.input;
-        let enum_ident = &derive_input.ident;
+        let enum_ident = &self.item.ident;
 
-        let enum_config = config_for_enum_with_attrs(&self.input.attrs)?;
+        let enum_config = config_for_enum(&self.item)?;
 
         if enum_config.is_excluded(DERIVE_MACRO_NAME) {
             return Ok(TokenStream2::default());
@@ -568,7 +550,7 @@ impl EnumDeriver {
         let outer = enum_ident;
         let outer_ty: Type = parse_quote_spanned! { outer.span() => #outer };
 
-        let (impl_generics, type_generics, where_clause) = self.input.generics.split_for_impl();
+        let (impl_generics, type_generics, where_clause) = self.item.generics.split_for_impl();
 
         let tokens = quote! {
             impl #impl_generics ::enumcapsulate::VariantDowncast for #outer_ty #type_generics #where_clause {}
@@ -580,10 +562,9 @@ impl EnumDeriver {
     pub fn derive_variant_discriminant(&self) -> Result<TokenStream2, syn::Error> {
         const DERIVE_MACRO_NAME: &str = macro_name::VARIANT_DISCRIMINANT;
 
-        let derive_input = &self.input;
-        let enum_ident = &derive_input.ident;
+        let enum_ident = &self.item.ident;
 
-        let enum_config = config_for_enum_with_attrs(&self.input.attrs)?;
+        let enum_config = config_for_enum(&self.item)?;
 
         if enum_config.is_excluded(DERIVE_MACRO_NAME) {
             return Ok(TokenStream2::default());
@@ -592,9 +573,9 @@ impl EnumDeriver {
         let outer = enum_ident;
         let outer_ty: Type = parse_quote_spanned! { outer.span() => #outer };
 
-        let (impl_generics, type_generics, where_clause) = self.input.generics.split_for_impl();
+        let (impl_generics, type_generics, where_clause) = self.item.generics.split_for_impl();
 
-        let variants = self.variants()?;
+        let variants = self.variants();
 
         let discriminant_ident = quote::format_ident!("{outer}Discriminant");
 
@@ -655,7 +636,7 @@ impl EnumDeriver {
     }
 
     fn uses_generic_const_or_type(&self, ty: &syn::Type) -> bool {
-        let mut visitor = TypeVisitor::new(&self.input.generics);
+        let mut visitor = TypeVisitor::new(&self.item.generics);
 
         visitor.visit_type(ty);
 
diff --git a/macros/src/lib.rs b/macros/src/lib.rs
index b73e1e9..7038824 100644
--- a/macros/src/lib.rs
+++ b/macros/src/lib.rs
@@ -1,5 +1,5 @@
 use proc_macro::TokenStream;
-use syn::{parse_macro_input, DeriveInput};
+use syn::parse_macro_input;
 
 use crate::utils::tokenstream;
 
@@ -8,10 +8,7 @@ mod enum_deriver;
 mod type_visitor;
 mod utils;
 
-use config::*;
-use enum_deriver::*;
-use type_visitor::*;
-use utils::*;
+use self::{config::*, enum_deriver::*, type_visitor::*, utils::*};
 
 /// Derive macro generating an impl of the trait `From<T>`.
 ///
@@ -40,10 +37,10 @@ use utils::*;
 ///
 #[proc_macro_derive(From, attributes(enumcapsulate))]
 pub fn derive_from(input: TokenStream) -> TokenStream {
-    let input: DeriveInput = parse_macro_input!(input);
+    let item = parse_macro_input!(input as syn::ItemEnum);
 
     tokenstream(|| {
-        let deriver = EnumDeriver::from(input);
+        let deriver = EnumDeriver::from(item);
         deriver.derive_from()
     })
 }
@@ -84,10 +81,10 @@ pub fn derive_from(input: TokenStream) -> TokenStream {
 /// more appropriate as the derive's name.
 #[proc_macro_derive(TryInto, attributes(enumcapsulate))]
 pub fn derive_try_from(input: TokenStream) -> TokenStream {
-    let input: DeriveInput = parse_macro_input!(input);
+    let item = parse_macro_input!(input as syn::ItemEnum);
 
     tokenstream(|| {
-        let deriver = EnumDeriver::from(input);
+        let deriver = EnumDeriver::from(item);
         deriver.derive_try_into()
     })
 }
@@ -121,10 +118,10 @@ pub fn derive_try_from(input: TokenStream) -> TokenStream {
 ///
 #[proc_macro_derive(FromVariant, attributes(enumcapsulate))]
 pub fn derive_from_variant(input: TokenStream) -> TokenStream {
-    let input: DeriveInput = parse_macro_input!(input);
+    let item = parse_macro_input!(input as syn::ItemEnum);
 
     tokenstream(|| {
-        let deriver = EnumDeriver::from(input);
+        let deriver = EnumDeriver::from(item);
         deriver.derive_from_variant()
     })
 }
@@ -162,10 +159,10 @@ pub fn derive_from_variant(input: TokenStream) -> TokenStream {
 ///
 #[proc_macro_derive(AsVariant, attributes(enumcapsulate))]
 pub fn derive_as_variant(input: TokenStream) -> TokenStream {
-    let input: DeriveInput = parse_macro_input!(input);
+    let item = parse_macro_input!(input as syn::ItemEnum);
 
     tokenstream(|| {
-        let deriver = EnumDeriver::from(input);
+        let deriver = EnumDeriver::from(item);
         deriver.derive_as_variant()
     })
 }
@@ -202,10 +199,10 @@ pub fn derive_as_variant(input: TokenStream) -> TokenStream {
 ///
 #[proc_macro_derive(AsVariantRef, attributes(enumcapsulate))]
 pub fn derive_as_variant_ref(input: TokenStream) -> TokenStream {
-    let input: DeriveInput = parse_macro_input!(input);
+    let item = parse_macro_input!(input as syn::ItemEnum);
 
     tokenstream(|| {
-        let deriver = EnumDeriver::from(input);
+        let deriver = EnumDeriver::from(item);
         deriver.derive_as_variant_ref()
     })
 }
@@ -242,10 +239,10 @@ pub fn derive_as_variant_ref(input: TokenStream) -> TokenStream {
 ///
 #[proc_macro_derive(AsVariantMut, attributes(enumcapsulate))]
 pub fn derive_as_variant_mut(input: TokenStream) -> TokenStream {
-    let input: DeriveInput = parse_macro_input!(input);
+    let item = parse_macro_input!(input as syn::ItemEnum);
 
     tokenstream(|| {
-        let deriver = EnumDeriver::from(input);
+        let deriver = EnumDeriver::from(item);
         deriver.derive_as_variant_mut()
     })
 }
@@ -286,10 +283,10 @@ pub fn derive_as_variant_mut(input: TokenStream) -> TokenStream {
 /// more appropriate as the derive's name.
 #[proc_macro_derive(IntoVariant, attributes(enumcapsulate))]
 pub fn derive_into_variant(input: TokenStream) -> TokenStream {
-    let input: DeriveInput = parse_macro_input!(input);
+    let item = parse_macro_input!(input as syn::ItemEnum);
 
     tokenstream(|| {
-        let deriver = EnumDeriver::from(input);
+        let deriver = EnumDeriver::from(item);
         deriver.derive_into_variant()
     })
 }
@@ -311,10 +308,10 @@ pub fn derive_into_variant(input: TokenStream) -> TokenStream {
 ///
 #[proc_macro_derive(VariantDowncast, attributes(enumcapsulate))]
 pub fn derive_variant_downcast(input: TokenStream) -> TokenStream {
-    let input: DeriveInput = parse_macro_input!(input);
+    let item = parse_macro_input!(input as syn::ItemEnum);
 
     tokenstream(|| {
-        let deriver = EnumDeriver::from(input);
+        let deriver = EnumDeriver::from(item);
         deriver.derive_variant_downcast()
     })
 }
@@ -353,10 +350,10 @@ pub fn derive_variant_downcast(input: TokenStream) -> TokenStream {
 ///
 #[proc_macro_derive(VariantDiscriminant)]
 pub fn derive_variant_discriminant(input: TokenStream) -> TokenStream {
-    let input: DeriveInput = parse_macro_input!(input);
+    let item = parse_macro_input!(input as syn::ItemEnum);
 
     tokenstream(|| {
-        let deriver = EnumDeriver::from(input);
+        let deriver = EnumDeriver::from(item);
         deriver.derive_variant_discriminant()
     })
 }
@@ -386,10 +383,10 @@ pub fn derive_variant_discriminant(input: TokenStream) -> TokenStream {
 /// ```
 #[proc_macro_derive(Encapsulate, attributes(enumcapsulate))]
 pub fn derive_encapsulate(input: TokenStream) -> TokenStream {
-    let input: DeriveInput = parse_macro_input!(input);
+    let item = parse_macro_input!(input as syn::ItemEnum);
 
     tokenstream(|| {
-        let deriver = EnumDeriver::from(input);
+        let deriver = EnumDeriver::from(item);
 
         let from = deriver.derive_from()?;
         let try_into = deriver.derive_try_into()?;
diff --git a/macros/src/utils.rs b/macros/src/utils.rs
index 6bb004a..f1615a0 100644
--- a/macros/src/utils.rs
+++ b/macros/src/utils.rs
@@ -4,12 +4,12 @@ use proc_macro2::TokenStream as TokenStream2;
 use crate::config::VariantFieldConfig;
 
 pub(crate) mod attr {
-    pub(crate) const NAMESPACE: &str = "enumcapsulate";
     pub(crate) const EXCLUDE: &str = "exclude";
-    pub(crate) const INCLUDE: &str = "include";
     pub(crate) const FIELD: &str = "field";
-    pub(crate) const NAME: &str = "name";
+    pub(crate) const INCLUDE: &str = "include";
     pub(crate) const INDEX: &str = "index";
+    pub(crate) const NAME: &str = "name";
+    pub(crate) const NAMESPACE: &str = "enumcapsulate";
 }
 
 pub(crate) mod macro_name {
diff --git a/tests/derive-tests/as_variant/fail/struct.err.txt b/tests/derive-tests/as_variant/fail/struct.err.txt
index 197a801..44ea2b2 100644
--- a/tests/derive-tests/as_variant/fail/struct.err.txt
+++ b/tests/derive-tests/as_variant/fail/struct.err.txt
@@ -1,5 +1,5 @@
-error: Only enums can use this derive
- --> /tests/derive-tests/as_variant/fail/struct.rs:4:12
+error: expected `enum`
+ --> /tests/derive-tests/as_variant/fail/struct.rs:4:5
   |
 4 | pub struct Struct {
-  |            ^^^^^^
+  |     ^^^^^^
diff --git a/tests/derive-tests/as_variant/fail/union.err.txt b/tests/derive-tests/as_variant/fail/union.err.txt
index e4c86f3..57311c8 100644
--- a/tests/derive-tests/as_variant/fail/union.err.txt
+++ b/tests/derive-tests/as_variant/fail/union.err.txt
@@ -1,5 +1,5 @@
-error: Only enums can use this derive
- --> /tests/derive-tests/as_variant/fail/union.rs:4:11
+error: expected `enum`
+ --> /tests/derive-tests/as_variant/fail/union.rs:4:5
   |
 4 | pub union Union {
-  |           ^^^^^
+  |     ^^^^^
diff --git a/tests/derive-tests/as_variant_mut/fail/struct.err.txt b/tests/derive-tests/as_variant_mut/fail/struct.err.txt
index 0cf1d1e..5a2b5c8 100644
--- a/tests/derive-tests/as_variant_mut/fail/struct.err.txt
+++ b/tests/derive-tests/as_variant_mut/fail/struct.err.txt
@@ -1,5 +1,5 @@
-error: Only enums can use this derive
- --> /tests/derive-tests/as_variant_mut/fail/struct.rs:4:12
+error: expected `enum`
+ --> /tests/derive-tests/as_variant_mut/fail/struct.rs:4:5
   |
 4 | pub struct Struct {
-  |            ^^^^^^
+  |     ^^^^^^
diff --git a/tests/derive-tests/as_variant_mut/fail/union.err.txt b/tests/derive-tests/as_variant_mut/fail/union.err.txt
index 9defa7f..73ea3f1 100644
--- a/tests/derive-tests/as_variant_mut/fail/union.err.txt
+++ b/tests/derive-tests/as_variant_mut/fail/union.err.txt
@@ -1,5 +1,5 @@
-error: Only enums can use this derive
- --> /tests/derive-tests/as_variant_mut/fail/union.rs:4:11
+error: expected `enum`
+ --> /tests/derive-tests/as_variant_mut/fail/union.rs:4:5
   |
 4 | pub union Union {
-  |           ^^^^^
+  |     ^^^^^
diff --git a/tests/derive-tests/as_variant_ref/fail/struct.err.txt b/tests/derive-tests/as_variant_ref/fail/struct.err.txt
index 8d05626..19ab420 100644
--- a/tests/derive-tests/as_variant_ref/fail/struct.err.txt
+++ b/tests/derive-tests/as_variant_ref/fail/struct.err.txt
@@ -1,5 +1,5 @@
-error: Only enums can use this derive
- --> /tests/derive-tests/as_variant_ref/fail/struct.rs:4:12
+error: expected `enum`
+ --> /tests/derive-tests/as_variant_ref/fail/struct.rs:4:5
   |
 4 | pub struct Struct {
-  |            ^^^^^^
+  |     ^^^^^^
diff --git a/tests/derive-tests/as_variant_ref/fail/union.err.txt b/tests/derive-tests/as_variant_ref/fail/union.err.txt
index b87981b..e3e97f6 100644
--- a/tests/derive-tests/as_variant_ref/fail/union.err.txt
+++ b/tests/derive-tests/as_variant_ref/fail/union.err.txt
@@ -1,5 +1,5 @@
-error: Only enums can use this derive
- --> /tests/derive-tests/as_variant_ref/fail/union.rs:4:11
+error: expected `enum`
+ --> /tests/derive-tests/as_variant_ref/fail/union.rs:4:5
   |
 4 | pub union Union {
-  |           ^^^^^
+  |     ^^^^^
diff --git a/tests/derive-tests/from/fail/struct.err.txt b/tests/derive-tests/from/fail/struct.err.txt
index 8c897e8..950a874 100644
--- a/tests/derive-tests/from/fail/struct.err.txt
+++ b/tests/derive-tests/from/fail/struct.err.txt
@@ -1,5 +1,5 @@
-error: Only enums can use this derive
- --> /tests/derive-tests/from/fail/struct.rs:4:12
+error: expected `enum`
+ --> /tests/derive-tests/from/fail/struct.rs:4:5
   |
 4 | pub struct Struct {
-  |            ^^^^^^
+  |     ^^^^^^
diff --git a/tests/derive-tests/from/fail/union.err.txt b/tests/derive-tests/from/fail/union.err.txt
index c085a73..065513b 100644
--- a/tests/derive-tests/from/fail/union.err.txt
+++ b/tests/derive-tests/from/fail/union.err.txt
@@ -1,5 +1,5 @@
-error: Only enums can use this derive
- --> /tests/derive-tests/from/fail/union.rs:4:11
+error: expected `enum`
+ --> /tests/derive-tests/from/fail/union.rs:4:5
   |
 4 | pub union Union {
-  |           ^^^^^
+  |     ^^^^^
diff --git a/tests/derive-tests/from_variant/fail/struct.err.txt b/tests/derive-tests/from_variant/fail/struct.err.txt
index 4e97055..5140020 100644
--- a/tests/derive-tests/from_variant/fail/struct.err.txt
+++ b/tests/derive-tests/from_variant/fail/struct.err.txt
@@ -1,5 +1,5 @@
-error: Only enums can use this derive
- --> /tests/derive-tests/from_variant/fail/struct.rs:4:12
+error: expected `enum`
+ --> /tests/derive-tests/from_variant/fail/struct.rs:4:5
   |
 4 | pub struct Struct {
-  |            ^^^^^^
+  |     ^^^^^^
diff --git a/tests/derive-tests/from_variant/fail/union.err.txt b/tests/derive-tests/from_variant/fail/union.err.txt
index edd8e93..da8fb41 100644
--- a/tests/derive-tests/from_variant/fail/union.err.txt
+++ b/tests/derive-tests/from_variant/fail/union.err.txt
@@ -1,5 +1,5 @@
-error: Only enums can use this derive
- --> /tests/derive-tests/from_variant/fail/union.rs:4:11
+error: expected `enum`
+ --> /tests/derive-tests/from_variant/fail/union.rs:4:5
   |
 4 | pub union Union {
-  |           ^^^^^
+  |     ^^^^^
diff --git a/tests/derive-tests/into_variant/fail/struct.err.txt b/tests/derive-tests/into_variant/fail/struct.err.txt
index 9f02d94..03d0846 100644
--- a/tests/derive-tests/into_variant/fail/struct.err.txt
+++ b/tests/derive-tests/into_variant/fail/struct.err.txt
@@ -1,5 +1,5 @@
-error: Only enums can use this derive
- --> /tests/derive-tests/into_variant/fail/struct.rs:4:12
+error: expected `enum`
+ --> /tests/derive-tests/into_variant/fail/struct.rs:4:5
   |
 4 | pub struct Struct {
-  |            ^^^^^^
+  |     ^^^^^^
diff --git a/tests/derive-tests/into_variant/fail/union.err.txt b/tests/derive-tests/into_variant/fail/union.err.txt
index f22df49..01b9baf 100644
--- a/tests/derive-tests/into_variant/fail/union.err.txt
+++ b/tests/derive-tests/into_variant/fail/union.err.txt
@@ -1,5 +1,5 @@
-error: Only enums can use this derive
- --> /tests/derive-tests/into_variant/fail/union.rs:4:11
+error: expected `enum`
+ --> /tests/derive-tests/into_variant/fail/union.rs:4:5
   |
 4 | pub union Union {
-  |           ^^^^^
+  |     ^^^^^
diff --git a/tests/derive-tests/try_into/fail/struct.err.txt b/tests/derive-tests/try_into/fail/struct.err.txt
index 3ed490c..d572746 100644
--- a/tests/derive-tests/try_into/fail/struct.err.txt
+++ b/tests/derive-tests/try_into/fail/struct.err.txt
@@ -1,5 +1,5 @@
-error: Only enums can use this derive
- --> /tests/derive-tests/try_into/fail/struct.rs:4:12
+error: expected `enum`
+ --> /tests/derive-tests/try_into/fail/struct.rs:4:5
   |
 4 | pub struct Struct {
-  |            ^^^^^^
+  |     ^^^^^^
diff --git a/tests/derive-tests/try_into/fail/union.err.txt b/tests/derive-tests/try_into/fail/union.err.txt
index d2848d6..c70cfcb 100644
--- a/tests/derive-tests/try_into/fail/union.err.txt
+++ b/tests/derive-tests/try_into/fail/union.err.txt
@@ -1,5 +1,5 @@
-error: Only enums can use this derive
- --> /tests/derive-tests/try_into/fail/union.rs:4:11
+error: expected `enum`
+ --> /tests/derive-tests/try_into/fail/union.rs:4:5
   |
 4 | pub union Union {
-  |           ^^^^^
+  |     ^^^^^
diff --git a/tests/derive-tests/variant_downcast/fail/struct.err.txt b/tests/derive-tests/variant_downcast/fail/struct.err.txt
index 20c4c97..d2b658a 100644
--- a/tests/derive-tests/variant_downcast/fail/struct.err.txt
+++ b/tests/derive-tests/variant_downcast/fail/struct.err.txt
@@ -1,5 +1,5 @@
-error: Only enums can use this derive
- --> /tests/derive-tests/variant_downcast/fail/struct.rs:4:12
+error: expected `enum`
+ --> /tests/derive-tests/variant_downcast/fail/struct.rs:4:5
   |
 4 | pub struct Struct {
-  |            ^^^^^^
+  |     ^^^^^^
diff --git a/tests/derive-tests/variant_downcast/fail/union.err.txt b/tests/derive-tests/variant_downcast/fail/union.err.txt
index 836fd47..f6eb276 100644
--- a/tests/derive-tests/variant_downcast/fail/union.err.txt
+++ b/tests/derive-tests/variant_downcast/fail/union.err.txt
@@ -1,5 +1,5 @@
-error: Only enums can use this derive
- --> /tests/derive-tests/variant_downcast/fail/union.rs:4:11
+error: expected `enum`
+ --> /tests/derive-tests/variant_downcast/fail/union.rs:4:5
   |
 4 | pub union Union {
-  |           ^^^^^
+  |     ^^^^^

From e5e750643bf13d85844ff259bca929c382125de7 Mon Sep 17 00:00:00 2001
From: Vincent Esche <regexident@gmail.com>
Date: Fri, 29 Nov 2024 16:31:03 +0100
Subject: [PATCH 3/5] Refactor `Encapsulate` derive macro

---
 macros/src/config.rs       |  4 ++++
 macros/src/enum_deriver.rs | 44 ++++++++++++++++++++++++++++++++++++++
 macros/src/lib.rs          | 23 +-------------------
 3 files changed, 49 insertions(+), 22 deletions(-)

diff --git a/macros/src/config.rs b/macros/src/config.rs
index e0e88bd..e6702e5 100644
--- a/macros/src/config.rs
+++ b/macros/src/config.rs
@@ -64,6 +64,10 @@ pub(crate) struct EnumConfig {
 }
 
 impl EnumConfig {
+    pub fn is_included(&self, name: &str) -> bool {
+        !self.is_excluded(name)
+    }
+
     pub fn is_excluded(&self, name: &str) -> bool {
         self.exclude
             .as_ref()
diff --git a/macros/src/enum_deriver.rs b/macros/src/enum_deriver.rs
index 52014a1..9b37edb 100644
--- a/macros/src/enum_deriver.rs
+++ b/macros/src/enum_deriver.rs
@@ -635,6 +635,50 @@ impl EnumDeriver {
         })
     }
 
+    pub fn derive_encapsulate(&self) -> Result<TokenStream2, syn::Error> {
+        let enum_config = config_for_enum(&self.item)?;
+
+        let from = enum_config
+            .is_included(macro_name::FROM)
+            .then_some(self.derive_from()?);
+        let try_into = enum_config
+            .is_included(macro_name::TRY_INTO)
+            .then_some(self.derive_try_into()?);
+        let from_variant = enum_config
+            .is_included(macro_name::FROM_VARIANT)
+            .then_some(self.derive_from_variant()?);
+        let as_variant = enum_config
+            .is_included(macro_name::AS_VARIANT)
+            .then_some(self.derive_as_variant()?);
+        let as_variant_ref = enum_config
+            .is_included(macro_name::AS_VARIANT_REF)
+            .then_some(self.derive_as_variant_ref()?);
+        let as_variant_mut = enum_config
+            .is_included(macro_name::AS_VARIANT_MUT)
+            .then_some(self.derive_as_variant_mut()?);
+        let into_variant = enum_config
+            .is_included(macro_name::INTO_VARIANT)
+            .then_some(self.derive_into_variant()?);
+        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
+            #try_into
+            #from_variant
+            #as_variant
+            #as_variant_ref
+            #as_variant_mut
+            #into_variant
+            #variant_downcast
+            #variant_discriminant
+        })
+    }
+
     fn uses_generic_const_or_type(&self, ty: &syn::Type) -> bool {
         let mut visitor = TypeVisitor::new(&self.item.generics);
 
diff --git a/macros/src/lib.rs b/macros/src/lib.rs
index 7038824..0595a7c 100644
--- a/macros/src/lib.rs
+++ b/macros/src/lib.rs
@@ -387,27 +387,6 @@ pub fn derive_encapsulate(input: TokenStream) -> TokenStream {
 
     tokenstream(|| {
         let deriver = EnumDeriver::from(item);
-
-        let from = deriver.derive_from()?;
-        let try_into = deriver.derive_try_into()?;
-        let from_variant = deriver.derive_from_variant()?;
-        let as_variant = deriver.derive_as_variant()?;
-        let as_variant_ref = deriver.derive_as_variant_ref()?;
-        let as_variant_mut = deriver.derive_as_variant_mut()?;
-        let into_variant = deriver.derive_into_variant()?;
-        let variant_downcast = deriver.derive_variant_downcast()?;
-        let variant_discriminant = deriver.derive_variant_discriminant()?;
-
-        Ok(quote::quote! {
-            #from
-            #try_into
-            #from_variant
-            #as_variant
-            #as_variant_ref
-            #as_variant_mut
-            #into_variant
-            #variant_downcast
-            #variant_discriminant
-        })
+        deriver.derive_encapsulate()
     })
 }

From e9cb0e3c4b3f0154c237a30b8a53b627606de356 Mon Sep 17 00:00:00 2001
From: Vincent Esche <regexident@gmail.com>
Date: Sat, 30 Nov 2024 00:00:03 +0100
Subject: [PATCH 4/5] Bump MSRV from "1.74.0" to "1.78.0"

---
 .github/workflows/rust.yml | 2 +-
 CHANGELOG.md               | 2 +-
 Cargo.toml                 | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
index 1206b75..e60cfa7 100644
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -40,7 +40,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@v1
         with:
-          toolchain: 1.74.0
+          toolchain: 1.78.0
           components: rust-src
       - run: cargo install cargo-expand
       - run: cargo test -- --test-threads=1
diff --git a/CHANGELOG.md b/CHANGELOG.md
index ea0e7d6..6423da2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -24,7 +24,7 @@ Please make sure to add your changes to the appropriate categories:
 
 ### Changed
 
-- n/a
+- Bumped MSRV from "1.74.0" to "1.78.0".
 
 ### Deprecated
 
diff --git a/Cargo.toml b/Cargo.toml
index 5a00fdc..69e7b7e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -8,7 +8,7 @@ homepage = "https://github.com/regexident/enumcapsulate"
 documentation = "https://docs.rs/enumcapsulate"
 license = "MPL-2.0"
 edition = "2021"
-rust-version = "1.74.0"
+rust-version = "1.78.0"
 version = "0.4.0"
 
 [package]

From 355115d6c5e306d97cd6d412b0c6b2f98a7aa093 Mon Sep 17 00:00:00 2001
From: Vincent Esche <regexident@gmail.com>
Date: Sat, 30 Nov 2024 00:22:23 +0100
Subject: [PATCH 5/5] Update test snapshots

---
 tests/derive-tests/as_variant/fail/struct.err.txt              | 1 +
 tests/derive-tests/as_variant/fail/union.err.txt               | 1 +
 tests/derive-tests/as_variant_mut/fail/struct.err.txt          | 1 +
 tests/derive-tests/as_variant_mut/fail/union.err.txt           | 1 +
 tests/derive-tests/as_variant_ref/fail/struct.err.txt          | 1 +
 tests/derive-tests/as_variant_ref/fail/union.err.txt           | 1 +
 .../encapsulate/pass/enum/tuple_variants/one_field.out.rs      | 3 +--
 tests/derive-tests/encapsulate/pass/enum/zero_variants.out.rs  | 3 +--
 tests/derive-tests/from/fail/struct.err.txt                    | 1 +
 tests/derive-tests/from/fail/union.err.txt                     | 1 +
 tests/derive-tests/from_variant/fail/struct.err.txt            | 1 +
 tests/derive-tests/from_variant/fail/union.err.txt             | 1 +
 tests/derive-tests/into_variant/fail/struct.err.txt            | 1 +
 tests/derive-tests/into_variant/fail/union.err.txt             | 1 +
 tests/derive-tests/try_into/fail/struct.err.txt                | 1 +
 tests/derive-tests/try_into/fail/union.err.txt                 | 1 +
 .../variant_discriminant/pass/enum/mixed_variants.out.rs       | 3 +--
 .../variant_discriminant/pass/enum/zero_variants.out.rs        | 3 +--
 tests/derive-tests/variant_downcast/fail/struct.err.txt        | 1 +
 tests/derive-tests/variant_downcast/fail/union.err.txt         | 1 +
 20 files changed, 20 insertions(+), 8 deletions(-)

diff --git a/tests/derive-tests/as_variant/fail/struct.err.txt b/tests/derive-tests/as_variant/fail/struct.err.txt
index 44ea2b2..f5bb83b 100644
--- a/tests/derive-tests/as_variant/fail/struct.err.txt
+++ b/tests/derive-tests/as_variant/fail/struct.err.txt
@@ -3,3 +3,4 @@ error: expected `enum`
   |
 4 | pub struct Struct {
   |     ^^^^^^
+error: could not compile `<CRATE>` (bin "<BIN>") due to 1 previous error
diff --git a/tests/derive-tests/as_variant/fail/union.err.txt b/tests/derive-tests/as_variant/fail/union.err.txt
index 57311c8..0a45a64 100644
--- a/tests/derive-tests/as_variant/fail/union.err.txt
+++ b/tests/derive-tests/as_variant/fail/union.err.txt
@@ -3,3 +3,4 @@ error: expected `enum`
   |
 4 | pub union Union {
   |     ^^^^^
+error: could not compile `<CRATE>` (bin "<BIN>") due to 1 previous error
diff --git a/tests/derive-tests/as_variant_mut/fail/struct.err.txt b/tests/derive-tests/as_variant_mut/fail/struct.err.txt
index 5a2b5c8..37c0e2d 100644
--- a/tests/derive-tests/as_variant_mut/fail/struct.err.txt
+++ b/tests/derive-tests/as_variant_mut/fail/struct.err.txt
@@ -3,3 +3,4 @@ error: expected `enum`
   |
 4 | pub struct Struct {
   |     ^^^^^^
+error: could not compile `<CRATE>` (bin "<BIN>") due to 1 previous error
diff --git a/tests/derive-tests/as_variant_mut/fail/union.err.txt b/tests/derive-tests/as_variant_mut/fail/union.err.txt
index 73ea3f1..f39bf2e 100644
--- a/tests/derive-tests/as_variant_mut/fail/union.err.txt
+++ b/tests/derive-tests/as_variant_mut/fail/union.err.txt
@@ -3,3 +3,4 @@ error: expected `enum`
   |
 4 | pub union Union {
   |     ^^^^^
+error: could not compile `<CRATE>` (bin "<BIN>") due to 1 previous error
diff --git a/tests/derive-tests/as_variant_ref/fail/struct.err.txt b/tests/derive-tests/as_variant_ref/fail/struct.err.txt
index 19ab420..d8545b6 100644
--- a/tests/derive-tests/as_variant_ref/fail/struct.err.txt
+++ b/tests/derive-tests/as_variant_ref/fail/struct.err.txt
@@ -3,3 +3,4 @@ error: expected `enum`
   |
 4 | pub struct Struct {
   |     ^^^^^^
+error: could not compile `<CRATE>` (bin "<BIN>") due to 1 previous error
diff --git a/tests/derive-tests/as_variant_ref/fail/union.err.txt b/tests/derive-tests/as_variant_ref/fail/union.err.txt
index e3e97f6..b7980c9 100644
--- a/tests/derive-tests/as_variant_ref/fail/union.err.txt
+++ b/tests/derive-tests/as_variant_ref/fail/union.err.txt
@@ -3,3 +3,4 @@ error: expected `enum`
   |
 4 | pub union Union {
   |     ^^^^^
+error: could not compile `<CRATE>` (bin "<BIN>") due to 1 previous error
diff --git a/tests/derive-tests/encapsulate/pass/enum/tuple_variants/one_field.out.rs b/tests/derive-tests/encapsulate/pass/enum/tuple_variants/one_field.out.rs
index edaf7c0..62e5630 100644
--- a/tests/derive-tests/encapsulate/pass/enum/tuple_variants/one_field.out.rs
+++ b/tests/derive-tests/encapsulate/pass/enum/tuple_variants/one_field.out.rs
@@ -144,8 +144,6 @@ impl ::core::clone::Clone for EnumDiscriminant {
     }
 }
 #[automatically_derived]
-impl ::core::marker::StructuralEq for EnumDiscriminant {}
-#[automatically_derived]
 impl ::core::cmp::Eq for EnumDiscriminant {
     #[inline]
     #[doc(hidden)]
@@ -173,6 +171,7 @@ impl ::core::hash::Hash for EnumDiscriminant {
 }
 #[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,
diff --git a/tests/derive-tests/encapsulate/pass/enum/zero_variants.out.rs b/tests/derive-tests/encapsulate/pass/enum/zero_variants.out.rs
index ee54429..930c386 100644
--- a/tests/derive-tests/encapsulate/pass/enum/zero_variants.out.rs
+++ b/tests/derive-tests/encapsulate/pass/enum/zero_variants.out.rs
@@ -14,8 +14,6 @@ impl ::core::clone::Clone for EnumDiscriminant {
     }
 }
 #[automatically_derived]
-impl ::core::marker::StructuralEq for EnumDiscriminant {}
-#[automatically_derived]
 impl ::core::cmp::Eq for EnumDiscriminant {
     #[inline]
     #[doc(hidden)]
@@ -40,6 +38,7 @@ impl ::core::hash::Hash for EnumDiscriminant {
 }
 #[automatically_derived]
 impl ::core::fmt::Debug for EnumDiscriminant {
+    #[inline]
     fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
         match *self {}
     }
diff --git a/tests/derive-tests/from/fail/struct.err.txt b/tests/derive-tests/from/fail/struct.err.txt
index 950a874..3118d4f 100644
--- a/tests/derive-tests/from/fail/struct.err.txt
+++ b/tests/derive-tests/from/fail/struct.err.txt
@@ -3,3 +3,4 @@ error: expected `enum`
   |
 4 | pub struct Struct {
   |     ^^^^^^
+error: could not compile `<CRATE>` (bin "<BIN>") due to 1 previous error
diff --git a/tests/derive-tests/from/fail/union.err.txt b/tests/derive-tests/from/fail/union.err.txt
index 065513b..f71bd7a 100644
--- a/tests/derive-tests/from/fail/union.err.txt
+++ b/tests/derive-tests/from/fail/union.err.txt
@@ -3,3 +3,4 @@ error: expected `enum`
   |
 4 | pub union Union {
   |     ^^^^^
+error: could not compile `<CRATE>` (bin "<BIN>") due to 1 previous error
diff --git a/tests/derive-tests/from_variant/fail/struct.err.txt b/tests/derive-tests/from_variant/fail/struct.err.txt
index 5140020..f1b2821 100644
--- a/tests/derive-tests/from_variant/fail/struct.err.txt
+++ b/tests/derive-tests/from_variant/fail/struct.err.txt
@@ -3,3 +3,4 @@ error: expected `enum`
   |
 4 | pub struct Struct {
   |     ^^^^^^
+error: could not compile `<CRATE>` (bin "<BIN>") due to 1 previous error
diff --git a/tests/derive-tests/from_variant/fail/union.err.txt b/tests/derive-tests/from_variant/fail/union.err.txt
index da8fb41..fe32851 100644
--- a/tests/derive-tests/from_variant/fail/union.err.txt
+++ b/tests/derive-tests/from_variant/fail/union.err.txt
@@ -3,3 +3,4 @@ error: expected `enum`
   |
 4 | pub union Union {
   |     ^^^^^
+error: could not compile `<CRATE>` (bin "<BIN>") due to 1 previous error
diff --git a/tests/derive-tests/into_variant/fail/struct.err.txt b/tests/derive-tests/into_variant/fail/struct.err.txt
index 03d0846..46cfafd 100644
--- a/tests/derive-tests/into_variant/fail/struct.err.txt
+++ b/tests/derive-tests/into_variant/fail/struct.err.txt
@@ -3,3 +3,4 @@ error: expected `enum`
   |
 4 | pub struct Struct {
   |     ^^^^^^
+error: could not compile `<CRATE>` (bin "<BIN>") due to 1 previous error
diff --git a/tests/derive-tests/into_variant/fail/union.err.txt b/tests/derive-tests/into_variant/fail/union.err.txt
index 01b9baf..6c31313 100644
--- a/tests/derive-tests/into_variant/fail/union.err.txt
+++ b/tests/derive-tests/into_variant/fail/union.err.txt
@@ -3,3 +3,4 @@ error: expected `enum`
   |
 4 | pub union Union {
   |     ^^^^^
+error: could not compile `<CRATE>` (bin "<BIN>") due to 1 previous error
diff --git a/tests/derive-tests/try_into/fail/struct.err.txt b/tests/derive-tests/try_into/fail/struct.err.txt
index d572746..2c49c81 100644
--- a/tests/derive-tests/try_into/fail/struct.err.txt
+++ b/tests/derive-tests/try_into/fail/struct.err.txt
@@ -3,3 +3,4 @@ error: expected `enum`
   |
 4 | pub struct Struct {
   |     ^^^^^^
+error: could not compile `<CRATE>` (bin "<BIN>") due to 1 previous error
diff --git a/tests/derive-tests/try_into/fail/union.err.txt b/tests/derive-tests/try_into/fail/union.err.txt
index c70cfcb..f162baa 100644
--- a/tests/derive-tests/try_into/fail/union.err.txt
+++ b/tests/derive-tests/try_into/fail/union.err.txt
@@ -3,3 +3,4 @@ error: expected `enum`
   |
 4 | pub union Union {
   |     ^^^^^
+error: could not compile `<CRATE>` (bin "<BIN>") due to 1 previous error
diff --git a/tests/derive-tests/variant_discriminant/pass/enum/mixed_variants.out.rs b/tests/derive-tests/variant_discriminant/pass/enum/mixed_variants.out.rs
index 6fd5703..8387730 100644
--- a/tests/derive-tests/variant_discriminant/pass/enum/mixed_variants.out.rs
+++ b/tests/derive-tests/variant_discriminant/pass/enum/mixed_variants.out.rs
@@ -31,8 +31,6 @@ impl ::core::clone::Clone for EnumDiscriminant {
     }
 }
 #[automatically_derived]
-impl ::core::marker::StructuralEq for EnumDiscriminant {}
-#[automatically_derived]
 impl ::core::cmp::Eq for EnumDiscriminant {
     #[inline]
     #[doc(hidden)]
@@ -60,6 +58,7 @@ impl ::core::hash::Hash for EnumDiscriminant {
 }
 #[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,
diff --git a/tests/derive-tests/variant_discriminant/pass/enum/zero_variants.out.rs b/tests/derive-tests/variant_discriminant/pass/enum/zero_variants.out.rs
index 532ce55..e22db76 100644
--- a/tests/derive-tests/variant_discriminant/pass/enum/zero_variants.out.rs
+++ b/tests/derive-tests/variant_discriminant/pass/enum/zero_variants.out.rs
@@ -11,8 +11,6 @@ impl ::core::clone::Clone for EnumDiscriminant {
     }
 }
 #[automatically_derived]
-impl ::core::marker::StructuralEq for EnumDiscriminant {}
-#[automatically_derived]
 impl ::core::cmp::Eq for EnumDiscriminant {
     #[inline]
     #[doc(hidden)]
@@ -37,6 +35,7 @@ impl ::core::hash::Hash for EnumDiscriminant {
 }
 #[automatically_derived]
 impl ::core::fmt::Debug for EnumDiscriminant {
+    #[inline]
     fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
         match *self {}
     }
diff --git a/tests/derive-tests/variant_downcast/fail/struct.err.txt b/tests/derive-tests/variant_downcast/fail/struct.err.txt
index d2b658a..62cde3c 100644
--- a/tests/derive-tests/variant_downcast/fail/struct.err.txt
+++ b/tests/derive-tests/variant_downcast/fail/struct.err.txt
@@ -3,3 +3,4 @@ error: expected `enum`
   |
 4 | pub struct Struct {
   |     ^^^^^^
+error: could not compile `<CRATE>` (bin "<BIN>") due to 1 previous error
diff --git a/tests/derive-tests/variant_downcast/fail/union.err.txt b/tests/derive-tests/variant_downcast/fail/union.err.txt
index f6eb276..91af1e6 100644
--- a/tests/derive-tests/variant_downcast/fail/union.err.txt
+++ b/tests/derive-tests/variant_downcast/fail/union.err.txt
@@ -3,3 +3,4 @@ error: expected `enum`
   |
 4 | pub union Union {
   |     ^^^^^
+error: could not compile `<CRATE>` (bin "<BIN>") due to 1 previous error