Adding support for int and bool EnumProperties

strum/src/lib.rs

@@ -136,9 +136,9 @@ pub trait EnumMessage {
 
 /// `EnumProperty` is a trait that makes it possible to store additional information
 /// with enum variants. This trait is designed to be used with the macro of the same
-/// name in the `strum_macros` crate. Currently, the only string literals are supported
-/// in attributes, the other methods will be implemented as additional attribute types
-/// become stabilized.
+/// name in the `strum_macros` crate. Currently, string, integer and boolean literals
+/// are supported in attributes, the other methods will be implemented as additional
+/// attribute types become stabilized.
 ///
 /// # Example
 ///
@@ -152,24 +152,22 @@ pub trait EnumMessage {
 ///     #[strum(props(Teacher="Ms.Frizzle", Room="201"))]
 ///     History,
 ///     #[strum(props(Teacher="Mr.Smith"))]
-///     #[strum(props(Room="103"))]
+///     #[strum(props(Room=103))]
 ///     Mathematics,
 ///     #[strum(props(Time="2:30"))]
 ///     Science,
 /// }
 ///
 /// let history = Class::History;
 /// assert_eq!("Ms.Frizzle", history.get_str("Teacher").unwrap());
+/// let maths = Class::Mathematics;
+/// assert_eq!(103, maths.get_int("Room").unwrap());
 /// ```
 pub trait EnumProperty {
     fn get_str(&self, prop: &str) -> Option<&'static str>;
-    fn get_int(&self, _prop: &str) -> Option<usize> {
-        Option::None
-    }
+    fn get_int(&self, prop: &str) -> Option<usize>;
 
-    fn get_bool(&self, _prop: &str) -> Option<bool> {
-        Option::None
-    }
+    fn get_bool(&self, prop: &str) -> Option<bool>;
 }
 
 /// A cheap reference-to-reference conversion. Used to convert a value to a

strum_macros/src/helpers/metadata.rs

@@ -10,6 +10,7 @@ use syn::{
 };
 
 use super::case_style::CaseStyle;
+use super::PropertyValue;
 
 pub mod kw {
     use syn::custom_keyword;
@@ -184,7 +185,7 @@ pub enum VariantMeta {
     },
     Props {
         kw: kw::props,
-        props: Vec<(LitStr, LitStr)>,
+        props: Vec<(LitStr, PropertyValue)>,
     },
 }
 
@@ -242,15 +243,22 @@ impl Parse for VariantMeta {
     }
 }
 
-struct Prop(Ident, LitStr);
+struct Prop(Ident, PropertyValue);
 
 impl Parse for Prop {
     fn parse(input: ParseStream) -> syn::Result<Self> {
         use syn::ext::IdentExt;
 
         let k = Ident::parse_any(input)?;
         let _: Token![=] = input.parse()?;
-        let v = input.parse()?;
+        let v;
+        if input.peek(syn::LitBool) {
+            v = PropertyValue::Bool(input.parse()?);
+        } else if input.peek(syn::LitInt) {
+            v = PropertyValue::Num(input.parse()?);
+        } else {
+            v = PropertyValue::Str(input.parse()?);
+        };
 
         Ok(Prop(k, v))
     }

strum_macros/src/helpers/mod.rs

@@ -30,3 +30,20 @@ pub fn occurrence_error<T: ToTokens>(fst: T, snd: T, attr: &str) -> syn::Error {
     e.combine(syn::Error::new_spanned(fst, "first one here"));
     e
 }
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum PropertyValue {
+    Str(syn::LitStr),
+    Num(syn::LitInt),
+    Bool(syn::LitBool),
+}
+
+impl quote::ToTokens for PropertyValue {
+    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+        match self {
+            PropertyValue::Str(s) => s.to_tokens(tokens),
+            PropertyValue::Num(n) => n.to_tokens(tokens),
+            PropertyValue::Bool(b) => b.to_tokens(tokens),
+        }
+    }
+}

strum_macros/src/helpers/variant_props.rs

@@ -4,6 +4,7 @@ use syn::{Ident, LitStr, Variant};
 use super::case_style::{CaseStyle, CaseStyleHelpers};
 use super::metadata::{kw, VariantExt, VariantMeta};
 use super::occurrence_error;
+use super::PropertyValue;
 
 pub trait HasStrumVariantProperties {
     fn get_variant_properties(&self) -> syn::Result<StrumVariantProperties>;
@@ -17,7 +18,7 @@ pub struct StrumVariantProperties {
     pub message: Option<LitStr>,
     pub detailed_message: Option<LitStr>,
     pub documentation: Vec<LitStr>,
-    pub string_props: Vec<(LitStr, LitStr)>,
+    pub string_props: Vec<(LitStr, PropertyValue)>,
     serialize: Vec<LitStr>,
     to_string: Option<LitStr>,
     ident: Option<Ident>,

strum_macros/src/lib.rs

@@ -560,12 +560,12 @@ pub fn enum_messages(input: proc_macro::TokenStream) -> proc_macro::TokenStream
 /// Add custom properties to enum variants.
 ///
 /// Enables the encoding of arbitary constants into enum variants. This method
-/// currently only supports adding additional string values. Other types of literals are still
-/// experimental in the rustc compiler. The generated code works by nesting match statements.
-/// The first match statement matches on the type of the enum, and the inner match statement
-/// matches on the name of the property requested. This design works well for enums with a small
-/// number of variants and properties, but scales linearly with the number of variants so may not
-/// be the best choice in all situations.
+/// currently only supports adding additional string, integer and boolean values. Other types
+/// of literals are still experimental in the rustc compiler. The generated code works by
+/// nesting match statements. The first match statement matches on the type of the enum,
+/// and the inner match statement matches on the name of the property requested. This design
+/// works well for enums with a small number of variants and properties, but scales linearly
+/// with the number of variants so may not be the best choice in all situations.
 ///
 /// ```
 ///

strum_macros/src/macros/enum_properties.rs

@@ -2,6 +2,7 @@ use proc_macro2::TokenStream;
 use quote::quote;
 use syn::{Data, DeriveInput, Fields};
 
+use crate::helpers::PropertyValue;
 use crate::helpers::{non_enum_error, HasStrumVariantProperties, HasTypeProperties};
 
 pub fn enum_properties_inner(ast: &DeriveInput) -> syn::Result<TokenStream> {
@@ -14,7 +15,9 @@ pub fn enum_properties_inner(ast: &DeriveInput) -> syn::Result<TokenStream> {
     let type_properties = ast.get_type_properties()?;
     let strum_module_path = type_properties.crate_module_path();
 
-    let mut arms = Vec::new();
+    let mut string_props = Vec::new();
+    let mut num_props = Vec::new();
+    let mut bool_props = Vec::new();
     for variant in variants {
         let ident = &variant.ident;
         let variant_properties = variant.get_variant_properties()?;
@@ -33,31 +36,71 @@ pub fn enum_properties_inner(ast: &DeriveInput) -> syn::Result<TokenStream> {
         };
 
         for (key, value) in variant_properties.string_props {
-            string_arms.push(quote! { #key => ::core::option::Option::Some( #value )});
+            match value {
+                PropertyValue::Str(s) => {
+                    string_arms.push(quote! { #key => ::core::option::Option::Some( #s )})
+                }
+                PropertyValue::Num(n) => {
+                    num_arms.push(quote! { #key => ::core::option::Option::Some( #n )})
+                }
+                PropertyValue::Bool(b) => {
+                    bool_arms.push(quote! { #key => ::core::option::Option::Some( #b )})
+                }
+            }
         }
 
         string_arms.push(quote! { _ => ::core::option::Option::None });
         bool_arms.push(quote! { _ => ::core::option::Option::None });
         num_arms.push(quote! { _ => ::core::option::Option::None });
 
-        arms.push(quote! {
+        string_props.push(quote! {
             &#name::#ident #params => {
                 match prop {
                     #(#string_arms),*
                 }
             }
         });
+        bool_props.push(quote! {
+            &#name::#ident #params => {
+                match prop {
+                    #(#bool_arms),*
+                }
+            }
+        });
+        num_props.push(quote! {
+            &#name::#ident #params => {
+                match prop {
+                    #(#num_arms),*
+                }
+            }
+        });
     }
 
-    if arms.len() < variants.len() {
-        arms.push(quote! { _ => ::core::option::Option::None });
+    if string_props.len() < variants.len() {
+        string_props.push(quote! { _ => ::core::option::Option::None });
+    }
+    if bool_props.len() < variants.len() {
+        bool_props.push(quote! { _ => ::core::option::Option::None });
+    }
+    if num_props.len() < variants.len() {
+        num_props.push(quote! { _ => ::core::option::Option::None });
     }
 
     Ok(quote! {
         impl #impl_generics #strum_module_path::EnumProperty for #name #ty_generics #where_clause {
             fn get_str(&self, prop: &str) -> ::core::option::Option<&'static str> {
                 match self {
-                    #(#arms),*
+                    #(#string_props),*
+                }
+            }
+            fn get_bool(&self, prop: &str) -> ::core::option::Option<bool> {
+                match self {
+                    #(#bool_props),*
+                }
+            }
+            fn get_int(&self, prop: &str) -> ::core::option::Option<usize> {
+                match self {
+                    #(#num_props),*
                 }
             }
         }

strum_tests/tests/enum_props.rs

@@ -39,9 +39,16 @@ fn crate_module_path_test() {
     enum Test {
         #[strum(props(key = "value"))]
         A,
+        #[strum(props(answer = 42))]
         B,
+        #[strum(props(to_be = false))]
+        C,
     }
 
     let a = Test::A;
     assert_eq!("value", a.get_str("key").unwrap());
+    let b = Test::B;
+    assert_eq!(42, b.get_int("answer").unwrap());
+    let c = Test::C;
+    assert_eq!(false, c.get_bool("to_be").unwrap());
 }