Merge branch 'bobozaur-258-transparent-attr'

Author: Peter Glotfelty

strum/src/additional_attributes.rs

@@ -74,6 +74,10 @@
 //!     The plugin will fail if the data doesn't implement From<&str>. You can only have one `default`
 //!     on your enum.
 //!
+//! - `transparent`: Signals that the inner field's implementation should be used, instead of generating
+//!    one for this variant. Only applicable to enum variants with a single field. Compatible with the
+//!    `AsRefStr`, `Display` and `IntoStaticStr` derive macros.
+//!
 //! - `disabled`: removes variant from generated code.
 //!
 //! - `ascii_case_insensitive`: makes the comparison to this variant case insensitive (ASCII only).

strum_macros/src/helpers/metadata.rs

@@ -32,6 +32,7 @@ pub mod kw {
     custom_keyword!(detailed_message);
     custom_keyword!(serialize);
     custom_keyword!(to_string);
+    custom_keyword!(transparent);
     custom_keyword!(disabled);
     custom_keyword!(default);
     custom_keyword!(default_with);
@@ -62,7 +63,7 @@ pub enum EnumMeta {
         kw: kw::parse_err_fn,
         path: Path,
     },
-    ConstIntoStr(kw::const_into_str)
+    ConstIntoStr(kw::const_into_str),
 }
 
 impl Parse for EnumMeta {
@@ -188,6 +189,7 @@ pub enum VariantMeta {
         kw: kw::to_string,
         value: LitStr,
     },
+    Transparent(kw::transparent),
     Disabled(kw::disabled),
     Default(kw::default),
     DefaultWith {
@@ -227,6 +229,8 @@ impl Parse for VariantMeta {
             let _: Token![=] = input.parse()?;
             let value = input.parse()?;
             Ok(VariantMeta::ToString { kw, value })
+        } else if lookahead.peek(kw::transparent) {
+            Ok(VariantMeta::Transparent(input.parse()?))
         } else if lookahead.peek(kw::disabled) {
             Ok(VariantMeta::Disabled(input.parse()?))
         } else if lookahead.peek(kw::default) {

strum_macros/src/helpers/mod.rs

@@ -32,6 +32,16 @@ pub fn non_unit_variant_error() -> syn::Error {
     )
 }
 
+pub fn non_single_field_variant_error(attr: &str) -> syn::Error {
+    syn::Error::new(
+        Span::call_site(),
+        format_args!(
+            "The [`{}`] attribute only supports enum variants with a single field",
+            attr
+        ),
+    )
+}
+
 pub fn strum_discriminants_passthrough_error(span: &impl Spanned) -> syn::Error {
     syn::Error::new(
         span.span(),

strum_macros/src/helpers/variant_props.rs

@@ -11,6 +11,7 @@ pub trait HasStrumVariantProperties {
 
 #[derive(Clone, Default)]
 pub struct StrumVariantProperties {
+    pub transparent: Option<kw::transparent>,
     pub disabled: Option<kw::disabled>,
     pub default: Option<kw::default>,
     pub default_with: Option<LitStr>,
@@ -73,6 +74,7 @@ impl HasStrumVariantProperties for Variant {
 
         let mut message_kw = None;
         let mut detailed_message_kw = None;
+        let mut transparent_kw = None;
         let mut disabled_kw = None;
         let mut default_kw = None;
         let mut default_with_kw = None;
@@ -110,6 +112,14 @@ impl HasStrumVariantProperties for Variant {
                     to_string_kw = Some(kw);
                     output.to_string = Some(value);
                 }
+                VariantMeta::Transparent(kw) => {
+                    if let Some(fst_kw) = transparent_kw {
+                        return Err(occurrence_error(fst_kw, kw, "transparent"));
+                    }
+
+                    transparent_kw = Some(kw);
+                    output.transparent = Some(kw);
+                }
                 VariantMeta::Disabled(kw) => {
                     if let Some(fst_kw) = disabled_kw {
                         return Err(occurrence_error(fst_kw, kw, "disabled"));

strum_macros/src/lib.rs

@@ -56,7 +56,7 @@ fn debug_print_generated(ast: &DeriveInput, toks: &TokenStream) {
 ///
 /// The default error type is `strum::ParseError`. This can be overriden by applying both the
 /// `parse_err_ty` and `parse_err_fn` attributes at the type level.  `parse_error_fn` should be a
-/// function that accepts an `&str` and returns the type `parse_error_ty`. See 
+/// function that accepts an `&str` and returns the type `parse_error_ty`. See
 /// [this test case](https://github.com/Peternator7/strum/blob/9db3c4dc9b6f585aeb9f5f15f9cc18b6cf4fd780/strum_tests/tests/from_str.rs#L233)
 /// for an example.
 ///

strum_macros/src/macros/strings/as_ref_str.rs

@@ -2,9 +2,14 @@ use proc_macro2::TokenStream;
 use quote::quote;
 use syn::{parse_quote, Data, DeriveInput, Fields};
 
-use crate::helpers::{non_enum_error, HasStrumVariantProperties, HasTypeProperties};
-
-fn get_arms(ast: &DeriveInput) -> syn::Result<Vec<TokenStream>> {
+use crate::helpers::{
+    non_enum_error, non_single_field_variant_error, HasStrumVariantProperties, HasTypeProperties,
+};
+
+fn get_arms<F>(ast: &DeriveInput, transparent_fn: F) -> syn::Result<Vec<TokenStream>>
+where
+    F: Fn(&TokenStream) -> TokenStream,
+{
     let name = &ast.ident;
     let mut arms = Vec::new();
     let variants = match &ast.data {
@@ -22,12 +27,21 @@ fn get_arms(ast: &DeriveInput) -> syn::Result<Vec<TokenStream>> {
             continue;
         }
 
+        if let Some(..) = variant_properties.transparent {
+            let arm = super::extract_single_field_variant_and_then(name, variant, |tok| {
+                transparent_fn(tok)
+            })
+            .map_err(|_| non_single_field_variant_error("transparent"))?;
+
+            arms.push(arm);
+            continue;
+        }
+
         // Look at all the serialize attributes.
         // Use `to_string` attribute (not `as_ref_str` or something) to keep things consistent
         // (i.e. always `enum.as_ref().to_string() == enum.to_string()`).
         let output = variant_properties
             .get_preferred_name(type_properties.case_style, type_properties.prefix.as_ref());
-
         let params = match variant.fields {
             Fields::Unit => quote! {},
             Fields::Unnamed(..) => quote! { (..) },
@@ -52,7 +66,10 @@ fn get_arms(ast: &DeriveInput) -> syn::Result<Vec<TokenStream>> {
 pub fn as_ref_str_inner(ast: &DeriveInput) -> syn::Result<TokenStream> {
     let name = &ast.ident;
     let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl();
-    let arms = get_arms(ast)?;
+    let arms = get_arms(ast, |tok| {
+        quote! { ::core::convert::AsRef::<str>::as_ref(#tok) }
+    })?;
+
     Ok(quote! {
         impl #impl_generics ::core::convert::AsRef<str> for #name #ty_generics #where_clause {
             #[inline]
@@ -76,7 +93,10 @@ pub fn as_static_str_inner(
 ) -> syn::Result<TokenStream> {
     let name = &ast.ident;
     let (impl_generics, ty_generics, where_clause) = ast.generics.split_for_impl();
-    let arms = get_arms(ast)?;
+    let arms = get_arms(ast, |tok| {
+        quote! { ::core::convert::From::from(#tok) }
+    })?;
+
     let type_properties = ast.get_type_properties()?;
     let strum_module_path = type_properties.crate_module_path();
 
@@ -119,7 +139,7 @@ pub fn as_static_str_inner(
                 }
             }
         },
-        GenerateTraitVariant::From  => quote! {
+        GenerateTraitVariant::From => quote! {
             impl #impl_generics #name #ty_generics #where_clause {
                 pub const fn into_str(&self) -> &'static str {
                     match self {

strum_macros/src/macros/strings/display.rs

@@ -2,7 +2,9 @@ use proc_macro2::{Ident, TokenStream};
 use quote::quote;
 use syn::{punctuated::Punctuated, Data, DeriveInput, Fields, LitStr, Token};
 
-use crate::helpers::{non_enum_error, HasStrumVariantProperties, HasTypeProperties};
+use crate::helpers::{
+    non_enum_error, non_single_field_variant_error, HasStrumVariantProperties, HasTypeProperties,
+};
 
 pub fn display_inner(ast: &DeriveInput) -> syn::Result<TokenStream> {
     let name = &ast.ident;
@@ -23,6 +25,16 @@ pub fn display_inner(ast: &DeriveInput) -> syn::Result<TokenStream> {
             continue;
         }
 
+        if let Some(..) = variant_properties.transparent {
+            let arm = super::extract_single_field_variant_and_then(name, variant, |tok| {
+                quote! { ::core::fmt::Display::fmt(#tok, f)}
+            })
+            .map_err(|_| non_single_field_variant_error("transparent"))?;
+
+            arms.push(arm);
+            continue;
+        }
+
         // Look at all the serialize attributes.
         let output = variant_properties
             .get_preferred_name(type_properties.case_style, type_properties.prefix.as_ref());
@@ -37,7 +49,8 @@ pub fn display_inner(ast: &DeriveInput) -> syn::Result<TokenStream> {
                     .enumerate()
                     .map(|(index, field)| {
                         assert!(field.ident.is_none());
-                        let ident = syn::parse_str::<Ident>(format!("field{}", index).as_str()).unwrap();
+                        let ident =
+                            syn::parse_str::<Ident>(format!("field{}", index).as_str()).unwrap();
                         quote! { ref #ident }
                     })
                     .collect();
@@ -59,86 +72,87 @@ pub fn display_inner(ast: &DeriveInput) -> syn::Result<TokenStream> {
         };
 
         if variant_properties.to_string.is_none() && variant_properties.default.is_some() {
-            match &variant.fields {
-                Fields::Unnamed(fields) if fields.unnamed.len() == 1 => {
-                    arms.push(quote! { #name::#ident(ref s) => ::core::fmt::Display::fmt(s, f) });
+            let arm = super::extract_single_field_variant_and_then(name, variant, |tok| {
+                quote! { ::core::fmt::Display::fmt(#tok, f)}
+            })
+            .map_err(|_| {
+                syn::Error::new_spanned(
+                    variant,
+                    "Default only works on newtype structs with a single String field",
+                )
+            })?;
+
+            arms.push(arm);
+            continue;
+        }
+
+        let arm = match variant.fields {
+            Fields::Named(ref field_names) => {
+                let used_vars = capture_format_string_idents(&output)?;
+                if used_vars.is_empty() {
+                    quote! { #name::#ident #params => ::core::fmt::Display::fmt(#output, f) }
+                } else {
+                    // Create args like 'name = name, age = age' for format macro
+                    let args: Punctuated<_, Token!(,)> = field_names
+                        .named
+                        .iter()
+                        .filter_map(|field| {
+                            let ident = field.ident.as_ref().unwrap();
+                            // Only contain variables that are used in format string
+                            if !used_vars.contains(ident) {
+                                None
+                            } else {
+                                Some(quote! { #ident = #ident })
+                            }
+                        })
+                        .collect();
+
+                    quote! {
+                        #[allow(unused_variables)]
+                        #name::#ident #params => ::core::fmt::Display::fmt(&format_args!(#output, #args), f)
+                    }
                 }
-                _ => {
+            }
+            Fields::Unnamed(ref unnamed_fields) => {
+                let used_vars = capture_format_strings(&output)?;
+                if used_vars.iter().any(String::is_empty) {
                     return Err(syn::Error::new_spanned(
-                        variant,
-                        "Default only works on newtype structs with a single String field",
-                    ))
+                        &output,
+                        "Empty {} is not allowed; Use manual numbering ({0})",
+                    ));
                 }
-            }
-        } else {
-            let arm = match variant.fields {
-                Fields::Named(ref field_names) => {
-                    let used_vars = capture_format_string_idents(&output)?;
-                    if used_vars.is_empty() {
-                        quote! { #name::#ident #params => ::core::fmt::Display::fmt(#output, f) }
-                    } else {
-                        // Create args like 'name = name, age = age' for format macro
-                        let args: Punctuated<_, Token!(,)> = field_names
-                            .named
-                            .iter()
-                            .filter_map(|field| {
-                                let ident = field.ident.as_ref().unwrap();
-                                // Only contain variables that are used in format string
-                                if !used_vars.contains(ident) {
-                                    None
-                                } else {
-                                    Some(quote! { #ident = #ident })
-                                }
-                            })
-                            .collect();
-
-                        quote! {
-                            #[allow(unused_variables)]
-                            #name::#ident #params => ::core::fmt::Display::fmt(&format_args!(#output, #args), f)
-                        }
-                    }
-                },
-                Fields::Unnamed(ref unnamed_fields) => {
-                    let used_vars = capture_format_strings(&output)?;
-                    if used_vars.iter().any(String::is_empty) {
-                        return Err(syn::Error::new_spanned(
-                            &output,
-                            "Empty {} is not allowed; Use manual numbering ({0})",
-                        ))
-                    }
-                    if used_vars.is_empty() {
-                        quote! { #name::#ident #params => ::core::fmt::Display::fmt(#output, f) }
-                    } else {
-                        let args: Punctuated<_, Token!(,)> = unnamed_fields
-                            .unnamed
-                            .iter()
-                            .enumerate()
-                            .map(|(index, field)| {
-                                assert!(field.ident.is_none());
-                                syn::parse_str::<Ident>(format!("field{}", index).as_str()).unwrap()
-                            })
-                            .collect();
-                        quote! {
-                            #[allow(unused_variables)]
-                            #name::#ident #params => ::core::fmt::Display::fmt(&format!(#output, #args), f)
-                        }
+                if used_vars.is_empty() {
+                    quote! { #name::#ident #params => ::core::fmt::Display::fmt(#output, f) }
+                } else {
+                    let args: Punctuated<_, Token!(,)> = unnamed_fields
+                        .unnamed
+                        .iter()
+                        .enumerate()
+                        .map(|(index, field)| {
+                            assert!(field.ident.is_none());
+                            syn::parse_str::<Ident>(format!("field{}", index).as_str()).unwrap()
+                        })
+                        .collect();
+                    quote! {
+                        #[allow(unused_variables)]
+                        #name::#ident #params => ::core::fmt::Display::fmt(&format!(#output, #args), f)
                     }
                 }
-                Fields::Unit => {
-                    let used_vars = capture_format_strings(&output)?;
-                    if !used_vars.is_empty() {
-                        return Err(syn::Error::new_spanned(
-                            &output,
-                            "Unit variants do not support interpolation",
-                        ));
-                    }
-
-                    quote! { #name::#ident #params => ::core::fmt::Display::fmt(#output, f) }
+            }
+            Fields::Unit => {
+                let used_vars = capture_format_strings(&output)?;
+                if !used_vars.is_empty() {
+                    return Err(syn::Error::new_spanned(
+                        &output,
+                        "Unit variants do not support interpolation",
+                    ));
                 }
-            };
 
-            arms.push(arm);
-        }
+                quote! { #name::#ident #params => ::core::fmt::Display::fmt(#output, f) }
+            }
+        };
+
+        arms.push(arm);
     }
 
     if arms.len() < variants.len() {
@@ -157,14 +171,17 @@ pub fn display_inner(ast: &DeriveInput) -> syn::Result<TokenStream> {
 }
 
 fn capture_format_string_idents(string_literal: &LitStr) -> syn::Result<Vec<Ident>> {
-    capture_format_strings(string_literal)?.into_iter().map(|ident| {
-        syn::parse_str::<Ident>(ident.as_str()).map_err(|_| {
-            syn::Error::new_spanned(
-                string_literal,
-                "Invalid identifier inside format string bracket",
-            )
+    capture_format_strings(string_literal)?
+        .into_iter()
+        .map(|ident| {
+            syn::parse_str::<Ident>(ident.as_str()).map_err(|_| {
+                syn::Error::new_spanned(
+                    string_literal,
+                    "Invalid identifier inside format string bracket",
+                )
+            })
         })
-    }).collect()
+        .collect()
 }
 
 fn capture_format_strings(string_literal: &LitStr) -> syn::Result<Vec<String>> {