feat: add Display support for Path and PathBuf

Prior to this change, we could not display Paths or PathBufs via display
and their `Path::display` function because we only support identifiers
in the formatting strings and don't do anything fancy with those args
other than paste them verbatim into the args for the generated `write!`
calls.

This change adds special support for Path and PathBuf displaying via
autoref specialization. We introduce two new traits, one which handles
anything that implements display and just returns self, and another
which specifically works for Path and PathBuf and returns
`std::path::Display`. On top of this we manually route all display impl
format args thru this trait by putting `(&arg).get_display()` rather
than `arg` in the generated format args list.

Author: yaahc

Cargo.toml

@@ -16,7 +16,9 @@ A derive macro for implementing the display Trait via a doc comment and string i
 [lib]
 proc-macro = true
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[features]
+default = ["std"]
+std = []
 
 [dependencies]
 syn = "1.0"
@@ -28,3 +30,4 @@ trybuild = "1.0"
 static_assertions = "0.3.4"
 libc = { version = "0.2", default-features = false }
 rustversion = "1.0.0"
+pretty_assertions = "0.6.1"

src/expand.rs

@@ -11,6 +11,42 @@ pub fn derive(input: &DeriveInput) -> Result<TokenStream> {
     }
 }
 
+#[cfg(feature = "std")]
+fn specialization() -> TokenStream {
+    quote! {
+        trait DisplayToDisplayDoc {
+            fn get_display(&self) -> Self;
+        }
+
+        impl<T: core::fmt::Display> DisplayToDisplayDoc for &T {
+            fn get_display(&self) -> Self {
+                self
+            }
+        }
+
+        trait PathToDisplayDoc {
+            fn get_display(&self) -> std::path::Display<'_>;
+        }
+
+        impl PathToDisplayDoc for std::path::Path {
+            fn get_display(&self) -> std::path::Display<'_> {
+                self.display()
+            }
+        }
+
+        impl PathToDisplayDoc for std::path::PathBuf {
+            fn get_display(&self) -> std::path::Display<'_> {
+                self.display()
+            }
+        }
+    }
+}
+
+#[cfg(not(feature = "std"))]
+fn specialization() -> TokenStream {
+    quote! {}
+}
+
 fn impl_struct(input: &DeriveInput, data: &DataStruct) -> Result<TokenStream> {
     let ty = &input.ident;
     let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
@@ -38,7 +74,11 @@ fn impl_struct(input: &DeriveInput, data: &DataStruct) -> Result<TokenStream> {
         }
     });
 
+    let needed_traits = specialization();
+
     Ok(quote! {
+        #needed_traits
+
         #display
     })
 }
@@ -89,7 +129,11 @@ fn impl_enum(input: &DeriveInput, data: &DataEnum) -> Result<TokenStream> {
         return Err(Error::new_spanned(input, "Missing doc comments"));
     };
 
+    let needed_traits = specialization();
+
     Ok(quote! {
+        #needed_traits
+
         #display
     })
 }

src/fmt.rs

@@ -15,22 +15,39 @@ impl Display {
         while let Some(brace) = read.find('{') {
             out += &read[..=brace];
             read = &read[brace + 1..];
+
+            // skip cases where we find a {{
             if read.starts_with('{') {
                 out.push('{');
                 read = &read[1..];
                 continue;
             }
+
             let next = match read.chars().next() {
                 Some(next) => next,
                 None => return,
             };
+
             let var = match next {
                 '0'..='9' => take_int(&mut read),
                 'a'..='z' | 'A'..='Z' | '_' => take_ident(&mut read),
                 _ => return,
             };
+
             let ident = Ident::new(&var, span);
-            args.extend(quote_spanned!(span=> , #ident));
+
+            let next = match read.chars().next() {
+                Some(next) => next,
+                None => return,
+            };
+
+            let arg = if next == '}' {
+                quote_spanned!(span=> , (&#ident).get_display())
+            } else {
+                quote_spanned!(span=> , #ident)
+            };
+
+            args.extend(arg);
         }
 
         out += read;
@@ -71,6 +88,7 @@ fn take_ident(read: &mut &str) -> String {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use pretty_assertions::assert_eq;
     use proc_macro2::Span;
 
     fn assert(input: &str, fmt: &str, args: &str) {
@@ -85,12 +103,15 @@ mod tests {
 
     #[test]
     fn test_expand() {
-        assert("error {var}", "error {}", ", var");
+        assert("error {var}", "error {}", ", ( & var ) . get_display ( )");
         assert("fn main() {{ }}", "fn main() {{ }}", "");
         assert(
             "{v} {v:?} {0} {0:?}",
             "{} {:?} {} {:?}",
-            ", v , v , _0 , _0",
+            ", ( & v ) . get_display ( ) , v , ( & _0 ) . get_display ( ) , _0",
         );
+
+        // assert("The path {0.display()}", "The path {}", "0.display()");
+        // assert("The path {0.display():?}", "The path {:?}", "0.display()");
     }
 }

tests/happy.rs

@@ -1,4 +1,5 @@
 use displaydoc::Display;
+// use std::path::PathBuf;
 
 #[derive(Display)]
 enum Happy {
@@ -17,6 +18,8 @@ enum Happy {
     /// Variant5 just has {0} many problems
     /// but multi line comments aren't one of them
     Variant5(u32),
+    // /// The path {0.display()}
+    // Variant6(PathBuf),
 }
 
 fn assert_display<T: std::fmt::Display>(input: T, expected: &'static str) {
@@ -34,4 +37,8 @@ fn does_it_print() {
         "Variant4 wants to have a lot of lines\n\n Lets see how this works out for it",
     );
     assert_display(Happy::Variant5(2), "Variant5 just has 2 many problems");
+    // assert_display(
+    //     Happy::Variant6(PathBuf::from("/var/log/happy")),
+    //     "The path /var/log/happy",
+    // );
 }