Display args values via Debug if no ToString

This abuses inherent impls having priority over trait impls when the
compiler chooses which `to_string` method to invoke.

Author: nvzqz

CHANGELOG.md

@@ -10,6 +10,21 @@ Versioning](http://semver.org/spec/v2.0.0.html).
 
 ### Added
 
+- Display [`args`] option values with [`Debug`] instead if [`ToString`] is not
+  implemented.
+
+  This makes it simple to use enums with derived [`Debug`]:
+
+  ```rs
+  #[derive(Debug)]
+  enum Arg { A, B }
+
+  #[divan::bench(args = [Arg::A, Arg::B])]
+  fn bench_args(arg: &Arg) {
+      ...
+  }
+  ```
+
 - Documentation of when to use [`black_box`] in benchmarks.
 
 ## [0.1.11] - 2024-01-20
@@ -50,15 +65,6 @@ Versioning](http://semver.org/spec/v2.0.0.html).
   - It does not increase compile times, unlike [`consts`] which needs to
     generate new code for each constant used.
 
-[`args`]: https://docs.rs/divan/latest/divan/attr.bench.html#args
-[`consts`]: https://docs.rs/divan/latest/divan/attr.bench.html#consts
-
-[`Any`]: https://doc.rust-lang.org/std/any/trait.Any.html
-[`Copy`]: https://doc.rust-lang.org/std/marker/trait.Copy.html
-[`Send`]: https://doc.rust-lang.org/std/marker/trait.Send.html
-[`Sync`]: https://doc.rust-lang.org/std/marker/trait.Sync.html
-[`ToString`]: https://doc.rust-lang.org/std/string/trait.ToString.html
-
 ## [0.1.8] - 2023-12-19
 
 ### Changes
@@ -257,10 +263,18 @@ Initial release. See [blog post](https://nikolaivazquez.com/blog/divan/).
 [0.1.1]: https://github.com/nvzqz/divan/compare/v0.1.0...v0.1.1
 
 [`AllocProfiler`]: https://docs.rs/divan/0.1/divan/struct.AllocProfiler.html
+[`args`]: https://docs.rs/divan/latest/divan/attr.bench.html#args
 [`black_box`]: https://docs.rs/divan/latest/divan/fn.black_box.html
+[`consts`]: https://docs.rs/divan/latest/divan/attr.bench.html#consts
 
+[`Any`]: https://doc.rust-lang.org/std/any/trait.Any.html
+[`Copy`]: https://doc.rust-lang.org/std/marker/trait.Copy.html
+[`Debug`]: https://doc.rust-lang.org/std/fmt/trait.Debug.html
 [`Drop`]: https://doc.rust-lang.org/std/ops/trait.Drop.html
 [`Iterator`]: https://doc.rust-lang.org/std/iter/trait.Iterator.html
+[`Send`]: https://doc.rust-lang.org/std/marker/trait.Send.html
+[`Sync`]: https://doc.rust-lang.org/std/marker/trait.Sync.html
+[`ToString`]: https://doc.rust-lang.org/std/string/trait.ToString.html
 [available parallelism]: https://doc.rust-lang.org/std/thread/fn.available_parallelism.html
 [drop_fn]: https://doc.rust-lang.org/std/mem/fn.drop.html
 [`thread_local!`]: https://doc.rust-lang.org/std/macro.thread_local.html

macros/src/lib.rs

@@ -247,6 +247,8 @@ pub fn bench(options: TokenStream, item: TokenStream) -> TokenStream {
                 #bench_entry_runner::Args(|| __DIVAN_ARGS.runner(
                     || #arg_return_tokens { #args },
 
+                    |arg| #private_mod::ToStringHelper(arg).to_string(),
+
                     |divan, __divan_arg| divan.bench(|| #fn_expr(
                         #private_mod::Arg::<#last_arg_type_tokens>::get(__divan_arg)
                     )),
@@ -258,6 +260,8 @@ pub fn bench(options: TokenStream, item: TokenStream) -> TokenStream {
                 #bench_entry_runner::Args(|| __DIVAN_ARGS.runner(
                     || #arg_return_tokens { #args },
 
+                    |arg| #private_mod::ToStringHelper(arg).to_string(),
+
                     |divan, __divan_arg| #fn_expr(
                         divan,
                         #private_mod::Arg::<#last_arg_type_tokens>::get(__divan_arg),

src/bench/args.rs

@@ -58,11 +58,12 @@ impl BenchArgs {
     pub fn runner<I, B>(
         &'static self,
         make_args: impl FnOnce() -> I,
+        arg_to_string: impl Fn(&I::Item) -> String,
         _bench_impl: B,
     ) -> BenchArgsRunner
     where
         I: IntoIterator,
-        I::Item: Any + ToString + Send + Sync,
+        I::Item: Any + Send + Sync,
         B: FnOnce(Bencher, &I::Item) + Copy,
     {
         let args = self.args.get_or_init(|| {
@@ -90,7 +91,7 @@ impl BenchArgs {
                                 return arg;
                             }
 
-                            Box::leak(arg.to_string().into_boxed_str())
+                            Box::leak(arg_to_string(arg).into_boxed_str())
                         })
                         .collect(),
                 )
@@ -205,7 +206,7 @@ mod tests {
         fn str() {
             static ARGS: BenchArgs = BenchArgs::new();
 
-            let runner = ARGS.runner(|| ["a", "b"], |_, _| {});
+            let runner = ARGS.runner(|| ["a", "b"], ToString::to_string, |_, _| {});
 
             let typed_args = runner.args.typed_args::<&str>().unwrap();
             let names = runner.arg_names();
@@ -219,7 +220,8 @@ mod tests {
         fn string() {
             static ARGS: BenchArgs = BenchArgs::new();
 
-            let runner = ARGS.runner(|| ["a".to_owned(), "b".to_owned()], |_, _| {});
+            let runner =
+                ARGS.runner(|| ["a".to_owned(), "b".to_owned()], ToString::to_string, |_, _| {});
 
             let typed_args = runner.args.typed_args::<String>().unwrap();
             let names = runner.arg_names();
@@ -234,6 +236,7 @@ mod tests {
 
             let runner = ARGS.runner(
                 || ["a".to_owned().into_boxed_str(), "b".to_owned().into_boxed_str()],
+                ToString::to_string,
                 |_, _| {},
             );
 
@@ -248,8 +251,11 @@ mod tests {
         fn cow_str() {
             static ARGS: BenchArgs = BenchArgs::new();
 
-            let runner =
-                ARGS.runner(|| [Cow::Owned("a".to_owned()), Cow::Borrowed("b")], |_, _| {});
+            let runner = ARGS.runner(
+                || [Cow::Owned("a".to_owned()), Cow::Borrowed("b")],
+                ToString::to_string,
+                |_, _| {},
+            );
 
             let typed_args = runner.args.typed_args::<Cow<str>>().unwrap();
             let names = runner.arg_names();

src/lib.rs

@@ -358,22 +358,15 @@ pub fn black_box_drop<T>(dummy: T) {
 /// ```
 ///
 /// Unlike the [`consts`] option, any argument type is supported if it
-/// implements [`Any`], [`Copy`], [`Send`], [`Sync`], and [`ToString`]:
+/// implements [`Any`], [`Copy`], [`Send`], [`Sync`], and [`ToString`] (or
+/// [`Debug`](std::fmt::Debug)):
 ///
 /// ```
-/// #[derive(Clone, Copy)]
+/// #[derive(Clone, Copy, Debug)]
 /// enum Arg {
 ///     A, B
 /// }
 ///
-/// // `Display` implies `ToString`.
-/// impl std::fmt::Display for Arg {
-///     // ...
-///     # fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-///     #    Ok(())
-///     # }
-/// }
-///
 /// #[divan::bench(args = [Arg::A, Arg::B])]
 /// fn bench_args(arg: Arg) {
 ///     // ...
@@ -384,17 +377,11 @@ pub fn black_box_drop<T>(dummy: T) {
 /// a reference:
 ///
 /// ```
+/// #[derive(Debug)]
 /// enum Arg {
 ///     A, B
 /// }
 ///
-/// impl std::fmt::Display for Arg {
-///     // ...
-///     # fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-///     #    Ok(())
-///     # }
-/// }
-///
 /// #[divan::bench(args = [Arg::A, Arg::B])]
 /// fn bench_args(arg: &Arg) {
 ///     // ...

src/private.rs

@@ -1,7 +1,7 @@
-use std::borrow::Borrow;
 pub use std::{
     self, any, borrow::Cow, default::Default, iter::FromIterator, option::Option::*, sync::OnceLock,
 };
+use std::{borrow::Borrow, fmt::Debug};
 
 pub use crate::{
     bench::{BenchArgs, BenchOptions},
@@ -12,6 +12,29 @@ pub use crate::{
     time::IntoDuration,
 };
 
+/// Helper to convert values to strings via `ToString` or fallback to `Debug`.
+///
+/// This works by having a `Debug`-based `ToString::to_string` method that will
+/// be chosen if the wrapped type implements `Debug` *but not* `ToString`. If
+/// the wrapped type implements `ToString`, then the inherent
+/// `ToStringHelper::to_string` method will be chosen instead.
+pub struct ToStringHelper<'a, T: 'static>(pub &'a T);
+
+impl<T: Debug> ToString for ToStringHelper<'_, T> {
+    #[inline]
+    fn to_string(&self) -> String {
+        format!("{:?}", self.0)
+    }
+}
+
+impl<T: ToString> ToStringHelper<'_, T> {
+    #[allow(clippy::inherent_to_string)]
+    #[inline]
+    pub fn to_string(&self) -> String {
+        self.0.to_string()
+    }
+}
+
 /// Used by `#[divan::bench(args = ...)]` to enable polymorphism.
 pub trait Arg<T> {
     fn get(self) -> T;