Fixes #18 Adds support for array parameter values

Attribution now supports parameters whose value is a collection of
parameters. The type used in the struct to support this behavior is a
Vec whose element types are any other supported parameter value type
(e.g. Vec<i64>).

As part of this effort, the code used to parse the attribute input
went through a major overhaul. This included implementing the 'Parse'
trait for the 'ParamVal' enum and no longer using the 'MetaList' from
the syn crate. These changes to the parsing logic will grant more
flexibility in the future for the types of syntax that can be parsed as
attribute input.

As part of the implementation of this feature, a new variant to the
'ParamVal' enum was also added. The 'Array' variant stores the value as
a Vec<ParamVal>. Theoretically this means that heterogenous array values
could be used in the future.

The following is an example of attribute args and the corresponding
usage of the attribute. NOTE: Pound signs omitted due to commit message
constraints.

[attr_args]
struct AttrArgs {
    vals: Vec<i64>
}

// ...

[my_attr(vals = [1, 2, 3])]
fn foo() {
    //...
}

As part of this effort, a new example crate was added that demonstrates
the usage of multiple types of parameters.

Author: chuck-flowers

Cargo.toml

@@ -4,5 +4,7 @@ members = [
     "attribution",
     "attribution-examples/ez-trace/ez-trace-macros",
     "attribution-examples/ez-trace/fibonacci",
+    "attribution-examples/exhaustive-attr/exhaustive-attr",
+    "attribution-examples/exhaustive-attr/exhaustive-attr-macros",
     "attribution-macros"
 ]

attribution-examples/exhaustive-attr/exhaustive-attr-macros/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "exhaustive-attr-macros"
+version = "0.1.0"
+authors = ["Timothy Flowers <[email protected]>"]
+edition = "2018"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+attribution = { path = "../../../attribution" }
+proc-macro2 = "^1.0.0"
+quote = "^1.0.0"
+syn = "^1.0.0"

attribution-examples/exhaustive-attr/exhaustive-attr-macros/src/lib.rs

@@ -0,0 +1,66 @@
+use attribution::attr_args;
+use proc_macro::TokenStream;
+use proc_macro2::Span;
+use quote::ToTokens;
+use syn::parse_macro_input;
+use syn::parse_quote;
+use syn::Expr;
+use syn::ItemFn;
+use syn::LitBool;
+use syn::LitFloat;
+use syn::LitInt;
+use syn::LitStr;
+use syn::Stmt;
+
+#[attr_args]
+struct AttributeArgs {
+    flag: bool,
+    string: String,
+    integer: i64,
+    float: f64,
+    array_of_integers: Vec<i64>,
+}
+
+#[proc_macro_attribute]
+pub fn exhaustive(attr: TokenStream, tagged: TokenStream) -> TokenStream {
+    let attr = parse_macro_input!(attr as AttributeArgs);
+    let mut item_fn = parse_macro_input!(tagged as ItemFn);
+    for stmt in make_print_lines(attr) {
+        item_fn.block.stmts.push(stmt)
+    }
+
+    item_fn.to_token_stream().into()
+}
+
+fn make_print_lines(attr: AttributeArgs) -> impl IntoIterator<Item = Stmt> {
+    let flag_val = LitBool {
+        value: attr.flag,
+        span: proc_macro2::Span::call_site(),
+    };
+    let string_val = LitStr::new(&attr.string, Span::call_site());
+    let integer_val = LitInt::new(&attr.integer.to_string(), Span::call_site());
+    let float_val = LitFloat::new(&attr.float.to_string(), Span::call_site());
+    let array_of_integers = attr
+        .array_of_integers
+        .into_iter()
+        .map(|i| i.to_string())
+        .map(|i| LitInt::new(&i, Span::call_site()));
+    let array_of_integers_val: Expr = parse_quote! { vec![#(#array_of_integers),*] };
+    vec![
+        parse_quote! {
+            println!("flag = {}", #flag_val);
+        },
+        parse_quote! {
+            println!("string = {}", #string_val);
+        },
+        parse_quote! {
+            println!("integer = {}", #integer_val);
+        },
+        parse_quote! {
+            println!("float = {}", #float_val);
+        },
+        parse_quote! {
+            println!("array_of_integers = {:?}", #array_of_integers_val);
+        },
+    ]
+}

attribution-examples/exhaustive-attr/exhaustive-attr/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "exhaustive-attr"
+version = "0.1.0"
+authors = ["Timothy Flowers <[email protected]>"]
+edition = "2018"
+
+[dependencies]
+exhaustive-attr-macros = { path = "../exhaustive-attr-macros" }

attribution-examples/exhaustive-attr/exhaustive-attr/src/main.rs

@@ -0,0 +1,6 @@
+use exhaustive_attr_macros::exhaustive;
+
+#[exhaustive(flag = true, string = "foo", integer = 1, float = 4.0, array_of_integers = [1, 2, 3])]
+fn main() {
+    println!("End of main!");
+}

attribution/Cargo.toml

@@ -15,3 +15,6 @@ attribution-macros = { version = "0.3.0", path = "../attribution-macros" }
 proc-macro2 = "^1.0.0"
 quote = "^1.0.0"
 syn = { version = "^1.0.0", features = ["full"] }
+
+[dev-dependencies]
+syn = { version = "^1.0.0", features = ["full", "extra-traits"] }

attribution/src/conversion.rs

@@ -1,69 +1,16 @@
 use crate::params::ParamKey;
 use crate::params::ParamVal;
 use crate::Parameters;
-
-/// An error that occurs as a result of a failed conversion of a `ParameterVal`
-#[derive(Debug)]
-pub enum FromParameterValueError {
-    /// The data that was being attempted for conversion was not of the expected type.
-    UnexpectedType,
-}
-
-/// A trait that is used to create a type from a provided `ParamVal`. This
-/// trait should be implemented when a type should be able to be converted from
-/// a single `ParamVal` type.
-///
-/// # Example
-/// ```
-/// use attribution::FromParameterValue;
-/// use attribution::ParamVal;
-///
-/// let param_val = ParamVal::Bool(true);
-/// let from_result = bool::from_parameter_value(param_val);
-/// assert_eq!(from_result.unwrap(), true);
-/// ```
-pub trait FromParameterValue: Sized {
-    /// Tries to create a type from the provided `ParamVal`
-    fn from_parameter_value(parameter_val: ParamVal) -> Result<Self, FromParameterValueError>;
-}
-
-impl FromParameterValue for u64 {
-    fn from_parameter_value(parameter_val: ParamVal) -> Result<Self, FromParameterValueError> {
-        if let ParamVal::UnsignedInt(val) = parameter_val {
-            Ok(val)
-        } else {
-            Err(FromParameterValueError::UnexpectedType)
-        }
-    }
-}
-
-impl FromParameterValue for bool {
-    fn from_parameter_value(parameter_val: ParamVal) -> Result<Self, FromParameterValueError> {
-        if let ParamVal::Bool(val) = parameter_val {
-            Ok(val)
-        } else {
-            Err(FromParameterValueError::UnexpectedType)
-        }
-    }
-}
-
-impl FromParameterValue for String {
-    fn from_parameter_value(parameter_val: ParamVal) -> Result<Self, FromParameterValueError> {
-        if let ParamVal::Str(val) = parameter_val {
-            Ok(val)
-        } else {
-            Err(FromParameterValueError::UnexpectedType)
-        }
-    }
-}
+use core::convert::TryFrom;
+use core::convert::TryInto;
 
 /// An error that occurs as a result of a failed conversion of a `Parameters`
 /// struct
 #[derive(Debug)]
-pub enum FromParametersError {
+pub enum FromParametersError<'a> {
     /// Indicates the error ocurred because a value for a specified parameter
     /// was not supplied.
-    MissingParam { param_name: ParamKey },
+    MissingParam { param_key: &'a ParamKey },
 
     /// Indicates the error occurred because the value that was attempted for conversion
     /// was for the incorrect type.
@@ -74,35 +21,73 @@ pub enum FromParametersError {
 pub trait FromParameters: Sized {
     /// Try to create a type from a parameter struct (`params`) for a paramter
     /// of a specific name (`param_name`).
-    fn from_parameters(
+    fn from_parameters<'a>(
         params: &mut Parameters,
-        param_name: &ParamKey,
-    ) -> Result<Self, FromParametersError>;
+        param_key: &'a ParamKey,
+    ) -> Result<Self, FromParametersError<'a>>;
 }
 
-impl<T: FromParameterValue> FromParameters for T {
-    fn from_parameters(
+impl<T> FromParameters for T
+where
+    T: TryFrom<ParamVal>,
+{
+    fn from_parameters<'a>(
         params: &mut Parameters,
-        param_name: &ParamKey,
-    ) -> Result<Self, FromParametersError> {
-        if let Some(parameter_val) = params.remove(&param_name.to_owned().into()) {
-            T::from_parameter_value(parameter_val).map_err(|err| match err {
-                FromParameterValueError::UnexpectedType => FromParametersError::UnexpectedType,
-            })
+        param_key: &'a ParamKey,
+    ) -> Result<Self, FromParametersError<'a>> {
+        if let Some(param_val) = params.remove(param_key) {
+            T::try_from(param_val).map_err(|_| FromParametersError::UnexpectedType)
         } else {
-            Err(FromParametersError::MissingParam {
-                param_name: param_name.clone(),
-            })
+            Err(FromParametersError::MissingParam { param_key })
         }
     }
 }
 
-impl<T: FromParameters> FromParameters for Option<T> {
-    fn from_parameters(
+impl FromParameters for Option<bool> {
+    fn from_parameters<'a>(
         params: &mut Parameters,
-        param_name: &ParamKey,
-    ) -> Result<Self, FromParametersError> {
-        Ok(T::from_parameters(params, param_name).ok())
+        param_key: &'a ParamKey,
+    ) -> Result<Self, FromParametersError<'a>> {
+        Ok(params
+            .remove(param_key)
+            .map(|val| val.try_into().ok())
+            .flatten())
+    }
+}
+
+impl FromParameters for Option<i64> {
+    fn from_parameters<'a>(
+        params: &mut Parameters,
+        param_key: &'a ParamKey,
+    ) -> Result<Self, FromParametersError<'a>> {
+        Ok(params
+            .remove(param_key)
+            .map(|val| val.try_into().ok())
+            .flatten())
+    }
+}
+
+impl FromParameters for Option<f64> {
+    fn from_parameters<'a>(
+        params: &mut Parameters,
+        param_key: &'a ParamKey,
+    ) -> Result<Self, FromParametersError<'a>> {
+        Ok(params
+            .remove(param_key)
+            .map(|val| val.try_into().ok())
+            .flatten())
+    }
+}
+
+impl FromParameters for Option<String> {
+    fn from_parameters<'a>(
+        params: &mut Parameters,
+        param_key: &'a ParamKey,
+    ) -> Result<Self, FromParametersError<'a>> {
+        Ok(params
+            .remove(param_key)
+            .map(|val| val.try_into().ok())
+            .flatten())
     }
 }
 
@@ -116,16 +101,18 @@ mod tests {
     fn from_parameters_bool() {
         let mut params = Parameters::default();
         params.insert("foo".into(), ParamVal::Bool(true));
-        let output = bool::from_parameters(&mut params, &"foo".into());
+        let param_key = "foo".into();
+        let output = bool::from_parameters(&mut params, &param_key);
 
         assert_eq!(output.unwrap(), true);
     }
 
     #[test]
     fn from_parameters_str() {
         let mut params = Parameters::default();
-        params.insert("foo".into(), ParamVal::UnsignedInt(1));
-        let output = u64::from_parameters(&mut params, &"foo".into());
+        params.insert("foo".into(), ParamVal::Int(1));
+        let param_key = "foo".into();
+        let output = i64::from_parameters(&mut params, &param_key);
 
         assert_eq!(output.unwrap(), 1);
     }
@@ -134,7 +121,8 @@ mod tests {
     fn from_parameters_int() {
         let mut params = Parameters::default();
         params.insert("foo".into(), ParamVal::Str("bar".into()));
-        let output = String::from_parameters(&mut params, &"foo".into());
+        let param_key = "foo".into();
+        let output = String::from_parameters(&mut params, &param_key);
 
         let right: String = "bar".into();
         assert_eq!(output.unwrap(), right);
@@ -144,33 +132,36 @@ mod tests {
     fn from_parameters_bool_option() {
         let mut params = Parameters::default();
         params.insert("foo".into(), ParamVal::Bool(true));
-        let output = Option::<bool>::from_parameters(&mut params, &"foo".into());
+        let param_key = "foo".into();
+        let output = Option::<bool>::from_parameters(&mut params, &param_key);
 
         assert_eq!(output.unwrap(), Some(true));
-        let no_output = Option::<bool>::from_parameters(&mut params, &"foo".into());
+        let no_output = Option::<bool>::from_parameters(&mut params, &param_key);
         assert_eq!(no_output.unwrap(), None);
     }
 
     #[test]
     fn from_parameters_str_option() {
         let mut params = Parameters::default();
-        params.insert("foo".into(), ParamVal::UnsignedInt(1));
-        let output = Option::<u64>::from_parameters(&mut params, &"foo".into());
+        params.insert("foo".into(), ParamVal::Int(1));
+        let param_key = "foo".into();
+        let output = Option::<i64>::from_parameters(&mut params, &param_key);
 
         assert_eq!(output.unwrap(), Some(1));
-        let no_output = Option::<u64>::from_parameters(&mut params, &"foo".into());
+        let no_output = Option::<i64>::from_parameters(&mut params, &param_key);
         assert_eq!(no_output.unwrap(), None);
     }
 
     #[test]
     fn from_parameters_int_option() {
         let mut params = Parameters::default();
-        params.insert("foo".into(), ParamVal::Str("bar".into()));
-        let output = Option::<String>::from_parameters(&mut params, &"foo".into());
+        params.insert("foo".into(), "bar".into());
+        let param_key = "foo".into();
+        let output = Option::<String>::from_parameters(&mut params, &param_key);
 
         let right: String = "bar".into();
         assert_eq!(output.unwrap(), Some(right));
-        let no_output = Option::<String>::from_parameters(&mut params, &"foo".into());
+        let no_output = Option::<String>::from_parameters(&mut params, &param_key);
         assert_eq!(no_output.unwrap(), None);
     }
 }

attribution/src/lib.rs

@@ -5,8 +5,6 @@ mod conversion;
 mod params;
 
 pub use attribution_macros::attr_args;
-pub use conversion::FromParameterValue;
-pub use conversion::FromParameterValueError;
 pub use conversion::FromParameters;
 pub use conversion::FromParametersError;
 pub use params::DynamicParameters;