Error causes can't be downcast

[brson]

Originally reported here: https://users.rust-lang.org/t/cant-to-introspect-error-cause/6536/2

Because cause doesn't return an Error bound by 'static you can't downcast it.

This seems like a significant oversight. Of course you want to be able to downcast that object.

[brson]

cc @Stebalien

[nikomatsakis]

cc me

[nikomatsakis]

This is definitely a bug in the trait as written. OTOH, it's a hard one to fix. Just adding the 'static bound would probably break tons of code.

I did have one thought -- though it probably won't work -- which is adding Any as a supertrait to Error. Seems worth experimenting with, though I guess there must be some people that implement Error for types that are not 'static.

[nikomatsakis]

Another possibility might be deprecating the existing method and adding a new one, I guess (with a default). But it'll be a drag to deal with, particularly since there is no way to "bridge" from the old implementation.

[aturon]

cc me

[aturon]

I think what happened here is that we had Error: Any initially (which implies 'static), but that was replaced with Reflect. Sadly, it seems there weren't any tests of the downcasting functionality...

It's definitely worth a crater run with adding a 'static bound, to see how widespread the problem is.

[Stebalien]

So, I'm worried about generic errors that return values to the programmer (e.g. PoisonError). Such a change would break std. However, as Reflect is unstable, generic errors defined without the help of unstable features will bound their generic parameter with T: Any, not T: Reflect. This implies T: 'static.

Unfortunately, this logic does not apply to errors that return values of non-generic types that just happen to not have static lifetimes.

[alexcrichton]

Possible routes to solve:

• Replace Reflect with Any
• Add 'static to the trait object returned by Error
• Add cause2 which cause calls by default
• Add Error2, an entirely new trait

We'll be using crater here to figure out what to possibly do here.

[alexcrichton]

I don't think we can replace the Reflect bound with Any, too many regressions: https://gist.github.com/alexcrichton/ed5c565611351adbf2a34687b2972cc7

I also don't think we can add 'static to the trait object returned by Error as it'll break anyone who's previously written fn cause. I think at this point we're moving into the territory of "need a whole new error trait" or "need a whole new method"

[antoyo]

This issue happens even when not using cause.
For instance:

use std::error::Error;
use std::fmt::{self, Display, Formatter};

#[derive(Debug)]
struct MyError { }

impl Error for MyError {
    fn description(&self) -> &str {
        "description"
    }
}

impl Display for MyError {
    fn fmt(&self, formatter: &mut Formatter) -> Result<(), fmt::Error> {
        write!(formatter, "description")
    }
}

fn main() {
    let error: Box<Error> = From::from(Box::new(MyError {}));
    let downcasted = error.downcast_ref::<MyError>();
    println!("{:?}", downcasted); // WRONG: prints None.

    let error: Box<Error> = Box::new(MyError {});
    let downcasted = error.downcast_ref::<MyError>();
    println!("{:?}", downcasted); // OK: prints Some(MyError).
}

[Stebalien]

@antoyo That's because you're double boxing. The correct code is:

use std::error::Error;
use std::fmt::{self, Display, Formatter};

#[derive(Debug)]
struct MyError { }

impl Error for MyError {
    fn description(&self) -> &str {
    "description"
}
}

impl Display for MyError {
    fn fmt(&self, formatter: &mut Formatter) -> Result<(), fmt::Error> {
        write!(formatter, "description")
    }
}

fn main() {
    let error: Box<Error> = From::from(Box::new(MyError {}));
    let downcasted = error.downcast_ref::<Box<MyError>>(); // Downcast to `Box<MyError>`
    println!("{:?}", downcasted); 

    let error: Box<Error> = Box::new(MyError {});
    let downcasted = error.downcast_ref::<MyError>();
    println!("{:?}", downcasted); // OK: prints Some(MyError).
}

However, this is extremely confusing and magical.