Merge pull request #15 from chuck-flowers/v0.3.0

v0.3.0

Author: chuck-flowers

attribution-examples/ez-trace/ez-trace-macros/src/lib.rs

@@ -2,13 +2,23 @@ extern crate proc_macro;
 
 use attribution::attr_args;
 use proc_macro::TokenStream;
-use syn::ItemFn;
-use syn::parse_macro_input;
+use proc_macro2::Span;
 use quote::quote;
+use syn::parse_macro_input;
 use syn::parse_quote;
+use syn::punctuated::Punctuated;
+use syn::FnArg;
+use syn::ItemFn;
+use syn::LitStr;
+use syn::Pat;
 
 #[attr_args]
-struct EzTraceArgs {}
+enum EzTraceArgs {
+    StartAndEnd { start: String, end: String },
+    Start { start: String },
+    End { end: String },
+    Silent,
+}
 
 #[proc_macro_attribute]
 pub fn ez_trace(attr: TokenStream, tagged: TokenStream) -> TokenStream {
@@ -18,20 +28,97 @@ pub fn ez_trace(attr: TokenStream, tagged: TokenStream) -> TokenStream {
 
     (quote! {
         #function
-    }).into()
+    })
+    .into()
 }
 
-fn wrap_function(function: &mut ItemFn, _: &EzTraceArgs) {
-    let function_name = function.sig.ident.to_string();
-    let function_name_lit = syn::LitStr::new(&function_name, proc_macro2::Span::call_site());
-    let body = &function.block;
-    let new_body: syn::Block = parse_quote! {
-        {
-            let result = #body;
-            println!("{}: {}", #function_name_lit, result);
-            result
-        }
+fn wrap_function(function: &mut ItemFn, attr: &EzTraceArgs) {
+    fn make_template(msg: Option<&String>) -> Option<syn::LitStr> {
+        msg.as_ref()
+            .map(|template| syn::LitStr::new(template, Span::call_site()))
+    }
+
+    // Get the name of the function
+    let name = LitStr::new(&function.sig.ident.to_string(), Span::call_site());
+
+    // Build the comma separated list of arg names
+    let args: Punctuated<_, syn::Token![,]> = function
+        .sig
+        .inputs
+        .iter()
+        .map(|input| match input {
+            FnArg::Receiver(_) => quote! { &self },
+            FnArg::Typed(pat_type) => match pat_type.pat.as_ref() {
+                Pat::Ident(pat_ident) => {
+                    let ident = &pat_ident.ident;
+                    quote! { &#ident }
+                }
+                _ => panic!("Only simple parameter types are supported"),
+            },
+        })
+        .collect();
+
+    // Create the template that is used to format the args
+    let mut arg_templates = if args.is_empty() {
+        String::from("")
+    } else {
+        String::from("{}")
     };
 
-    function.block = Box::new(new_body);
-}
+    for _ in args.iter().skip(1) {
+        arg_templates.push_str(", {}");
+    }
+
+    // Build the string builder which will be used at runtime
+    let arg_templates = LitStr::new(&arg_templates, Span::call_site());
+    let args = quote! {
+        format!(#arg_templates, #args);
+    };
+
+    let start_param_val = match attr {
+        EzTraceArgs::StartAndEnd { start, .. } => Some(start),
+        EzTraceArgs::Start { start } => Some(start),
+        _ => None,
+    };
+
+    let end_param_val = match attr {
+        EzTraceArgs::StartAndEnd { end, .. } => Some(end),
+        EzTraceArgs::End { end } => Some(end),
+        _ => None,
+    };
+
+    // Create the start message if one has been defined
+    let start_msg = make_template(start_param_val)
+        .map(|template| {
+            quote! {
+                let args = #args;
+                println!(#template, name = #name, args = args);
+            }
+        })
+        .unwrap_or_default();
+
+    // Create the end message if one has been defined
+    let end_msg = make_template(end_param_val)
+        .map(|template| {
+            quote! {
+                let args = #args;
+                println!(#template, name = #name, args = args, result = result);
+            }
+        })
+        .unwrap_or_default();
+
+    // Wrap the old body with the messages if either are defined
+    if !start_msg.is_empty() || !end_msg.is_empty() {
+        let body = &function.block;
+        let new_body: syn::Block = parse_quote! {
+            {
+                #start_msg
+                let result = #body;
+                #end_msg
+                result
+            }
+        };
+
+        function.block = Box::new(new_body);
+    }
+}

attribution-examples/ez-trace/fibonacci/src/main.rs

@@ -6,11 +6,11 @@ fn main() {
     println!("Finished");
 }
 
-#[ez_trace]
+#[ez_trace(start = "{name}({args})", end = "{name}({args}) -> {result}")]
 fn fibonacci(n: u32) -> u32 {
     if n == 0 || n == 1 {
         n
     } else {
         fibonacci(n - 1) + fibonacci(n - 2)
     }
-}
+}

attribution-macros/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "attribution-macros"
-version = "0.2.1"
+version = "0.3.0"
 authors = ["Timothy Flowers <[email protected]>"]
 description = "The macros used by the attribution crate"
 categories = ["development-tools::procedural-macro-helpers"]

attribution-macros/src/construction.rs

@@ -0,0 +1,125 @@
+use crate::identifiers::build_unnamed_idents;
+use proc_macro2::TokenStream as TokenStream2;
+use quote::quote;
+use syn::parse_quote;
+use syn::punctuated::Punctuated;
+use syn::Expr;
+use syn::Fields;
+use syn::FieldsNamed;
+use syn::FieldsUnnamed;
+use syn::Ident;
+use syn::ItemStruct;
+use syn::Token;
+use syn::Variant;
+
+pub fn build_struct_constructor(input_struct: &ItemStruct) -> TokenStream2 {
+    let struct_name = &input_struct.ident;
+
+    let ctor_body = match &input_struct.fields {
+        Fields::Named(named) => named_constructor_body(named),
+        Fields::Unnamed(unnamed) => unnamed_constructor_body(unnamed),
+        Fields::Unit => quote! { {} },
+    };
+
+    quote! {
+        Ok(#struct_name #ctor_body)
+    }
+}
+
+pub fn build_variant_constructor(enum_name: &Ident, variant: &Variant) -> Expr {
+    let variant_name = &variant.ident;
+
+    let constructor_body = match &variant.fields {
+        Fields::Named(named) => named_constructor_body(named),
+        Fields::Unnamed(unnamed) => unnamed_constructor_body(unnamed),
+        Fields::Unit => quote! { {} },
+    };
+
+    parse_quote! {
+        Ok(#enum_name::#variant_name #constructor_body)
+    }
+}
+
+/// Builds the constructor body for a struct with named fields.
+fn named_constructor_body(FieldsNamed { named, .. }: &FieldsNamed) -> TokenStream2 {
+    let idents: Punctuated<&Ident, Token![,]> =
+        named.iter().map(|el| el.ident.as_ref().unwrap()).collect();
+    quote! { { #idents } }
+}
+
+/// Builds the constructor body for a struct with unnamed fields.
+fn unnamed_constructor_body(FieldsUnnamed { unnamed, .. }: &FieldsUnnamed) -> TokenStream2 {
+    let idents: Punctuated<Ident, Token![,]> = build_unnamed_idents(unnamed.len()).collect();
+    quote! { (#idents) }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+    use quote::ToTokens;
+
+    #[test]
+    fn build_struct_constructor_test() {
+        let input_struct = parse_quote! {
+            struct Foo {
+                a: u32,
+                b: String,
+                c: bool
+            }
+        };
+
+        let actual = build_struct_constructor(&input_struct);
+        let expected = quote! {
+            Ok(Foo { a, b, c })
+        };
+
+        assert_eq!(expected.to_string(), actual.to_string());
+    }
+
+    #[test]
+    fn build_variant_constructor_test() {
+        let enum_ident: Ident = parse_quote! { EnumName };
+        let variant = parse_quote! {
+            Foo (u32, String, bool)
+        };
+
+        let actual = build_variant_constructor(&enum_ident, &variant);
+        let expected: Expr = parse_quote! {
+            EnumName::Foo(_0, _1, _2)
+        };
+
+        assert_eq!(
+            expected.to_token_stream().to_string(),
+            actual.to_token_stream().to_string()
+        );
+    }
+
+    #[test]
+    fn named_constructor_body_test() {
+        let fields_named = parse_quote! {
+            { a: u32, b: String, c: bool }
+        };
+
+        let actual = named_constructor_body(&fields_named);
+        let expected = quote! {
+            { a, b, c }
+        };
+
+        assert_eq!(expected.to_string(), actual.to_string());
+    }
+
+    #[test]
+    fn unnamed_constructor_body_test() {
+        let fields_unnamed = parse_quote! {
+            (u32, String, bool)
+        };
+
+        let actual = unnamed_constructor_body(&fields_unnamed);
+        let expected = quote! {
+            (_0, _1, _2)
+        };
+
+        assert_eq!(expected.to_string(), actual.to_string());
+    }
+}