feat(divan_fork): manage type and args in bench names

Author: GuillaumeLagrange

crates/divan_compat/divan_fork/src/divan.rs

@@ -311,21 +311,9 @@ impl Divan {
                 if should_compute_stats {
                     let stats = bench_context.compute_stats();
                     {
-                        // WARNING: Keep in sync with `codspeed-divan-compat::uri::generate`
-                        // Not worth doing the work of actually using the same code since this fork
-                        // is temporary
-                        let name = bench_entry.display_name().to_string();
-                        let file = bench_entry.meta().location.file;
-                        let mut module_path = bench_entry
-                            .meta()
-                            .module_path_components()
-                            .skip(1)
-                            .collect::<Vec<_>>()
-                            .join("::");
-                        if !module_path.is_empty() {
-                            module_path.push_str("::");
-                        }
-                        let uri = format!("{file}::{module_path}{name}");
+                        let CodspeedBench { bench_name, uri } =
+                            generate_codspeed_bench_name(&bench_entry, bench_display_name);
+
                         let iter_per_round = bench_context.samples.sample_size;
                         let times_ns: Vec<_> = bench_context
                             .samples
@@ -336,7 +324,7 @@ impl Divan {
                         let max_time_ns = options.max_time.map(|t| t.as_nanos());
                         ::codspeed::walltime::collect_raw_walltime_results(
                             "divan",
-                            name,
+                            bench_name,
                             uri,
                             iter_per_round,
                             max_time_ns,
@@ -383,6 +371,76 @@ impl Divan {
     }
 }
 
+struct CodspeedBench {
+    bench_name: String,
+    uri: String,
+}
+
+/// Generates a Codspeed benchmark name and URI
+///
+/// WARNING: Keep in sync with `codspeed-divan-compat::uri::generate`
+/// Not worth doing the work of actually using the same code since this fork
+/// is temporary
+fn generate_codspeed_bench_name(
+    bench_entry: &AnyBenchEntry,
+    closure_bench_display_name: &str,
+) -> CodspeedBench {
+    let bench_function_name = bench_entry.meta().display_name;
+
+    let (bench_type_name, bench_arg_name) = {
+        let bench_function_or_type_name = bench_entry.display_name().to_string();
+
+        let type_name = if bench_function_or_type_name == bench_function_name {
+            None
+        } else {
+            Some(bench_function_or_type_name)
+        };
+
+        let arg_name = match type_name.as_ref() {
+            None => {
+                if closure_bench_display_name == bench_function_name {
+                    None
+                } else {
+                    Some(closure_bench_display_name)
+                }
+            }
+            Some(type_name) => {
+                if closure_bench_display_name == type_name {
+                    None
+                } else {
+                    Some(closure_bench_display_name)
+                }
+            }
+        };
+
+        (type_name, arg_name)
+    };
+
+    let mut bench_name = bench_function_name.to_string();
+
+    match (bench_type_name, bench_arg_name) {
+        (None, None) => {}
+        (Some(type_name), None) => {
+            bench_name.push_str(format!("[{type_name}]").as_str());
+        }
+        (None, Some(arg_name)) => {
+            bench_name.push_str(format!("[{arg_name}]").as_str());
+        }
+        (Some(type_name), Some(arg_name)) => {
+            bench_name.push_str(format!("[{type_name}, {arg_name}]").as_str());
+        }
+    }
+
+    let file = bench_entry.meta().location.file;
+    let mut module_path =
+        bench_entry.meta().module_path_components().skip(1).collect::<Vec<_>>().join("::");
+    if !module_path.is_empty() {
+        module_path.push_str("::");
+    }
+    let uri = format!("{file}::{module_path}{bench_name}");
+    CodspeedBench { bench_name, uri }
+}
+
 /// Makes `Divan::skip_regex` input polymorphic.
 pub trait SkipRegex {
     fn skip_regex(self, divan: &mut Divan);