Support #[error(source(optional))] attribute (#465, #426)

## Synopsis

See #459:
> Additionally, we may support `#[error(source(optional))]` attribute,
which will allow using renamed types naturally:
> ```rust
> use derive_more::{Display, Error};
>
> #[derive(Debug, Display, Error)]
> struct Simple;
>
> #[derive(Debug, Display, Error)]
> #[display("Oops!")]
> struct Generic(#[error(source(optional))] RenamedOption<Simple>); //
forces recognizing as `Option`
> type RenamedOption<T> = Option<T>;
> ```

## Solution

Adds support for `#[error(source(optional))]` attribute.

Author: tyranron

impl/doc/error.md

@@ -83,24 +83,40 @@ Deriving `source()` is supported naturally for `Option<_>`-typed fields.
 >   struct Option<T>(T);
 >   ```
 
+> **TIP**: If `std::option::Option` for some reason needs to be renamed,
+> annotate the field with the `#[error(source(optional))]` attribute:
+> ```rust
+> # use derive_more::{Display, Error};
+> #
+> #[derive(Debug, Display, Error)]
+> struct Simple;
+>
+> #[derive(Debug, Display, Error)]
+> #[display("Oops!")]
+> struct Generic(#[error(source(optional))] RenamedOption<Simple>);
+> type RenamedOption<T> = Option<T>;
+>  ```
+
 
 
 
 ## Example usage
 
 ```rust
 # #![cfg_attr(nightly, feature(error_generic_member_access))]
-// Nightly requires enabling this feature:
-// #![feature(error_generic_member_access)]
+# // Nightly requires enabling this feature:
+# // #![feature(error_generic_member_access)]
 # #[cfg(not(nightly))] fn main() {}
 # #[cfg(nightly)] fn main() {
 # use core::error::{request_ref, request_value, Error as __};
 # use std::backtrace::Backtrace;
 #
 # use derive_more::{Display, Error, From};
-
-// std::error::Error requires std::fmt::Debug and std::fmt::Display,
-// so we can also use derive_more::Display for fully declarative
+#
+# type RenamedOption<T> = Option<T>;
+#
+// `std::error::Error` requires `std::fmt::Debug` and `std::fmt::Display`,
+// so we can also use `derive_more::Display` for fully declarative
 // error-type definitions.
 
 #[derive(Default, Debug, Display, Error)]
@@ -126,6 +142,12 @@ struct WithExplicitOptionalSource {
     #[error(source)]
     explicit_source: Option<Simple>,
 }
+#[derive(Default, Debug, Display, Error)]
+#[display("WithExplicitOptionalSource")]
+struct WithExplicitRenamedOptionalSource {
+    #[error(source(optional))]
+    explicit_source: RenamedOption<Simple>,
+}
 
 #[derive(Default, Debug, Display, Error)]
 struct Tuple(Simple);
@@ -170,6 +192,11 @@ enum CompoundError {
         #[error(source)]
         explicit_source: Option<WithSource>,
     },
+    #[display("WithExplicitRenamedOptionalSource")]
+    WithExplicitRenamedOptionalSource {
+        #[error(source(optional))]
+        explicit_source: RenamedOption<WithExplicitRenamedOptionalSource>,
+    },
     #[from(ignore)]
     WithBacktraceFromExplicitSource {
         #[error(backtrace, source)]
@@ -189,6 +216,7 @@ assert!(WithOptionalSource { source: Some(Simple) }.source().is_some());
 
 assert!(WithExplicitSource::default().source().is_some());
 assert!(WithExplicitOptionalSource { explicit_source: Some(Simple) }.source().is_some());
+assert!(WithExplicitRenamedOptionalSource { explicit_source: Some(Simple) }.source().is_some());
 
 assert!(Tuple::default().source().is_some());
 
@@ -211,6 +239,7 @@ assert!(CompoundError::from(Some(WithSource::default())).source().is_some());
 
 assert!(CompoundError::from(WithExplicitSource::default()).source().is_some());
 assert!(CompoundError::from(Some(WithExplicitSource::default())).source().is_some());
+assert!(CompoundError::from(Some(WithExplicitRenamedOptionalSource { explicit_source: Some(Simple) })).source().is_some());
 
 assert!(CompoundError::from(Tuple::default()).source().is_none());
 # }

impl/src/error.rs

@@ -181,7 +181,7 @@ fn allowed_attr_params() -> AttrParams {
         enum_: vec!["ignore"],
         struct_: vec!["ignore"],
         variant: vec!["ignore"],
-        field: vec!["ignore", "source", "backtrace"],
+        field: vec!["ignore", "source", "optional", "backtrace"],
     }
 }
 
@@ -207,17 +207,19 @@ impl ParsedFields<'_, '_> {
     fn render_source_as_struct(&self) -> Option<TokenStream> {
         let source = self.source?;
         let ident = &self.data.members[source];
-        Some(render_some(
-            quote! { (&#ident) },
-            self.data.field_types[source].is_option(),
-        ))
+        let is_optional = self.data.infos[source].info.source_optional == Some(true)
+            || self.data.field_types[source].is_option();
+
+        Some(render_some(quote! { (&#ident) }, is_optional))
     }
 
     fn render_source_as_enum_variant_match_arm(&self) -> Option<TokenStream> {
         let source = self.source?;
         let pattern = self.data.matcher(&[source], &[quote! { source }]);
-        let expr =
-            render_some(quote! { source }, self.data.field_types[source].is_option());
+        let is_optional = self.data.infos[source].info.source_optional == Some(true)
+            || self.data.field_types[source].is_option();
+
+        let expr = render_some(quote! { source }, is_optional);
         Some(quote! { #pattern => #expr })
     }
 
@@ -344,10 +346,15 @@ fn parse_fields<'input, 'state>(
     }?;
 
     if let Some(source) = parsed_fields.source {
+        let is_optional = parsed_fields.data.infos[source].info.source_optional
+            == Some(true)
+            || state.fields[source].ty.is_option();
+
         add_bound_if_type_parameter_used_in_type(
             &mut parsed_fields.bounds,
             type_params,
             &state.fields[source].ty,
+            is_optional,
         );
     }
 
@@ -502,9 +509,16 @@ fn add_bound_if_type_parameter_used_in_type(
     bounds: &mut HashSet<syn::Type>,
     type_params: &HashSet<syn::Ident>,
     ty: &syn::Type,
+    unpack: bool,
 ) {
     if let Some(ty) = utils::get_if_type_parameter_used_in_type(type_params, ty) {
-        bounds.insert(ty.get_option_inner().cloned().unwrap_or(ty));
+        bounds.insert(
+            unpack
+                .then(|| ty.get_inner())
+                .flatten()
+                .cloned()
+                .unwrap_or(ty),
+        );
     }
 }
 
@@ -513,24 +527,36 @@ trait TypeExt {
     /// Checks syntactically whether this [`syn::Type`] represents an [`Option`].
     fn is_option(&self) -> bool;
 
+    /// Returns the inner [`syn::Type`] if this one represents a wrapper.
+    ///
+    /// `filter` filters out this [`syn::Type`] by its name.
+    fn get_inner_if(&self, filter: impl Fn(&syn::Ident) -> bool) -> Option<&Self>;
+
+    /// Returns the inner [`syn::Type`] if this one represents a wrapper.
+    fn get_inner(&self) -> Option<&Self> {
+        self.get_inner_if(|_| true)
+    }
+
     /// Returns the inner [`syn::Type`] if this one represents an [`Option`].
-    fn get_option_inner(&self) -> Option<&Self>;
+    fn get_option_inner(&self) -> Option<&Self> {
+        self.get_inner_if(|ident| ident == "Option")
+    }
 }
 
 impl TypeExt for syn::Type {
     fn is_option(&self) -> bool {
         self.get_option_inner().is_some()
     }
 
-    fn get_option_inner(&self) -> Option<&Self> {
+    fn get_inner_if(&self, filter: impl Fn(&syn::Ident) -> bool) -> Option<&Self> {
         match self {
             Self::Group(g) => g.elem.get_option_inner(),
             Self::Paren(p) => p.elem.get_option_inner(),
             Self::Path(p) => p
                 .path
                 .segments
                 .last()
-                .filter(|s| s.ident == "Option")
+                .filter(|s| filter(&s.ident))
                 .and_then(|s| {
                     if let syn::PathArguments::AngleBracketed(a) = &s.arguments {
                         if let Some(syn::GenericArgument::Type(ty)) = a.args.first() {

impl/src/utils.rs

@@ -921,6 +921,8 @@ fn parse_punctuated_nested_meta(
                     (None, "ref") => info.ref_ = Some(true),
                     (None, "ref_mut") => info.ref_mut = Some(true),
 
+                    (None, "source") => info.source = Some(true),
+
                     #[cfg(any(feature = "from", feature = "into"))]
                     (None, "types")
                     | (Some("owned"), "types")
@@ -1022,6 +1024,7 @@ fn parse_punctuated_nested_meta(
                     (None, "ref_mut") => info.ref_mut = Some(true),
                     (None, "source") => info.source = Some(true),
                     (Some("not"), "source") => info.source = Some(false),
+                    (Some("source"), "optional") => info.source_optional = Some(true),
                     (None, "backtrace") => info.backtrace = Some(true),
                     (Some("not"), "backtrace") => info.backtrace = Some(false),
                     _ => {
@@ -1218,6 +1221,7 @@ pub struct MetaInfo {
     pub ref_: Option<bool>,
     pub ref_mut: Option<bool>,
     pub source: Option<bool>,
+    pub source_optional: Option<bool>,
     pub backtrace: Option<bool>,
     #[cfg(any(feature = "from", feature = "into"))]
     pub types: HashMap<RefType, HashSet<syn::Type>>,

tests/error/derives_for_enums_with_source.rs

@@ -2,6 +2,8 @@
 
 use super::*;
 
+type RenamedOption<T> = Option<T>;
+
 derive_display!(TestErr);
 #[derive(Debug, Error)]
 enum TestErr {
@@ -13,15 +15,15 @@ enum TestErr {
         source: SimpleErr,
         field: i32,
     },
-    NamedImplicitOptionalSource {
-        source: Option<SimpleErr>,
-        field: i32,
-    },
     #[cfg(feature = "std")]
     NamedImplicitBoxedSource {
         source: Box<dyn Error + Send + 'static>,
         field: i32,
     },
+    NamedImplicitOptionalSource {
+        source: Option<SimpleErr>,
+        field: i32,
+    },
     #[cfg(feature = "std")]
     NamedImplicitOptionalBoxedSource {
         source: Option<Box<dyn Error + Send + 'static>>,
@@ -42,6 +44,17 @@ enum TestErr {
         explicit_source: Option<SimpleErr>,
         field: i32,
     },
+    NamedExplicitRenamedOptionalSource {
+        #[error(source(optional))]
+        explicit_source: RenamedOption<SimpleErr>,
+        field: i32,
+    },
+    #[cfg(feature = "std")]
+    NamedExplicitRenamedOptionalBoxedSource {
+        #[error(source(optional))]
+        explicit_source: RenamedOption<Box<dyn Error + Send + 'static>>,
+        field: i32,
+    },
     NamedExplicitNoSourceRedundant {
         #[error(not(source))]
         field: i32,
@@ -51,11 +64,6 @@ enum TestErr {
         source: SimpleErr,
         field: i32,
     },
-    NamedExplicitOptionalSourceRedundant {
-        #[error(source)]
-        source: Option<SimpleErr>,
-        field: i32,
-    },
     NamedExplicitSuppressesImplicit {
         source: i32,
         #[error(source)]
@@ -72,12 +80,20 @@ enum TestErr {
     UnnamedExplicitNoSource(#[error(not(source))] SimpleErr),
     UnnamedExplicitSource(#[error(source)] SimpleErr, i32),
     UnnamedExplicitOptionalSource(#[error(source)] Option<SimpleErr>, i32),
+    UnnamedExplicitRenamedOptionalSource(
+        #[error(source(optional))] RenamedOption<SimpleErr>,
+        i32,
+    ),
+    #[cfg(feature = "std")]
+    UnnamedExplicitRenamedOptionalBoxedSource(
+        #[error(source(optional))] RenamedOption<Box<dyn Error + Send + 'static>>,
+        i32,
+    ),
     UnnamedExplicitNoSourceRedundant(
         #[error(not(source))] i32,
         #[error(not(source))] i32,
     ),
     UnnamedExplicitSourceRedundant(#[error(source)] SimpleErr),
-    UnnamedExplicitOptionalSourceRedundant(#[error(source)] Option<SimpleErr>),
     NamedIgnore {
         #[error(ignore)]
         source: SimpleErr,
@@ -195,16 +211,21 @@ fn named_explicit_optional_source() {
 }
 
 #[test]
-fn named_explicit_no_source_redundant() {
-    let err = TestErr::NamedExplicitNoSourceRedundant { field: 0 };
+fn named_explicit_renamed_optional_source() {
+    let err = TestErr::NamedExplicitRenamedOptionalSource {
+        explicit_source: Some(SimpleErr),
+        field: 0,
+    };
 
-    assert!(err.source().is_none());
+    assert!(err.source().is_some());
+    assert!(err.source().unwrap().is::<SimpleErr>());
 }
 
+#[cfg(feature = "std")]
 #[test]
-fn named_explicit_source_redundant() {
-    let err = TestErr::NamedExplicitSourceRedundant {
-        source: SimpleErr,
+fn named_explicit_renamed_optional_boxed_source() {
+    let err = TestErr::NamedExplicitRenamedOptionalBoxedSource {
+        explicit_source: Some(Box::new(SimpleErr)),
         field: 0,
     };
 
@@ -213,9 +234,16 @@ fn named_explicit_source_redundant() {
 }
 
 #[test]
-fn named_explicit_optional_source_redundant() {
-    let err = TestErr::NamedExplicitOptionalSourceRedundant {
-        source: Some(SimpleErr),
+fn named_explicit_no_source_redundant() {
+    let err = TestErr::NamedExplicitNoSourceRedundant { field: 0 };
+
+    assert!(err.source().is_none());
+}
+
+#[test]
+fn named_explicit_source_redundant() {
+    let err = TestErr::NamedExplicitSourceRedundant {
+        source: SimpleErr,
         field: 0,
     };
 
@@ -290,23 +318,35 @@ fn unnamed_explicit_optional_source() {
 }
 
 #[test]
-fn unnamed_explicit_no_source_redundant() {
-    let err = TestErr::UnnamedExplicitNoSourceRedundant(0, 0);
+fn unnamed_explicit_renamed_optional_source() {
+    let err = TestErr::UnnamedExplicitRenamedOptionalSource(Some(SimpleErr), 0);
 
-    assert!(err.source().is_none());
+    assert!(err.source().is_some());
+    assert!(err.source().unwrap().is::<SimpleErr>());
 }
 
+#[cfg(feature = "std")]
 #[test]
-fn unnamed_explicit_source_redundant() {
-    let err = TestErr::UnnamedExplicitSourceRedundant(SimpleErr);
+fn unnamed_explicit_renamed_optional_boxed_source() {
+    let err = TestErr::UnnamedExplicitRenamedOptionalBoxedSource(
+        Some(Box::new(SimpleErr)),
+        0,
+    );
 
     assert!(err.source().is_some());
     assert!(err.source().unwrap().is::<SimpleErr>());
 }
 
 #[test]
-fn unnamed_explicit_optional_source_redundant() {
-    let err = TestErr::UnnamedExplicitOptionalSourceRedundant(Some(SimpleErr));
+fn unnamed_explicit_no_source_redundant() {
+    let err = TestErr::UnnamedExplicitNoSourceRedundant(0, 0);
+
+    assert!(err.source().is_none());
+}
+
+#[test]
+fn unnamed_explicit_source_redundant() {
+    let err = TestErr::UnnamedExplicitSourceRedundant(SimpleErr);
 
     assert!(err.source().is_some());
     assert!(err.source().unwrap().is::<SimpleErr>());