Add support for nested variant discriminants

(via `#[enumcapsulate(discriminant(nested = …))]` variant attribute)

Author: regexident

macros/src/config/for_variant/config.rs

@@ -14,6 +14,12 @@ pub(crate) enum FieldSelector {
     Index(usize),
 }
 
+impl Default for FieldSelector {
+    fn default() -> Self {
+        Self::Index(0)
+    }
+}
+
 #[derive(Clone, Default)]
 pub(crate) struct VariantConfig {
     discriminant: Option<DiscriminantConfig>,
@@ -60,42 +66,41 @@ impl VariantConfig {
         Ok(this)
     }
 
-    pub(crate) fn position_of_selected_field(
+    pub(crate) fn selected_field<'a>(
         &self,
-        fields: &syn::Fields,
-    ) -> Result<usize, syn::Error> {
-        if let Some(selector) = &self.field {
-            match selector {
-                FieldSelector::Name(name) => {
-                    let position = fields
-                        .iter()
-                        .position(|field| {
-                            field
-                                .ident
-                                .as_ref()
-                                .map(|ident| ident == name)
-                                .unwrap_or(false)
-                        })
-                        .expect("field name should have been rejected");
-
-                    return Ok(position);
-                }
-                FieldSelector::Index(index) => {
-                    if *index >= fields.len() {
-                        return Err(syn::Error::new_spanned(fields, "field index out of bounds"));
-                    }
-                    return Ok(*index);
-                }
+        fields: &'a syn::Fields,
+    ) -> Result<Option<(&'a syn::Field, usize)>, syn::Error> {
+        let default_field_selector = FieldSelector::default();
+        let field_selector = self.field.as_ref().unwrap_or(&default_field_selector);
+
+        if fields.is_empty() {
+            return Ok(None);
+        }
+
+        match field_selector {
+            FieldSelector::Name(name) => {
+                let (index, field) = fields
+                    .iter()
+                    .enumerate()
+                    .find(|(_, field)| {
+                        field
+                            .ident
+                            .as_ref()
+                            .map(|ident| ident == name)
+                            .unwrap_or(false)
+                    })
+                    .expect("field name should have been rejected");
+
+                Ok(Some((field, index)))
+            }
+            FieldSelector::Index(index) => {
+                let field = fields
+                    .iter()
+                    .nth(*index)
+                    .expect("field index should have been rejected");
+
+                Ok(Some((field, *index)))
             }
-        };
-
-        match fields.len() {
-            0 => Err(syn::Error::new_spanned(fields, "no fields")),
-            1 => Ok(0),
-            _ => Err(syn::Error::new_spanned(
-                fields,
-                "multiple fields, please disambiguate via helper attribute",
-            )),
         }
     }
 
@@ -106,4 +111,9 @@ impl VariantConfig {
     pub(crate) fn exclude(&self) -> Option<&ExcludeConfig> {
         self.exclude.as_ref()
     }
+
+    #[allow(dead_code)]
+    pub(crate) fn field(&self) -> Option<&FieldSelector> {
+        self.field.as_ref()
+    }
 }

macros/src/config/for_variant/discriminant.rs

@@ -1,32 +1,45 @@
 use syn::meta::ParseNestedMeta;
 
-use crate::attr::{NAME, VALUE};
+use crate::attr::{NAME, NESTED, VALUE};
 
 #[derive(Clone, Default)]
 pub(crate) struct DiscriminantConfig {
     expr: Option<syn::Expr>,
     ident: Option<syn::Ident>,
+    nested: Option<syn::Path>,
 }
 
 impl DiscriminantConfig {
     pub(crate) fn parse(
         &mut self,
         meta: &ParseNestedMeta,
-        _variant: &syn::Variant,
+        variant: &syn::Variant,
     ) -> Result<(), syn::Error> {
         meta.parse_nested_meta(|meta| {
             if meta.path.is_ident(VALUE) {
                 if self.expr.is_some() {
-                    return Err(meta.error("value already specified"));
+                    return Err(meta.error("`value = …` already specified"));
+                } else if self.nested.is_some() {
+                    return Err(meta.error("conflicting with use of `nesting = …`"));
                 }
 
                 self.expr = Some(meta.value()?.parse()?);
             } else if meta.path.is_ident(NAME) {
                 if self.ident.is_some() {
-                    return Err(meta.error("name already specified"));
+                    return Err(meta.error("`name = …` already specified"));
                 }
 
                 self.ident = Some(meta.value()?.parse()?);
+            } else if meta.path.is_ident(NESTED) {
+                if matches!(variant.fields, syn::Fields::Unit) {
+                    return Err(meta.error("no field found on variant"));
+                } else if self.nested.is_some() {
+                    return Err(meta.error("`nested = …` already specified"));
+                } else if self.expr.is_some() {
+                    return Err(meta.error("conflicting with use of `value = …`"));
+                }
+
+                self.nested = Some(meta.value()?.parse()?);
             } else {
                 return Err(meta.error("unsupported discriminant attribute"));
             }
@@ -42,4 +55,8 @@ impl DiscriminantConfig {
     pub(crate) fn ident(&self) -> Option<&syn::Ident> {
         self.ident.as_ref()
     }
+
+    pub(crate) fn nested(&self) -> Option<&syn::Path> {
+        self.nested.as_ref()
+    }
 }