Re-introduce type argument (nested = <Type>) of #[enumcapsulate(discriminant(nested))] variant attribute, but as an optional argument

(required for fields using the parent enum's generic parameters)

Author: regexident

CHANGELOG.md

@@ -24,7 +24,7 @@ Please make sure to add your changes to the appropriate categories:
 
 ### Changed
 
-- n/a
+- Re-introduced type argument (`nested = <Type>`) of `#[enumcapsulate(discriminant(nested))]` variant attribute, but as an optional argument (required for fields using the parent enum's generic parameters).
 
 ### Deprecated
 

macros/README.md

@@ -310,6 +310,37 @@ enum Enum {
 
 There is limited support for generic enums:
 
+### `VariantDiscriminant`
+
+When using the `VariantDiscriminant` derive macro with a generic enum you have to
+provide an explicit type path for any nested discriminant that uses any of the parent
+enum's generic parameters in its own type.
+
+```rust
+#[derive(VariantDiscriminant)]
+enum VariantA<T> {
+    VariantA1(T),
+    // ...
+}
+
+#[derive(VariantDiscriminant)]
+enum VariantB {
+    VariantB1,
+    // ...
+}
+
+#[derive(VariantDiscriminant)]
+enum Enum<T> {
+    #[enumcapsulate(discriminant(nested = VariantADiscriminant))]
+    VariantA(VariantA<T>),
+    #[enumcapsulate(discriminant(nested))]
+    VariantB(VariantB),
+    // ...
+}
+```
+
+### Generic traits
+
 Variants using generic const/type parameters are always excluded when deriving generic traits with `enumcapsulate`'s derive macros.
 
 The reason for this behavior is that implementing generic traits for variants that use any of the generic parameters of the enum tends to result in conflicting implementations in Rust, as shown by the following example program:

macros/src/config/for_variant/discriminant.rs

@@ -2,11 +2,17 @@ use syn::meta::ParseNestedMeta;
 
 use crate::attr::{NAME, NESTED, VALUE};
 
+#[derive(Clone)]
+pub enum NestedDiscriminantType {
+    Default,
+    Custom(syn::Type),
+}
+
 #[derive(Clone, Default)]
 pub(crate) struct DiscriminantConfig {
     value: Option<syn::Expr>,
     name: Option<syn::Ident>,
-    nested: bool,
+    nested: Option<NestedDiscriminantType>,
 }
 
 impl DiscriminantConfig {
@@ -19,7 +25,7 @@ impl DiscriminantConfig {
             if meta.path.is_ident(VALUE) {
                 if self.value.is_some() {
                     return Err(meta.error("`value = …` already specified"));
-                } else if self.nested {
+                } else if self.nested.is_some() {
                     return Err(meta.error("conflicting with use of `nesting`"));
                 }
 
@@ -33,13 +39,18 @@ impl DiscriminantConfig {
             } 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 {
+                } else if self.nested.is_some() {
                     return Err(meta.error("`nested` already specified"));
                 } else if self.value.is_some() {
                     return Err(meta.error("conflicting with use of `value = …`"));
                 }
 
-                self.nested = true;
+                if meta.input.peek(syn::Token![=]) {
+                    let custom_type = meta.value()?.parse()?;
+                    self.nested = Some(NestedDiscriminantType::Custom(custom_type));
+                } else {
+                    self.nested = Some(NestedDiscriminantType::Default);
+                }
             } else {
                 return Err(meta.error("unsupported discriminant attribute"));
             }
@@ -56,7 +67,7 @@ impl DiscriminantConfig {
         self.name.as_ref()
     }
 
-    pub(crate) fn nested(&self) -> bool {
-        self.nested
+    pub(crate) fn nested(&self) -> Option<&NestedDiscriminantType> {
+        self.nested.as_ref()
     }
 }

macros/src/enum_deriver.rs

@@ -1,6 +1,8 @@
 use proc_macro2::TokenStream as TokenStream2;
 use quote::quote;
-use syn::{parse_quote, parse_quote_spanned, visit::Visit as _, Fields, Type, Variant};
+use syn::{
+    parse_quote, parse_quote_spanned, spanned::Spanned, visit::Visit as _, Fields, Type, Variant,
+};
 
 use crate::*;
 
@@ -579,13 +581,28 @@ impl EnumDeriver {
                     discriminant_variant_expr = Some(expr);
                 }
 
-                if discriminant_config.nested() {
-                    let (field, _) = field_selection.expect("no selected field found");
-                    let ty = &field.ty;
-                    let nested_type = parse_quote! {
-                        <#ty as ::enumcapsulate::VariantDiscriminant>::Discriminant
-                    };
-                    discriminant_variant_nested = Some(nested_type);
+                if let Some(nested) = discriminant_config.nested() {
+                    match nested {
+                        NestedDiscriminantType::Default => {
+                            let (field, _) = field_selection.expect("no selected field found");
+                            let field_type = &field.ty;
+
+                            if self.uses_generic_const_or_type(field_type) {
+                                return Err(syn::Error::new(
+                                    field.span(),
+                                    "generic fields require an explicit nested discriminant type",
+                                ));
+                            }
+
+                            let nested_type = parse_quote! {
+                                <#field_type as ::enumcapsulate::VariantDiscriminant>::Discriminant
+                            };
+                            discriminant_variant_nested = Some(nested_type);
+                        }
+                        NestedDiscriminantType::Custom(custom_type) => {
+                            discriminant_variant_nested = Some(custom_type.clone());
+                        }
+                    }
                 }
             }
 

tests/derive-tests/variant_discriminant/fail/nested_generic_field.err.txt

@@ -0,0 +1,6 @@
+error: generic fields require an explicit nested discriminant type
+  --> /tests/derive-tests/variant_discriminant/fail/nested_generic_field.rs:12:14
+   |
+12 |     VariantA(VariantA<T>),
+   |              ^^^^^^^^
+error: could not compile `<CRATE>` (bin "<BIN>") due to 1 previous error

tests/derive-tests/variant_discriminant/fail/nested_generic_field.out.rs

@@ -0,0 +1,76 @@
+use enumcapsulate::VariantDiscriminant;
+pub enum VariantA<T> {
+    Variant(T),
+}
+pub enum VariantADiscriminant {
+    Variant,
+}
+#[automatically_derived]
+impl ::core::marker::Copy for VariantADiscriminant {}
+#[automatically_derived]
+impl ::core::clone::Clone for VariantADiscriminant {
+    #[inline]
+    fn clone(&self) -> VariantADiscriminant {
+        *self
+    }
+}
+#[automatically_derived]
+impl ::core::cmp::Ord for VariantADiscriminant {
+    #[inline]
+    fn cmp(&self, other: &VariantADiscriminant) -> ::core::cmp::Ordering {
+        ::core::cmp::Ordering::Equal
+    }
+}
+#[automatically_derived]
+impl ::core::cmp::PartialOrd for VariantADiscriminant {
+    #[inline]
+    fn partial_cmp(
+        &self,
+        other: &VariantADiscriminant,
+    ) -> ::core::option::Option<::core::cmp::Ordering> {
+        ::core::option::Option::Some(::core::cmp::Ordering::Equal)
+    }
+}
+#[automatically_derived]
+impl ::core::cmp::Eq for VariantADiscriminant {
+    #[inline]
+    #[doc(hidden)]
+    #[coverage(off)]
+    fn assert_receiver_is_total_eq(&self) -> () {}
+}
+#[automatically_derived]
+impl ::core::marker::StructuralPartialEq for VariantADiscriminant {}
+#[automatically_derived]
+impl ::core::cmp::PartialEq for VariantADiscriminant {
+    #[inline]
+    fn eq(&self, other: &VariantADiscriminant) -> bool {
+        true
+    }
+}
+#[automatically_derived]
+impl ::core::hash::Hash for VariantADiscriminant {
+    #[inline]
+    fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {}
+}
+#[automatically_derived]
+impl ::core::fmt::Debug for VariantADiscriminant {
+    #[inline]
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+        ::core::fmt::Formatter::write_str(f, "Variant")
+    }
+}
+impl<T> ::enumcapsulate::VariantDiscriminant for VariantA<T> {
+    type Discriminant = VariantADiscriminant;
+    fn variant_discriminant(&self) -> Self::Discriminant {
+        match self {
+            VariantA::Variant(..) => VariantADiscriminant::Variant,
+            _ => ::core::panicking::panic("internal error: entered unreachable code"),
+        }
+    }
+}
+#[enumcapsulate(discriminant(repr = u8))]
+pub enum Enum<T> {
+    #[enumcapsulate(discriminant(nested))]
+    VariantA(VariantA<T>),
+}
+fn main() {}

tests/derive-tests/variant_discriminant/fail/nested_generic_field.rs

@@ -0,0 +1,15 @@
+use enumcapsulate::VariantDiscriminant;
+
+#[derive(VariantDiscriminant)]
+pub enum VariantA<T> {
+    Variant(T),
+}
+
+#[derive(VariantDiscriminant)]
+#[enumcapsulate(discriminant(repr = u8))]
+pub enum Enum<T> {
+    #[enumcapsulate(discriminant(nested))]
+    VariantA(VariantA<T>),
+}
+
+fn main() {}