feat(divan_compat_macro): parse types argument

Author: GuillaumeLagrange

Cargo.lock

@@ -13,5 +13,6 @@ members = [
 resolver = "2"
 
 [workspace.dependencies]
+itertools = "0.14.0"
 serde = { version = "1.0.217", features = ["derive"] }
 serde_json = "1.0.138"

Cargo.toml

@@ -22,7 +22,7 @@ cargo_metadata = "0.19.1"
 clap = { version = "=4.5.17", features = ["derive", "env"] }
 termcolor = "1.4"
 anyhow = "1.0.86"
-itertools = "0.13.0"
+itertools = { workspace = true }
 anstyle = "1.0.8"
 serde = { workspace = true }
 serde_json = { workspace = true }

crates/cargo-codspeed/Cargo.toml

@@ -17,7 +17,7 @@ fn sub() -> i32 {
     black_box(2) - black_box(1)
 }
 
-#[divan::bench]
+#[divan::bench(max_time = 1)]
 fn mul() -> i32 {
     black_box(2) * black_box(1)
 }

crates/divan_compat/examples/benches/math.rs

@@ -22,6 +22,7 @@ proc-macro = true
 
 [dependencies]
 divan-macros = { version = "=0.1.17" }
+itertools = { workspace = true }
 proc-macro-crate = "3.2.0"
 proc-macro2 = "1"
 quote = { version = "1", default-features = false }
@@ -32,4 +33,5 @@ syn = { version = "^2.0.18", default-features = false, features = [
   "parsing",
   "printing",
   "proc-macro",
+  "extra-traits",
 ] }

crates/divan_compat/macros/Cargo.toml

@@ -0,0 +1,107 @@
+use itertools::Itertools;
+use proc_macro::TokenStream;
+use quote::{quote, ToTokens};
+use syn::{
+    parse::{Parse, Parser},
+    Expr, Meta, MetaNameValue, Token, Type,
+};
+
+/// Values from parsed options shared between `#[divan::bench]` and
+/// `#[divan::bench_group]`.
+///
+/// The `crate` option is not included because it is only needed to get proper
+/// access to `__private`.
+#[derive(Default)]
+pub(crate) struct AttrOptions {
+    pub(crate) types: Option<GenericTypes>,
+    pub(crate) crate_: bool,
+    pub(crate) other_args: Vec<Meta>,
+}
+
+#[allow(unreachable_code)]
+impl AttrOptions {
+    pub fn parse(tokens: TokenStream) -> Result<Self, TokenStream> {
+        let mut attr_options = Self::default();
+
+        let attr_parser = syn::meta::parser(|meta| {
+            let Some(ident) = meta.path.get_ident() else {
+                return Err(meta.error("Unexpected attribute"));
+            };
+
+            let ident_name = ident.to_string();
+            let ident_name = ident_name.strip_prefix("r#").unwrap_or(&ident_name);
+
+            match ident_name {
+                // Divan accepts type syntax that is not parseable into syn::Meta out of the box,
+                // so we parse and rebuild the arguments manually.
+                "types" => {
+                    attr_options.types = Some(meta.value()?.parse()?);
+                }
+                "crate" => {
+                    attr_options.crate_ = true;
+                    meta.value()?.parse::<Expr>()?; // Discard the value
+                }
+                "min_time" | "max_time" | "sample_size" | "sample_count" | "skip_ext_time" => {
+                    // These arguments are ignored for codspeed runs
+                    meta.value()?.parse::<Expr>()?; // Discard the value
+                }
+                _ => {
+                    let path = meta.path.clone();
+                    let parsed_meta = if meta.input.is_empty() {
+                        Meta::Path(path)
+                    } else {
+                        let value: syn::Expr = meta.value()?.parse()?;
+                        Meta::NameValue(MetaNameValue {
+                            path,
+                            eq_token: Default::default(),
+                            value: Expr::Verbatim(value.into_token_stream()),
+                        })
+                    };
+
+                    attr_options.other_args.push(parsed_meta);
+                }
+            }
+
+            Ok(())
+        });
+
+        match attr_parser.parse(tokens) {
+            Ok(()) => {}
+            Err(error) => return Err(error.into_compile_error().into()),
+        }
+
+        Ok(attr_options)
+    }
+}
+
+/// Generic types over which to instantiate benchmark functions.
+pub(crate) enum GenericTypes {
+    /// List of types, e.g. `[i32, String, ()]`.
+    List(Vec<proc_macro2::TokenStream>),
+}
+
+impl Parse for GenericTypes {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        let content;
+        syn::bracketed!(content in input);
+
+        Ok(Self::List(
+            content
+                .parse_terminated(Type::parse, Token![,])?
+                .into_iter()
+                .map(|ty| ty.into_token_stream())
+                .collect(),
+        ))
+    }
+}
+
+impl ToTokens for GenericTypes {
+    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+        match self {
+            Self::List(list) => {
+                let type_tokens = list.iter().cloned().map_into::<proc_macro2::TokenStream>();
+                tokens.extend(quote! { [ #(#type_tokens),* ] });
+            }
+        }
+    }
+}

crates/divan_compat/macros/src/args.rs

@@ -1,65 +1,25 @@
+mod args;
+
+use args::AttrOptions;
 use proc_macro::TokenStream;
 use proc_macro_crate::{crate_name, FoundCrate};
-use quote::{format_ident, quote};
-use syn::{
-    parse::Parse,
-    parse_macro_input,
-    punctuated::Punctuated,
-    ItemFn,
-    Meta::{self, NameValue},
-    MetaNameValue, Token,
-};
-
-struct MyBenchArgs {
-    args: Punctuated<Meta, Token![,]>,
-}
-
-impl Parse for MyBenchArgs {
-    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
-        Ok(Self {
-            args: Punctuated::parse_terminated(input)?,
-        })
-    }
-}
+use quote::{format_ident, quote, ToTokens};
+use syn::{parse_macro_input, Expr, ItemFn, Meta};
 
 #[proc_macro_attribute]
 pub fn bench_compat(attr: TokenStream, item: TokenStream) -> TokenStream {
-    let parsed_args = parse_macro_input!(attr as MyBenchArgs);
     let input = parse_macro_input!(item as ItemFn);
 
-    let mut filtered_args = Vec::new();
-
-    for arg in parsed_args.args {
-        match &arg {
-            NameValue(MetaNameValue { path, .. }) => {
-                if path.is_ident("crate") {
-                    return quote! {
-                        compile_error!("`crate` argument is not supported with codspeed_divan_compat");
-                    }.
-                    into();
-                }
-
-                if path.is_ident("types") {
-                    return quote! {
-                        compile_error!("`type` argument is not yet supported with codspeed_divan_compat");
-                    }
-                    .into();
-                }
-
-                if path.is_ident("min_time")
-                    || path.is_ident("max_time")
-                    || path.is_ident("sample_size")
-                    || path.is_ident("sample_count")
-                    || path.is_ident("skip_ext_time")
-                {
-                    // These arguments are ignored in instrumented mode
-                    continue;
-                }
+    let attr_options = match AttrOptions::parse(attr) {
+        Ok(attr_options) => attr_options,
+        Err(error) => return error,
+    };
 
-                filtered_args.push(arg);
-            }
-            _ => filtered_args.push(arg),
+    if attr_options.crate_ {
+        return quote! {
+            compile_error!("`crate` argument is yet supported with codspeed_divan_compat");
         }
+        .into();
     }
 
     let codspeed_divan_crate_ident = format_ident!(
@@ -72,10 +32,21 @@ pub fn bench_compat(attr: TokenStream, item: TokenStream) -> TokenStream {
             .unwrap_or("codspeed_divan_compat".to_string())
     );
 
-    filtered_args.push(syn::parse_quote!(crate = ::#codspeed_divan_crate_ident));
-    // Important: keep macro name in sync with re-exported macro name in divan-compat lib
+    let mut transfered_args = attr_options.other_args;
+
+    transfered_args.push(syn::parse_quote!(crate = ::#codspeed_divan_crate_ident));
+
+    if let Some(types) = attr_options.types {
+        transfered_args.push(Meta::NameValue(syn::MetaNameValue {
+            path: syn::parse_quote!(types),
+            eq_token: Default::default(),
+            value: Expr::Verbatim(types.into_token_stream()),
+        }));
+    }
+
+    // WARN: keep macro name in sync with re-exported macro name in divan-compat lib
     let expanded = quote! {
-        #[::#codspeed_divan_crate_ident::bench_original(#(#filtered_args),*)]
+        #[::#codspeed_divan_crate_ident::bench_original(#(#transfered_args),*)]
         #input
     };