Support errors with lifetimes to have a source - error-handling

Question

I have the following 3 errors, AError, BError and CError, where CError contains a borrowed string from some input, and AError is composed from either BError or CError, and thus has a lifetime too.
use std::error::Error;
use std::fmt;
#[derive(Debug)]
pub enum AError<'a> {
B(BError),
C(CError<'a>),
}
impl<'a> fmt::Display for AError<'a> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "AError")
}
}
impl<'a> Error for AError<'a> {
fn source(&self) -> Option<&(dyn Error + 'static)> {
match self {
AError::B(err) => Some(err),
AError::C(_) => None, // If I try to use `C(err) => Some(err)` it errors
}
}
}
#[derive(Debug)]
pub struct BError;
impl fmt::Display for BError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "BError")
}
}
impl Error for BError {}
#[derive(Debug)]
pub struct CError<'a> {
c: &'a str,
}
impl<'a> fmt::Display for CError<'a> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "CError: {}", self.c)
}
}
impl<'a> Error for CError<'a> {}
If I try to make A return C as a source error, I get the following error:
error[E0495]: cannot infer an appropriate lifetime due to conflicting requirements
--> src/lib.rs:18:15
|
18 | match self {
| ^^^^
|
note: first, the lifetime cannot outlive the lifetime `'a` as defined on the impl at 16:6...
--> src/lib.rs:16:6
|
16 | impl<'a> Error for AError<'a> {
| ^^
note: ...so that the types are compatible
--> src/lib.rs:18:15
|
18 | match self {
| ^^^^
= note: expected `&AError<'_>`
found `&AError<'a>`
= note: but, the lifetime must be valid for the static lifetime...
note: ...so that the expression is assignable
--> src/lib.rs:18:9
|
18 | / match self {
19 | | AError::B(err) => Some(err),
20 | | AError::C(err) => Some(err),
21 | | }
| |_________^
= note: expected `Option<&(dyn std::error::Error + 'static)>`
found `Option<&dyn std::error::Error>`
Which makes sense as source is declared with fn source(&self) -> Option<&(dyn Error + 'static)>.
I understand in order to be able to downcast, you must have a static reference, but all I want to do with it is print a backtrace of errors using source as such:
pub fn fmt_err(err: &dyn Error, f: &mut fmt::Formatter) -> fmt::Result {
writeln!(f, "{}", err)?;
if let Some(source) = err.source() {
fmt_err(source, f)?;
}
Ok(())
}
which doesn't require downcasting, simply uses the fact that fmt::Display is a super-trait of Error.
How can I make my errors with lifetimes support this type of usecase?
I know Error::cause exists, but it is deprecated and likely not intended for this use case and popular error deriving libraries (such as thiserror) likely don't implement it either, so I have to make do with source as my only way of getting an underlying error.
Is my only option to make my own trait and implement it for any errors with lifetimes?