Add bound attribute for generics support

impl/src/attr.rs

@@ -2,9 +2,10 @@ use proc_macro2::{Delimiter, Group, Span, TokenStream, TokenTree};
 use quote::{format_ident, quote, ToTokens};
 use std::iter::FromIterator;
 use syn::parse::{Nothing, ParseStream};
+use syn::punctuated::Punctuated;
 use syn::{
     braced, bracketed, parenthesized, token, Attribute, Error, Ident, Index, LitInt, LitStr,
-    Result, Token,
+    Result, Token, TypeParamBound,
 };
 
 pub struct Attrs<'a> {
@@ -13,6 +14,7 @@ pub struct Attrs<'a> {
     pub backtrace: Option<&'a Attribute>,
     pub from: Option<&'a Attribute>,
     pub transparent: Option<Transparent<'a>>,
+    pub bound: Option<Bound<'a>>,
 }
 
 #[derive(Clone)]
@@ -29,13 +31,20 @@ pub struct Transparent<'a> {
     pub span: Span,
 }
 
+#[derive(Clone)]
+pub struct Bound<'a> {
+    pub original: &'a Attribute,
+    pub bounds: Punctuated<TypeParamBound, token::Add>,
+}
+
 pub fn get(input: &[Attribute]) -> Result<Attrs> {
     let mut attrs = Attrs {
         display: None,
         source: None,
         backtrace: None,
         from: None,
         transparent: None,
+        bound: None,
     };
 
     for attr in input {
@@ -70,6 +79,7 @@ pub fn get(input: &[Attribute]) -> Result<Attrs> {
 
 fn parse_error_attribute<'a>(attrs: &mut Attrs<'a>, attr: &'a Attribute) -> Result<()> {
     syn::custom_keyword!(transparent);
+    syn::custom_keyword!(bound);
 
     attr.parse_args_with(|input: ParseStream| {
         if let Some(kw) = input.parse::<Option<transparent>>()? {
@@ -84,6 +94,22 @@ fn parse_error_attribute<'a>(attrs: &mut Attrs<'a>, attr: &'a Attribute) -> Resu
                 span: kw.span,
             });
             return Ok(());
+        } else if input.parse::<Option<bound>>()?.is_some() {
+            if attrs.bound.is_some() {
+                return Err(Error::new_spanned(
+                    attr,
+                    "duplicate #[error(bound)] attribute",
+                ));
+            }
+            input.parse::<token::Eq>().map_err(|_| {
+                Error::new_spanned(attr, "\"bound\" keyword must be followed by '='")
+            })?;
+            let bound = Bound {
+                original: attr,
+                bounds: Punctuated::<TypeParamBound, token::Add>::parse_separated_nonempty(input)?,
+            };
+            attrs.bound = Some(bound);
+            return Ok(());
         }
 
         let display = Display {

impl/src/expand.rs

@@ -2,7 +2,9 @@ use crate::ast::{Enum, Field, Input, Struct};
 use proc_macro2::TokenStream;
 use quote::{format_ident, quote, quote_spanned, ToTokens};
 use syn::spanned::Spanned;
-use syn::{Data, DeriveInput, Member, PathArguments, Result, Type, Visibility};
+use syn::{
+    token, Data, DeriveInput, Member, PathArguments, Result, Type, Visibility, WherePredicate,
+};
 
 pub fn derive(node: &DeriveInput) -> Result<TokenStream> {
     let input = Input::from_syn(node)?;
@@ -111,9 +113,26 @@ fn impl_struct(input: Struct) -> TokenStream {
     } else {
         None
     };
+
+    let bounded_where_predicates: Vec<syn::WherePredicate> = input
+        .attrs
+        .bound
+        .as_ref()
+        .map(|bound| apply_type_bounds(input.generics.type_params(), bound))
+        .unwrap_or_default();
+    let where_clause = extend_where_clause(
+        where_clause.cloned(),
+        input.original.span(),
+        bounded_where_predicates.into_iter(),
+    );
+
     let display_impl = display_body.map(|body| {
         quote! {
-            #[allow(unused_qualifications)]
+            #[allow(
+                unused_qualifications,
+                // Since we don't merge bounds that cover the same type, suppress this issue
+                clippy::type_repetition_in_bounds,
+            )]
             impl #impl_generics std::fmt::Display for #ty #ty_generics #where_clause {
                 #[allow(
                     // Clippy bug: https://github.com/rust-lang/rust-clippy/issues/7422
@@ -132,7 +151,11 @@ fn impl_struct(input: Struct) -> TokenStream {
         let from = from_field.ty;
         let body = from_initializer(from_field, backtrace_field);
         quote! {
-            #[allow(unused_qualifications)]
+            #[allow(
+                unused_qualifications,
+                // Since we don't merge bounds that cover the same type, suppress this issue
+                clippy::type_repetition_in_bounds,
+            )]
             impl #impl_generics std::convert::From<#from> for #ty #ty_generics #where_clause {
                 #[allow(deprecated)]
                 fn from(source: #from) -> Self {
@@ -143,9 +166,12 @@ fn impl_struct(input: Struct) -> TokenStream {
     });
 
     let error_trait = spanned_error_trait(input.original);
-
     quote! {
-        #[allow(unused_qualifications)]
+        #[allow(
+            unused_qualifications,
+            // Since we don't merge bounds that cover the same type, suppress this issue
+            clippy::type_repetition_in_bounds,
+        )]
         impl #impl_generics #error_trait for #ty #ty_generics #where_clause {
             #source_method
             #backtrace_method
@@ -266,6 +292,18 @@ fn impl_enum(input: Enum) -> TokenStream {
         None
     };
 
+    let bounded_where_predicates: Vec<syn::WherePredicate> = input
+        .attrs
+        .bound
+        .as_ref()
+        .map(|bound| apply_type_bounds(input.generics.type_params(), bound))
+        .unwrap_or_default();
+    let where_clause = extend_where_clause(
+        where_clause.cloned(),
+        input.original.span(),
+        bounded_where_predicates.into_iter(),
+    );
+
     let display_impl = if input.has_display() {
         let use_as_display = if input.variants.iter().any(|v| {
             v.attrs
@@ -303,7 +341,11 @@ fn impl_enum(input: Enum) -> TokenStream {
             }
         });
         Some(quote! {
-            #[allow(unused_qualifications)]
+            #[allow(
+                unused_qualifications,
+                // Since we don't merge bounds that cover the same type, suppress this issue
+                clippy::type_repetition_in_bounds,
+            )]
             impl #impl_generics std::fmt::Display for #ty #ty_generics #where_clause {
                 fn fmt(&self, __formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                     #use_as_display
@@ -331,7 +373,11 @@ fn impl_enum(input: Enum) -> TokenStream {
         let from = from_field.ty;
         let body = from_initializer(from_field, backtrace_field);
         Some(quote! {
-            #[allow(unused_qualifications)]
+            #[allow(
+                unused_qualifications,
+                // Since we don't merge bounds that cover the same type, suppress this issue
+                clippy::type_repetition_in_bounds,
+            )]
             impl #impl_generics std::convert::From<#from> for #ty #ty_generics #where_clause {
                 #[allow(deprecated)]
                 fn from(source: #from) -> Self {
@@ -342,9 +388,12 @@ fn impl_enum(input: Enum) -> TokenStream {
     });
 
     let error_trait = spanned_error_trait(input.original);
-
     quote! {
-        #[allow(unused_qualifications)]
+        #[allow(
+            unused_qualifications,
+            // Since we don't merge bounds that cover the same type, suppress this issue
+            clippy::type_repetition_in_bounds,
+        )]
         impl #impl_generics #error_trait for #ty #ty_generics #where_clause {
             #source_method
             #backtrace_method
@@ -424,3 +473,48 @@ fn spanned_error_trait(input: &DeriveInput) -> TokenStream {
     let error = quote_spanned!(last_span=> Error);
     quote!(#path #error)
 }
+
+/// Enhance a where clause with the given predicates, or create one with them if needed.
+/// When no new predicates are provided, return without alteration.
+fn extend_where_clause<TPredicates: std::iter::ExactSizeIterator<Item = syn::WherePredicate>>(
+    // Clause to be enhanced; created if absent when predicates are provided
+    where_clause: Option<syn::WhereClause>,
+    // Used to create span for new where clause if populating
+    where_span: proc_macro2::Span,
+    predicates: TPredicates,
+) -> Option<syn::WhereClause> {
+    // If we don't have any predicates to add, it doesn't matter if we
+    // have a where clause to extend or not; return whatever was given
+    if predicates.len() == 0 {
+        return where_clause;
+    }
+    Some(match where_clause {
+        // Extend the existing clause with the new predicates
+        Some(mut where_clause) => {
+            where_clause.predicates.extend(predicates);
+            where_clause
+        }
+        // No where clause provided; create a new one with the provided span
+        None => syn::WhereClause {
+            where_token: token::Where(where_span),
+            predicates: predicates.collect(),
+        },
+    })
+}
+
+fn apply_type_bounds<'a, TTypeParams: std::iter::Iterator<Item = &'a syn::TypeParam>>(
+    type_params: TTypeParams,
+    bound_attr: &'a crate::attr::Bound<'_>,
+) -> Vec<WherePredicate> {
+    let bounds = &bound_attr.bounds;
+    if bounds.is_empty() {
+        return Vec::new();
+    }
+    type_params
+        .map(move |syn::TypeParam { ident: tparam, .. }| {
+            let predicate = quote! { #tparam: #bounds };
+            syn::parse2::<syn::WherePredicate>(predicate)
+                .expect("quasiquote must create predicate bounds")
+        })
+        .collect()
+}

impl/src/valid.rs

@@ -30,6 +30,18 @@ impl Struct<'_> {
                 ));
             }
         }
+        if let Some(crate::attr::Bound {
+            original: bound_span,
+            ..
+        }) = self.attrs.bound
+        {
+            if self.generics.params.is_empty() {
+                return Err(Error::new_spanned(
+                    bound_span,
+                    "#[error(bound = ...)] requires at least one generic type parameter",
+                ));
+            }
+        }
         check_field_attrs(&self.fields)?;
         for field in &self.fields {
             field.validate()?;
@@ -52,6 +64,18 @@ impl Enum<'_> {
                 ));
             }
         }
+        if let Some(crate::attr::Bound {
+            original: bound_span,
+            ..
+        }) = self.attrs.bound
+        {
+            if self.generics.params.is_empty() {
+                return Err(Error::new_spanned(
+                    bound_span,
+                    "#[error(bound = ...)] requires at least one generic type parameter",
+                ));
+            }
+        }
         let mut from_types = Set::new();
         for variant in &self.variants {
             if let Some(from_field) = variant.from_field() {

tests/test_error.rs

@@ -6,6 +6,20 @@ use std::io;
 use thiserror::Error;
 
 macro_rules! unimplemented_display {
+    ($($tl:lifetime),*; $tp:tt; $ty:ty) => {
+        impl<$($tl),*, $tp> Display for $ty {
+            fn fmt(&self, _formatter: &mut fmt::Formatter) -> fmt::Result {
+                unimplemented!()
+            }
+        }
+    };
+    ($tp:tt; $ty:ty) => {
+        impl<$tp> Display for $ty {
+            fn fmt(&self, _formatter: &mut fmt::Formatter) -> fmt::Result {
+                unimplemented!()
+            }
+        }
+    };
     ($ty:ty) => {
         impl Display for $ty {
             fn fmt(&self, _formatter: &mut fmt::Formatter) -> fmt::Result {
@@ -49,9 +63,74 @@ enum EnumError {
     Unit,
 }
 
+#[derive(Error, Debug)]
+#[error(bound = std::fmt::Display + std::error::Error + 'static)]
+enum WithGeneric<T> {
+    Variant,
+    Generic(T),
+}
+
+#[derive(Error, Debug)]
+#[error(bound = std::fmt::Debug + std::error::Error + 'static)]
+enum WithGenericFrom<T> {
+    Variant,
+    Generic(#[from] T),
+}
+
+#[derive(Error, Debug)]
+#[error(bound = std::fmt::Display + std::fmt::Debug + std::error::Error + 'static)]
+enum WithGenericTransparent<T> {
+    #[error("variant")]
+    Variant,
+    #[error(transparent)]
+    Generic(#[from] T),
+}
+
+#[derive(Error, Debug)]
+#[error(bound = std::error::Error + 'static)]
+struct WithGenericStruct<T> {
+    #[from]
+    inner: T,
+}
+
+#[derive(Error, Debug)]
+#[error(bound = std::error::Error + 'static)]
+struct WithGenericStructRef<'a, T> {
+    inner: &'a WithGenericStruct<T>,
+}
+
+#[derive(Error, Debug)]
+#[error(bound = std::error::Error + 'a)]
+struct WithGenericStructRefNonStaticInline<'a, T: 'a> {
+    inner: &'a WithGenericStruct<T>,
+}
+
+#[derive(Error, Debug)]
+#[error(bound = std::error::Error + 'a)]
+struct WithGenericStructRefNonStaticWhere<'a, T>
+where
+    T: 'a,
+{
+    inner: &'a WithGenericStruct<T>,
+}
+
+#[derive(Error, Debug)]
+#[error(bound = std::fmt::Display + std::error::Error + 'static)]
+#[error(transparent)]
+struct WithGenericStructTransparent<T> {
+    #[from]
+    inner: T,
+}
+
 unimplemented_display!(BracedError);
 unimplemented_display!(TupleError);
 unimplemented_display!(UnitError);
 unimplemented_display!(WithSource);
 unimplemented_display!(WithAnyhow);
 unimplemented_display!(EnumError);
+unimplemented_display!(T; WithGeneric<T>);
+unimplemented_display!(T; WithGenericFrom<T>);
+unimplemented_display!(T; WithGenericStruct<T>);
+unimplemented_display!('a; T; WithGenericStructRef<'a, T>);
+unimplemented_display!('a; T; WithGenericStructRefNonStaticInline<'a, T>);
+unimplemented_display!('a; T; WithGenericStructRefNonStaticWhere<'a, T>);

tests/ui/bound-enum-without-generic.rs

@@ -0,0 +1,15 @@
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+#[error(bound = std::error::Error + 'static)]
+enum BoundsWithoutGeneric {
+    Variant(u32),
+}
+
+impl std::fmt::Display for BoundsWithoutGeneric {
+    fn fmt(&self, _formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+        unimplemented!()
+    }
+}
+
+fn main() {}