Fix parsing of derive configs

macros/src/config/for_enum.rs

@@ -1,18 +1,6 @@
+mod config;
 mod discriminant;
-mod encapsulate;
-mod standard;
-mod variant_discriminant;
 
-pub(crate) use self::encapsulate::EncapsulateDeriveEnumConfig;
-pub(crate) use self::variant_discriminant::VariantDiscriminantDeriveEnumConfig;
+pub(crate) use self::config::EnumConfig;
 
-use self::{discriminant::DiscriminantConfig, standard::EnumConfig};
-
-pub(crate) type FromDeriveEnumConfig = EnumConfig;
-pub(crate) type TryIntoDeriveEnumConfig = EnumConfig;
-pub(crate) type FromVariantDeriveEnumConfig = EnumConfig;
-pub(crate) type IntoVariantDeriveEnumConfig = EnumConfig;
-pub(crate) type AsVariantDeriveEnumConfig = EnumConfig;
-pub(crate) type AsVariantMutDeriveEnumConfig = EnumConfig;
-pub(crate) type AsVariantRefDeriveEnumConfig = EnumConfig;
-pub(crate) type VariantDowncastDeriveEnumConfig = EnumConfig;
+use self::discriminant::DiscriminantConfig;

macros/src/config/for_enum/encapsulate.rs → macros/src/config/for_enum/config.rs

@@ -1,11 +1,18 @@
-use crate::{attr::EXCLUDE, config::ExcludeConfig, parse_enumcapsulate_attrs};
+use crate::{
+    attr::{DISCRIMINANT, EXCLUDE},
+    config::ExcludeConfig,
+    parse_enumcapsulate_attrs,
+};
+
+use super::DiscriminantConfig;
 
 #[derive(Clone, Default)]
-pub(crate) struct EncapsulateDeriveEnumConfig {
+pub(crate) struct EnumConfig {
     exclude: Option<ExcludeConfig>,
+    discriminant: Option<DiscriminantConfig>,
 }
 
-impl EncapsulateDeriveEnumConfig {
+impl EnumConfig {
     pub fn is_included(&self, name: &str) -> bool {
         !self.is_excluded(name)
     }
@@ -16,14 +23,24 @@ impl EncapsulateDeriveEnumConfig {
             .map(|excluded| excluded.is_excluded(name))
             .unwrap_or(false)
     }
+
+    pub(crate) fn discriminant(&self) -> Option<&DiscriminantConfig> {
+        self.discriminant.as_ref()
+    }
 }
 
-impl EncapsulateDeriveEnumConfig {
+impl EnumConfig {
     pub(crate) fn from_enum(item_enum: &syn::ItemEnum) -> Result<Self, syn::Error> {
         let mut this = Self::default();
 
         parse_enumcapsulate_attrs(&item_enum.attrs, |meta| {
-            if meta.path.is_ident(EXCLUDE) {
+            if meta.path.is_ident(DISCRIMINANT) {
+                let mut discriminant = this.discriminant.take().unwrap_or_default();
+
+                discriminant.parse(&meta, item_enum)?;
+
+                this.discriminant = Some(discriminant);
+            } else if meta.path.is_ident(EXCLUDE) {
                 let mut exclude = this.exclude.take().unwrap_or_default();
 
                 exclude.parse(&meta, false)?;

macros/src/config/for_variant.rs

@@ -1,15 +1,6 @@
+mod config;
 mod discriminant;
-mod standard;
-mod variant_discriminant;
 
-pub(crate) use self::variant_discriminant::VariantDiscriminantDeriveVariantConfig;
+pub(crate) use self::config::VariantConfig;
 
-use self::{discriminant::DiscriminantConfig, standard::VariantConfig};
-
-pub(crate) type FromDeriveVariantConfig = VariantConfig;
-pub(crate) type TryIntoDeriveVariantConfig = VariantConfig;
-pub(crate) type FromVariantDeriveVariantConfig = VariantConfig;
-pub(crate) type IntoVariantDeriveVariantConfig = VariantConfig;
-pub(crate) type AsVariantDeriveVariantConfig = VariantConfig;
-pub(crate) type AsVariantMutDeriveVariantConfig = VariantConfig;
-pub(crate) type AsVariantRefDeriveVariantConfig = VariantConfig;
+use self::discriminant::DiscriminantConfig;

macros/src/config/for_variant/standard.rs → macros/src/config/for_variant/config.rs

@@ -1,11 +1,13 @@
 use syn::LitStr;
 
 use crate::{
-    attr::{EXCLUDE, FIELD},
+    attr::{DISCRIMINANT, EXCLUDE, FIELD},
     config::ExcludeConfig,
     parse_enumcapsulate_attrs,
 };
 
+use super::DiscriminantConfig;
+
 #[derive(Clone, Eq, PartialEq, Debug)]
 pub(crate) enum FieldSelector {
     Name(String),
@@ -14,6 +16,7 @@ pub(crate) enum FieldSelector {
 
 #[derive(Clone, Default)]
 pub(crate) struct VariantConfig {
+    discriminant: Option<DiscriminantConfig>,
     exclude: Option<ExcludeConfig>,
     field: Option<FieldSelector>,
 }
@@ -23,7 +26,13 @@ impl VariantConfig {
         let mut this = Self::default();
 
         parse_enumcapsulate_attrs(&variant.attrs, |meta| {
-            if meta.path.is_ident(EXCLUDE) {
+            if meta.path.is_ident(DISCRIMINANT) {
+                let mut discriminant = this.discriminant.take().unwrap_or_default();
+
+                discriminant.parse(&meta, variant)?;
+
+                this.discriminant = Some(discriminant);
+            } else if meta.path.is_ident(EXCLUDE) {
                 let mut exclude = this.exclude.take().unwrap_or_default();
 
                 exclude.parse(&meta, true)?;
@@ -51,14 +60,6 @@ impl VariantConfig {
         Ok(this)
     }
 
-    pub(crate) fn is_excluded(&self, name: &str) -> bool {
-        if let Some(excludes) = &self.exclude {
-            return excludes.is_excluded(name);
-        }
-
-        false
-    }
-
     pub(crate) fn position_of_selected_field(
         &self,
         fields: &syn::Fields,
@@ -97,4 +98,12 @@ impl VariantConfig {
             )),
         }
     }
+
+    pub(crate) fn discriminant(&self) -> Option<&DiscriminantConfig> {
+        self.discriminant.as_ref()
+    }
+
+    pub(crate) fn exclude(&self) -> Option<&ExcludeConfig> {
+        self.exclude.as_ref()
+    }
 }