Support Option as Error::source() in derive(Error) (#459, #426)

## Synopsis

See #426 (comment):
> I’d like to be able to use `derive_more` with optional sources, like:
> ```rust
> #[derive(derive_more::Error, derive_more::Display, Debug)]
> #[display("it’s an error")]
> struct MyErr {
> source: Option<Box<dyn std::error::Error + Send + Sync + 'static>>,
> }
> ```

## Solution

The way, the `thiserror` does it, is by
[checking](https://docs.rs/thiserror-impl/2.0.12/src/thiserror_impl/expand.rs.html#50)
the [type name to contain
`Option`](https://docs.rs/thiserror-impl/2.0.12/src/thiserror_impl/expand.rs.html#559-583).
Relying on type could be fragile, as the call site could introduce its
own type named `Option` in the scope where macro is called. Ideally, we
need to aid this case with type machinery.

For supporting this via type machinery, we obviously need some sort of
specialization to specialize case `Option<E: Error>` over `E: Error`,
since vanilla Rust coherence naturally hits the wall of "upstream crates
may add a new impl of trait `std::error::Error` for type `Option<_>` in
future versions". The usual solution is to use [autoref-based
specialization](https://lukaskalbertodt.github.io/2019/12/05/generalized-autoref-based-specialization.html)
as [we do for
`AsRef`](https://docs.rs/derive_more/2.0.1/src/derive_more/as.rs.html).
However, autoref-based specialization doesn't work in a generic context
(i.e. `MyError<E1, E2>`), since it requires trait bounds to work, and we
cannot describe conditional trait bounds in Rust, which leads to the
situation that this case could not be supported at all:
```rust
struct MyError<E> {
    source: Option<E>,
}
```

So, choosing between checking the field's type syntactically (and so
loosing support for renamed types) and not supporting optional `source`
in generic contexts, I would definitely choose to support generics
despite having naming issues in edge cases. As the result, this PR
implements the similar syntactically-based solution as the `thiserror`
crate does. The implications of this are warned and described in the
documentation.

## Future possibilities

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>); // froces recognizing as `Option`
type RenamedOption<T> = Option<T>;
```
However, it's better to be implemented as a separate PR, to not
overcomplicate this one.

Author: tyranron

CHANGELOG.md

@@ -12,6 +12,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Support `#[display(rename_all = "<casing>")]` attribute to change output for
   implicit naming of unit enum variants or unit structs when deriving `Display`.
   ([#443](https://github.com/JelteF/derive_more/pull/443))
+- Support `Option` fields for `Error::source()` in `Error` derive.
+  ([#459](https://github.com/JelteF/derive_more/pull/459))
 
 ### Fixed
 

impl/doc/error.md

@@ -52,6 +52,38 @@ Backtraces don't work though, because the `Backtrace` type is only available in
 `std`.
 
 
+### `Option`al fields
+
+Deriving `source()` is supported naturally for `Option<_>`-typed fields.
+
+> **WARNING**: Field type is **considered as `Option<_>` only syntactically**,
+> meaning that:
+> - Neither renaming `std::option::Option` would work:
+>   ```rust,compile_fail
+>   # use derive_more::{Display, Error};
+>   #
+>   #[derive(Debug, Display, Error)]
+>   struct Simple;
+>
+>   #[derive(Debug, Display, Error)]
+>   #[display("Oops!")]
+>   struct Generic(RenamedOption<Simple>); // not recognized as `Option`
+>   type RenamedOption<T> = Option<T>;
+>   ```
+> - Nor using any custom type named as `Option` would:
+>   ```rust,compile_fail
+>   # use derive_more::{Display, Error};
+>   #
+>   # #[derive(Debug, Display, Error)]
+>   # struct Simple;
+>   #
+>   #[derive(Debug, Display, Error)]
+>   #[display("No way!")]
+>   struct Generic(Option<Simple>);        // cannot use `?` syntax
+>   struct Option<T>(T);
+>   ```
+
+
 
 
 ## Example usage
@@ -79,10 +111,21 @@ struct WithSource {
     source: Simple,
 }
 #[derive(Default, Debug, Display, Error)]
+#[display("WithOptionalSource")]
+struct WithOptionalSource {
+    source: Option<Simple>,
+}
+#[derive(Default, Debug, Display, Error)]
 struct WithExplicitSource {
     #[error(source)]
     explicit_source: Simple,
 }
+#[derive(Default, Debug, Display, Error)]
+#[display("WithExplicitOptionalSource")]
+struct WithExplicitOptionalSource {
+    #[error(source)]
+    explicit_source: Option<Simple>,
+}
 
 #[derive(Default, Debug, Display, Error)]
 struct Tuple(Simple);
@@ -104,6 +147,10 @@ enum CompoundError {
     WithSource {
         source: Simple,
     },
+    #[display("WithOptionalSource")]
+    WithOptionalSource {
+        source: Option<Simple>,
+    },
     #[from(ignore)]
     WithBacktraceFromSource {
         #[error(backtrace)]
@@ -118,21 +165,35 @@ enum CompoundError {
         #[error(source)]
         explicit_source: WithSource,
     },
+    #[display("WithExplicitOptionalSource")]
+    WithExplicitOptionalSource {
+        #[error(source)]
+        explicit_source: Option<WithSource>,
+    },
     #[from(ignore)]
     WithBacktraceFromExplicitSource {
         #[error(backtrace, source)]
         explicit_source: WithSource,
     },
     Tuple(WithExplicitSource),
+    #[display("TupleOptional")]
+    TupleOptional(Option<WithExplicitSource>),
     WithoutSource(#[error(not(source))] Tuple),
 }
 
 assert!(Simple.source().is_none());
 assert!(request_ref::<Backtrace>(&Simple).is_none());
+
 assert!(WithSource::default().source().is_some());
+assert!(WithOptionalSource { source: Some(Simple) }.source().is_some());
+
 assert!(WithExplicitSource::default().source().is_some());
+assert!(WithExplicitOptionalSource { explicit_source: Some(Simple) }.source().is_some());
+
 assert!(Tuple::default().source().is_some());
+
 assert!(WithoutSource::default().source().is_none());
+
 let with_source_and_backtrace = WithSourceAndBacktrace {
     source: Simple,
     backtrace: Backtrace::capture(),
@@ -141,9 +202,16 @@ assert!(with_source_and_backtrace.source().is_some());
 assert!(request_ref::<Backtrace>(&with_source_and_backtrace).is_some());
 
 assert!(CompoundError::Simple.source().is_none());
+
 assert!(CompoundError::from(Simple).source().is_some());
+assert!(CompoundError::from(Some(Simple)).source().is_some());
+
 assert!(CompoundError::from(WithSource::default()).source().is_some());
+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(Tuple::default()).source().is_none());
 # }
 ```

impl/src/error.rs

@@ -43,7 +43,7 @@ pub fn expand(
             // TODO: Use `derive_more::core::error::Error` once `error_in_core` Rust feature is
             //       stabilized.
             fn source(&self) -> Option<&(dyn derive_more::with_trait::Error + 'static)> {
-                use derive_more::__private::AsDynError;
+                use derive_more::__private::AsDynError as _;
                 #source
             }
         }
@@ -207,13 +207,17 @@ 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 }))
+        Some(render_some(
+            quote! { (&#ident) },
+            self.data.field_types[source].is_option(),
+        ))
     }
 
     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 });
+        let expr =
+            render_some(quote! { source }, self.data.field_types[source].is_option());
         Some(quote! { #pattern => #expr })
     }
 
@@ -287,10 +291,10 @@ impl ParsedFields<'_, '_> {
     }
 }
 
-fn render_some<T>(expr: T) -> TokenStream
-where
-    T: quote::ToTokens,
-{
+fn render_some(mut expr: TokenStream, unpack: bool) -> TokenStream {
+    if unpack {
+        expr = quote! { derive_more::core::option::Option::as_ref(#expr)? }
+    }
     quote! { Some(#expr.as_dyn_error()) }
 }
 
@@ -500,6 +504,42 @@ fn add_bound_if_type_parameter_used_in_type(
     ty: &syn::Type,
 ) {
     if let Some(ty) = utils::get_if_type_parameter_used_in_type(type_params, ty) {
-        bounds.insert(ty);
+        bounds.insert(ty.get_option_inner().cloned().unwrap_or(ty));
+    }
+}
+
+/// Extension of a [`syn::Type`] used by this expansion.
+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 an [`Option`].
+    fn get_option_inner(&self) -> Option<&Self>;
+}
+
+impl TypeExt for syn::Type {
+    fn is_option(&self) -> bool {
+        self.get_option_inner().is_some()
+    }
+
+    fn get_option_inner(&self) -> 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")
+                .and_then(|s| {
+                    if let syn::PathArguments::AngleBracketed(a) = &s.arguments {
+                        if let Some(syn::GenericArgument::Type(ty)) = a.args.first() {
+                            return Some(ty);
+                        }
+                    }
+                    None
+                }),
+            _ => None,
+        }
     }
 }