Add support for adding attributes to enum variants (#46)

* Add support for adding attributes to enum variants

* Add test for `enum_variant_attributes`

If `enum_variant_attributes(serde(borrow))` is removed or commented,
the compilation will fail with `error: lifetime may not live long enough`.

* Add documentation for enum_variant_attributes

* Add documentation for specific_enum_variant_attributes

Also fixes some small docs issues (unlinked page, wrong link, double word)

* Improve the enum_variant_attributes test to exercise specific_enum_variant_attributes

---------

Co-authored-by: Christiaan Biesterbosch <[email protected]>

Author: Kriskras99

book/src/SUMMARY.md

@@ -7,6 +7,7 @@
   - [Top-level enum](./codegen/enum.md)
   - [`Ref` and `RefMut`](./codegen/ref-and-refmut.md)
   - [Mapping macros](./codegen/map-macros.md)
+  - [Meta variant structs and enums](./codegen/meta-variants.md)
 - [Configuration](./config.md)
   - [Struct attributes](./config/struct.md)
   - [Field attributes](./config/field.md)

book/src/codegen.md

@@ -8,6 +8,7 @@ You should visit each of the sub-pages in order to understand how the generated
 2. [Top-level enum](./codegen/enum.md).
 3. [`Ref` and `RefMut`](./codegen/ref-and-refmut.md).
 4. [Mapping macros](./codegen/map-macros.md).
+5. [Meta variant structs and enums](./codegen/meta-variants.md).
 
 ## Example
 

book/src/codegen/enum.md

@@ -2,7 +2,7 @@
 
 SuperStruct generates an enum that combines all of the generated variant structs.
 
-Consider the the `MyStruct` example from the previous page:
+Consider the `MyStruct` example from the previous page:
 
 ```rust,no_run,no_playground
 #[superstruct(variants(Foo, Bar))]
@@ -68,3 +68,37 @@ are described [here](./ref-and-refmut.md).
 The top-level enum has `From` implementations for converting (owned) variant structs, i.e.
 
 * `impl From<{VariantStruct}> for {BaseName}` for all variants
+
+## Attributes on the enum variants
+
+To add attributes to the enum variants, `enum_variant_attributes` and `specific_enum_variant_attributes`
+can be used.
+
+Consider a variant of the `MyStruct` example where you want to derive `serde::Serialize`. However, one
+of the fields has a lifetime thus the `#[serde(borrow)]` attribute is required on the enum variants.
+In addition, you want to change the name of one of the enum variants when it's serialized:
+```rust,no_run,no_playground
+#[superstruct(
+    variants(Foo, Bar),
+    enum_variant_attributes(serde(borrow)),
+    specific_enum_variant_attributes(Bar(serde(rename = "Baz"))),
+)]
+#[derive(serde::Serialize)]
+struct MyStruct<'a> {
+    name: &'a str,
+    #[superstruct(only(Foo))]
+    location: u16,
+}
+```
+
+The generated enum is:
+
+```rust,no_run,no_playground
+#[derive(serde::Serialize)]
+enum MyStruct<'a> {
+    #[serde(borrow)]
+    Foo(MyStructFoo<'a>),
+    #[serde(borrow, rename = "Baz")]
+    Bar(MyStructBar<'a>),
+}
+```

book/src/config/struct.md

@@ -67,6 +67,30 @@ procedural macro is being invoked on the variant struct which requires different
 
 **Format**: zero or more variant names, with variant attributes nested in parens
 
+## Enum variant attributes
+
+```
+#[superstruct(enum_variant_attributes(...))]
+```
+
+Provide a list of attributes to be applied verbatim to each of the enum variants.
+
+This is useful when using another proc-macro on the enum and needing to add an attribute
+to all enum variants.
+
+**Format**: any.
+
+## Specific enum variant attributes
+
+```
+#[superstruct(specific_enum_variant_attributes(A(...), B(...), ...))]
+```
+
+Similar to `enum_variant_attributes`, but applies the attributes only to the named enum variants.
+This is useful if e.g. one enum variant needs an attribute while the others cannot.
+
+**Format**: zero or more variant names, with enum variant attributes nested in parens.
+
 ## `Ref` attributes
 
 ```
@@ -106,7 +130,7 @@ Disable generation of the top-level enum, and all code except the
 
 Generate mapping macros from the top-level enum, the `Ref` type or the `RefMut` type as appropriate.
 
-Please see the documentation on [Mapping into other types](./codegen/map-macros.md#mapping-into-other-types)
+Please see the documentation on [Mapping into other types](../codegen/map-macros.md#mapping-into-other-types)
 for an explanation of how these macros operate.
 
 **Format**: one or more `superstruct` type names

src/lib.rs

@@ -9,7 +9,7 @@ use from::{
     generate_from_enum_trait_impl_for_ref, generate_from_variant_trait_impl,
     generate_from_variant_trait_impl_for_ref,
 };
-use itertools::Itertools;
+use itertools::{izip, Itertools};
 use macros::generate_all_map_macros;
 use proc_macro::TokenStream;
 use proc_macro2::{Span, TokenStream as TokenStream2};
@@ -39,6 +39,12 @@ struct StructOpts {
     /// List of attributes to apply to a selection of named variant structs.
     #[darling(default)]
     specific_variant_attributes: Option<HashMap<Ident, NestedMetaList>>,
+    /// List of attributes to apply to the enum variants.
+    #[darling(default)]
+    enum_variant_attributes: Option<NestedMetaList>,
+    /// List of attributes to apply to a selection of named enum variants.
+    #[darling(default)]
+    specific_enum_variant_attributes: Option<HashMap<Ident, NestedMetaList>>,
     /// List of attributes to apply to the generated Ref type.
     #[darling(default)]
     ref_attributes: Option<NestedMetaList>,
@@ -480,6 +486,11 @@ pub fn superstruct(args: TokenStream, input: TokenStream) -> TokenStream {
 
     // If the `no_enum` attribute is set, stop after generating variant structs.
     if opts.no_enum {
+        if opts.enum_variant_attributes.is_some() {
+            panic!("can't set both `no_enum` and `enum_variant_attributes`")
+        } else if opts.specific_enum_variant_attributes.is_some() {
+            panic!("can't set both `no_enum` and `enum_specific_variant_attributes`")
+        }
         return TokenStream::from_iter(output_items);
     }
 
@@ -542,11 +553,35 @@ fn generate_wrapper_enums(
     is_meta: bool,
 ) {
     let visibility = &item.vis;
+    let enum_variant_attributes = opts
+        .enum_variant_attributes
+        .as_ref()
+        .map_or(&[][..], |attrs| &attrs.metas);
     // Extract the generics to use for the top-level type and all variant structs.
     let decl_generics = &item.generics;
     // Generics used for the impl block.
     let (impl_generics, ty_generics, where_clause) = &item.generics.split_for_impl();
 
+    // Construct the enum variants
+    let mut variants = Vec::new();
+    for (variant_name, struct_name) in izip!(variant_names, struct_names) {
+        let specific_enum_variant_attributes = opts
+            .specific_enum_variant_attributes
+            .as_ref()
+            .and_then(|map| map.get(variant_name))
+            .map_or(&[][..], |attrs| &attrs.metas);
+        let variant = quote! {
+            #(
+                #[#enum_variant_attributes]
+            )*
+            #(
+                #[#specific_enum_variant_attributes]
+            )*
+            #variant_name(#struct_name #ty_generics),
+        };
+        variants.push(variant);
+    }
+
     // Construct the top-level enum.
     let top_level_attrs = discard_superstruct_attrs(&item.attrs);
     let enum_item = quote! {
@@ -555,7 +590,7 @@ fn generate_wrapper_enums(
         )*
         #visibility enum #type_name #decl_generics #where_clause {
             #(
-                #variant_names(#struct_names #ty_generics),
+                #variants
             )*
         }
     };

tests/basic.rs

@@ -1,6 +1,7 @@
 #![allow(non_local_definitions)] // for macros on structs within test functions
 
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
+use std::borrow::Cow;
 use superstruct::superstruct;
 
 #[test]
@@ -152,3 +153,31 @@ fn no_getter() {
         pub x: String,
     }
 }
+
+#[test]
+#[allow(dead_code)]
+fn enum_variant_attribute() {
+    #[superstruct(
+        variants(A, B),
+        variant_attributes(derive(Deserialize, Serialize)),
+        enum_variant_attributes(serde(borrow)),
+        specific_enum_variant_attributes(B(serde(rename = "C")))
+    )]
+    #[derive(Deserialize, Serialize)]
+    struct EnumVariantAttribute<'a> {
+        #[superstruct(only(A))]
+        #[serde(borrow)]
+        pub x: Cow<'a, str>,
+        #[superstruct(only(B))]
+        #[serde(borrow)]
+        pub y: Cow<'a, [u8]>,
+    }
+
+    assert_eq!(
+        serde_json::to_string(&EnumVariantAttribute::B(EnumVariantAttributeB {
+            y: Cow::Borrowed(&[0])
+        }))
+        .unwrap(),
+        r#"{"C":{"y":[0]}}"#
+    );
+}