Remove potentially confusing #[enumcapsulate(include(…))] helper attributes

Author: regexident

CHANGELOG.md

@@ -27,6 +27,7 @@ Please make sure to add your changes to the appropriate categories:
 - Bumped MSRV from "1.74.0" to "1.78.0".
 - Made the enum-level `#[enumcapsulate(exclude(…))]` helper macros only have an effect on derives, when orchestrated through the `Encapsulate` derive macro.
 - Made `Encapsulate` derive macro no longer derive `VariantDiscriminant`.
+- Removed potentially confusing `#[enumcapsulate(include(…))]` helper attributes.
 
 ### Deprecated
 

macros/README.md

@@ -59,9 +59,6 @@ enum Enum { /* ... */ }
 > your your particular use case then your can selectively opt them out by use of an
 > `#[enumcapsulate(exclude(…))]` attribute on the enum itself.
 >
-> You can even opt trait derives back in at the variant-level, by use of `#[enumcapsulate(include)]`
-> for previously opted-out derives, or individually by use of `#[enumcapsulate(include(…))]`:
->
 > ```rust
 > #[derive(Encapsulate)]
 > #[enumcapsulate(exclude(From, TryInto))]
@@ -70,12 +67,14 @@ enum Enum { /* ... */ }
 >     // due to existing enum-level attribute:
 >     VariantA(VariantA),
 >
->     // Selectively re-included for all derives:
->     #[enumcapsulate(include)]
+>     // Exclude derivation of any traits
+>     // for this specific variant's type:
+>     #[enumcapsulate(exclude)]
 >     VariantB(VariantB),
 >
->     // Selectively re-included for `From` derive:
->     #[enumcapsulate(include(From))]
+>     // Selectively exclude derivation of `From` trait
+>     // for this specific variant's type:
+>     #[enumcapsulate(exclude(From))]
 >     VariantC(VariantC),
 > }
 > ```
@@ -110,32 +109,6 @@ then you can do so by use of an `#[enumcapsulate(exclude(…))]` attribute:
 enum Enum { /* ... */ }
 ```
 
-> [!TIP]
-> If you wish to opt all but a select few variants out of a trait's derive, then
-> you can do so by use of an `#[enumcapsulate(exclude(…))]` attribute on the enum,
-> together with a `#[enumcapsulate(include(…))]` attribute on the variant:
->
-> ```rust
-> #[derive(Encapsulate)]
-> #[enumcapsulate(exclude(From, TryInto))]
-> enum Enum {
->     // Excluded from `From` and `TryInto` derives
->     // due to existing enum-level attribute:
->     VariantA(VariantA),
->
->     // Selectively re-included for all derives:
->     #[enumcapsulate(include)]
->     VariantB(VariantB),
->
->     // Selectively re-included for
->     // just the `From` derive:
->     #[enumcapsulate(include(From))]
->     VariantC(VariantC),
->
->     // ...
-> }
-> ```
-
 ### Variant attributes
 
 > [!NOTE]
@@ -170,71 +143,6 @@ enum Enum {
 }
 ```
 
-> [!TIP]
-> Combine the use of `#[enumcapsulate(exclude)]` with `#[enumcapsulate(include(…)]`
-> in order to exclude a variant from all but a select few derive macros.
->
-> ```rust
-> // Exclude variant from all derives,
-> // then selectively re-include it for
-> // just the `From` and `TryInto` derives:
-> #[enumcapsulate(exclude)]
-> #[enumcapsulate(include(From, TryInto))]
-> ```
-
-This attribute is recognized by the following variant-based derive macros:
-
-- `AsVariant`
-- `AsVariantMut`
-- `AsVariantRef`
-- `FromVariant`
-- `IntoVariant`
-- `From`
-- `TryInto`
-
-… as well as the umbrella derive macro:
-
-- `Encapsulate`
-
-#### `#[enumcapsulate(include(…)]`
-
-Include this variant for specific trait derivation (overriding existing uses of `#[enumcapsulate(exclude)]`).
-
-- `#[enumcapsulate(include)]`
-
-    Include variant from *all* `enumcapsulate` derive macros.
-
-- `#[enumcapsulate(include(…))]`
-
-    Include variant from specific `enumcapsulate` derive macros.
-
-```rust
-#[derive(Encapsulate)]
-#[enumcapsulate(exclude(From, TryInto))]
-enum Enum {
-    // Included by default.
-    VariantA(VariantA),
-    
-    // Selectively included for just
-    // the `From` and `TryInto` derives:
-    #[enumcapsulate(exclude)]
-    #[enumcapsulate(include(From, TryInto))]
-    VariantB(VariantB),
-}
-```
-
-> [!NOTE]
-> The `#[enumcapsulate(include(…)]` variant has a higher precedence than `#[enumcapsulate(exclude)]`,
-> and thus acts as a selective override if both are present on a variant:
->
-> ```rust
-> // Exclude variant from all derives,
-> // then selectively re-include it for
-> // just the `From` and `TryInto` derives:
-> #[enumcapsulate(exclude)]
-> #[enumcapsulate(include(From, TryInto))]
-> ```
-
 This attribute is recognized by the following variant-based derive macros:
 
 - `AsVariant`

macros/src/config.rs

@@ -47,15 +47,10 @@ impl MacroSelectionConfig {
     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 EncapsulateEnumConfig {
@@ -84,56 +79,26 @@ pub(crate) struct VariantConfig {
     // #[enumcapsulate(exclude(…))]
     pub exclude: Option<VariantExcludeConfig>,
 
-    // #[enumcapsulate(include(…))]
-    pub include: Option<VariantIncludeConfig>,
-
     // #[enumcapsulate(field(…))]
     pub field: Option<VariantFieldConfig>,
 }
 
 impl VariantConfig {
-    pub fn is_excluded(&self, name: &str) -> bool {
-        if self.is_included_explicitly(name) {
-            return false;
-        }
-
-        if self.is_excluded_explicitly(name) {
-            return true;
-        }
-
-        false
+    #[allow(dead_code)]
+    pub fn is_included(&self, name: &str) -> bool {
+        !self.is_excluded(name)
     }
 
-    pub fn is_excluded_explicitly(&self, name: &str) -> bool {
+    pub fn is_excluded(&self, name: &str) -> bool {
         let Some(excluded) = &self.exclude else {
             return 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 {
-        let Some(included) = &self.include else {
-            return false;
-        };
-
-        if included.is_empty() {
-            if let Some(excluded) = &self.exclude {
-                return !excluded.contains(name);
-            } else {
-                return true;
-            }
+            true
+        } else {
+            excluded.contains(name)
         }
-
-        included.contains(name)
     }
 }
 
@@ -205,19 +170,9 @@ pub(crate) fn config_for_variant(variant: &syn::Variant) -> Result<VariantConfig
 
             let mut exclude = config.exclude.take().unwrap_or_default();
 
-            let opposite = config.include.as_ref();
-            exclude.extend_idents(macro_selection_config_for_variant(&meta, opposite)?.idents);
+            exclude.extend_idents(macro_selection_config_for_variant(&meta)?.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 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(…))]
             meta.parse_nested_meta(|meta| {
@@ -311,16 +266,12 @@ pub(crate) fn macro_selection_config_for_enum(
 
 pub(crate) fn macro_selection_config_for_variant(
     meta: &syn::meta::ParseNestedMeta<'_>,
-    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(MacroSelectionConfig { idents })
 }
 
@@ -350,32 +301,6 @@ pub(crate) fn ensure_only_recognized_ident_names(
     Ok(())
 }
 
-pub(crate) fn ensure_no_conflicting_idents(
-    idents: &[syn::Ident],
-    conflicting: &[syn::Ident],
-) -> Result<(), syn::Error> {
-    let mut error: Option<syn::Error> = None;
-
-    let conflicting = idents
-        .iter()
-        .filter(|&ident| conflicting.iter().any(|conflicting| ident == conflicting));
-
-    for ident in conflicting {
-        let ident_err = syn::Error::new_spanned(ident, "conflicting macro derive");
-        if let Some(error) = error.as_mut() {
-            error.combine(ident_err);
-        } else {
-            error = Some(ident_err)
-        }
-    }
-
-    if let Some(err) = error {
-        return Err(err);
-    }
-
-    Ok(())
-}
-
 pub(crate) fn parse_idents_from_meta_list(
     meta: &syn::meta::ParseNestedMeta<'_>,
 ) -> Result<Vec<syn::Ident>, syn::Error> {