Added support for thiserror

Cargo.toml

@@ -31,3 +31,6 @@ static_assertions = "0.3.4"
 libc = { version = "0.2", default-features = false }
 rustversion = "1.0.0"
 pretty_assertions = "0.6.1"
+thiserror = "1.0.18"
+anyhow = "1.0.31"
+

src/attr.rs

@@ -1,6 +1,9 @@
 use proc_macro2::TokenStream;
 use quote::{quote, ToTokens};
-use syn::{Attribute, LitStr, Meta, Result};
+use syn::{
+    spanned::Spanned, Attribute, Lit::Str, LitStr, Meta, MetaList, MetaNameValue, NestedMeta,
+    Result,
+};
 
 pub struct Display {
     pub fmt: LitStr,
@@ -18,27 +21,39 @@ impl ToTokens for Display {
 }
 
 pub fn display(attrs: &[Attribute]) -> Result<Option<Display>> {
-    for attr in attrs {
-        if attr.path.is_ident("doc") {
-            let meta = attr.parse_meta()?;
-            let lit = match meta {
-                Meta::NameValue(syn::MetaNameValue {
-                    lit: syn::Lit::Str(lit),
-                    ..
-                }) => lit,
-                _ => unimplemented!(),
-            };
-
-            let lit = LitStr::new(lit.value().trim(), lit.span());
-
+    let attr = attrs
+        .iter()
+        .find(|attr| attr.path.is_ident("display"))
+        .or_else(|| attrs.iter().find(|attr| attr.path.is_ident("doc")));
+    if let Some(attr) = attr {
+        let meta = attr.parse_meta()?;
+        let lit = match meta {
+            Meta::NameValue(MetaNameValue { lit: Str(lit), .. }) => Some(lit),
+            Meta::NameValue(_) => unimplemented!("namevalue"),
+            Meta::Path(_) => unimplemented!("path"),
+            Meta::List(MetaList { nested, .. }) => {
+                nested.iter().find_map(|nested_attr| match nested_attr {
+                    NestedMeta::Meta(Meta::Path(path)) => {
+                        if path.is_ident("transparent") {
+                            Some(LitStr::new("{0}", attr.span()))
+                        } else {
+                            unimplemented!()
+                        }
+                    }
+                    NestedMeta::Lit(Str(lit)) => Some(lit.clone()),
+                    _ => unimplemented!(),
+                })
+            }
+        };
+        if let Some(l) = lit {
             let mut display = Display {
-                fmt: lit,
+                fmt: LitStr::new(l.value().trim(), l.span()),
                 args: TokenStream::new(),
             };
 
             display.expand_shorthand();
             return Ok(Some(display));
-        }
+        };
     }
 
     Ok(None)

src/expand.rs

@@ -60,7 +60,6 @@ fn specialization() -> TokenStream {
 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();
-
     let display = attr::display(&input.attrs)?.map(|display| {
         let pat = match &data.fields {
             Fields::Named(fields) => {

src/fmt.rs

@@ -20,7 +20,6 @@ impl Display {
         let mut read = fmt.as_str();
         let mut out = String::new();
         let mut args = TokenStream::new();
-
         while let Some(brace) = read.find('{') {
             out += &read[..=brace];
             read = &read[brace + 1..];

src/lib.rs

@@ -7,7 +7,7 @@ mod fmt;
 use proc_macro::TokenStream;
 use syn::{parse_macro_input, DeriveInput};
 
-#[proc_macro_derive(Display)]
+#[proc_macro_derive(Display, attributes(display))]
 pub fn derive_error(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as DeriveInput);
     expand::derive(&input)

tests/with_thiserror_tests.rs

@@ -0,0 +1,98 @@
+use anyhow::anyhow;
+use displaydoc::Display;
+use std::error::Error as StdError;
+use std::io;
+use thiserror::Error;
+
+fn assert_display<T: std::fmt::Display>(input: T, expected: &'static str) {
+    let out = format!("{}", input);
+    assert_eq!(expected, out);
+}
+
+#[test]
+fn test_transparent_for_enum() {
+    #[derive(Display, Error, Debug)]
+    enum MyError {
+        /// Doc for Variant.
+        #[display(transparent)]
+        Variant(anyhow::Error),
+    }
+
+    let var = MyError::Variant(anyhow!("inner").context("outer"));
+    assert_display(&var, "outer");
+    assert_eq!(var.source().unwrap().to_string(), "inner")
+}
+
+#[test]
+fn test_transparent_for_struct() {
+    #[derive(Display, Error, Debug)]
+    #[error(transparent)]
+    struct Error(ErrorKind);
+
+    #[derive(Display, Error, Debug)]
+    enum ErrorKind {
+        #[display("E0")]
+        E0,
+        #[display("E1")]
+        E1(#[from] io::Error),
+    }
+
+    let error = Error(ErrorKind::E0);
+    assert_eq!("E0", error.to_string());
+    assert!(error.source().is_none());
+
+    let io = io::Error::new(io::ErrorKind::Other, "oh no!");
+    let error = Error(ErrorKind::from(io));
+    assert_eq!("E1", error.to_string());
+    error.source().unwrap().downcast_ref::<io::Error>().unwrap();
+}
+
+#[test]
+fn test_errordoc_for_enum() {
+    #[derive(Display, Error, Debug)]
+    enum MyError {
+        /// I'm not a doc for Variant
+        #[display("I'm a doc for Variant")]
+        Variant,
+    }
+    assert_display(MyError::Variant, "I'm a doc for Variant");
+}
+
+#[test]
+fn test_errordoc_for_struct() {
+    #[derive(Display, Error, Debug)]
+    #[display("I'm a doc for MyError")]
+    struct MyError {
+        /// I'm not a doc for MyError
+        variant: u8,
+    }
+    assert_display(MyError { variant: 42 }, "I'm a doc for MyError");
+}
+
+#[test]
+fn test_thiserror_implicit_and_source_works() {
+    #[derive(Display, Error, Debug)]
+    #[error("implicit source")]
+    struct ImplicitSource {
+        source: io::Error,
+    }
+
+    #[derive(Display, Error, Debug)]
+    #[error("explicit source")]
+    struct ExplicitSource {
+        source: String,
+        #[source]
+        io: io::Error,
+    }
+
+    let io = io::Error::new(io::ErrorKind::Other, "oh no!");
+    let error = ImplicitSource { source: io };
+    error.source().unwrap().downcast_ref::<io::Error>().unwrap();
+
+    let io = io::Error::new(io::ErrorKind::Other, "oh no!");
+    let error = ExplicitSource {
+        source: String::new(),
+        io,
+    };
+    error.source().unwrap().downcast_ref::<io::Error>().unwrap();
+}