`#[derive(Error)]` fails on enum variant with a lifetime.

[KSXGitHub]

Reproduction code

#![allow(unused)]

use derive_more::{Display, Error};

#[derive(Debug, Display, Error)]
pub struct Owned {
    #[error(not(source))]
    message: String,
}

#[derive(Debug, Display, Error)]
pub struct Borrowed<'a> {
    #[error(not(source))]
    message: &'a str,
}

#[derive(Debug, Display, Error)]
pub enum MyError<'a> {
    Owned(Owned),
    Borrowed(Borrowed<'a>),
}

Compilation error

error: lifetime may not live long enough
  --> src/tmp_err_report.rs:17:26
   |
17 | #[derive(Debug, Display, Error)]
   |                          ^^^^^ returning this value requires that `'a` must outlive `'static`
18 | pub enum MyError<'a> {
   |                  -- lifetime `'a` defined here
   |
   = note: this error originates in the derive macro `Error` (in Nightly builds, run with -Z macro-backtrace for more info)

Current workaround

Implement Error manually:

#[derive(Debug, Display)]
pub enum MyError<'a> {
    Owned(Owned),
    Borrowed(Borrowed<'a>),
}

impl<'a> core::error::Error for MyError<'a> {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            MyError::Owned(error) => error.source(),
            MyError::Borrowed(error) => error.source(),
        }
    }
}

[tyranron]

@KSXGitHub that's because the generated code is not equivalent with the manual implementation you've provided.

From the docs:

When and how does it derive source()?

1. It's a struct/variant with named fields and one is the fields is called source. Then it would return that field as the source.
2. It's a tuple struct/variant and there's exactly one field that is not used as the backtrace. So either a tuple struct with one field, or one with two where one is the backtrace. Then it returns this field as the source.
3. One of the fields is annotated with #[error(source)]. Then it would return that field as the source.

And so, the actual and intended expansion is:

impl<'a> derive_more::core::error::Error for MyError<'a> {
    fn source(&self) -> Option<&( dyn derive_more::core::error::Error + 'static   )> {
        use derive_more::__private::AsDynError   as _;
        match self {
            MyError::Owned(source) => Some(source.as_dyn_error()),
            MyError::Borrowed(source) => Some(source.as_dyn_error())
        }
    }
}

It returns the field itself as a source(), not the field.source(). This is the intended default behavior. And it simply doesn't suit your use case due to source() method signature. The motivation behind why such behavior is the default was mostly outlined here: #110 (comment)

Your use case could be supported if we've had the #[error(forward)] attribute (or similar) for enabling forwarding logic. Its implementation has stalled a little bit, due to uncertainty whether we should encourage such code. Your issue, however, is another reason why it should be implemented eventually.

See also #482, #293