yaahc/eyre - Change MDCKAPJFOWFR5HBN3CU6ZGKYXP3QND5H5IV53ZKT34HPTR3YAEDAC

Switch report handler to a global hook (#29) * Switch report handler to a global hook * more cleanup * remove default from example * remove broken support for no_std * back out the unneeded nostd check * remove one stackframe when capturing a Handler * update docs and prep for release * port lib.rs docs updates to readme

Created by Jane Lusby on July 5, 2020

MDCKAPJFOWFR5HBN3CU6ZGKYXP3QND5H5IV53ZKT34HPTR3YAEDAC

Dependencies

In channels

main

Change contents

Replacement in Cargo.toml at line 3 [5.13]

B:BD[4.14] → [3.0:53]

version = "0.5.0" # remember to update html_root_url

[4.14]

[6.53]

version = "0.6.0" # remember to update html_root_url

Deletion in Cargo.toml at line 13 [5.13]
∅:D[7.56] → [8.1:39]
B:BD[8.1] → [8.1:39]
B:BD[8.39] → [9.0:1]
```
[features]
default = ["std"]
std = []
```
Insertion in Cargo.toml at line 23 [5.13]
[10.978]
[11.57]
```
once_cell = "1.4.0"
```

Replacement in README.md at line 15 [13.12]

B:BD[6.5393] → [12.54:197]

This crate is a fork of [`anyhow`] by @dtolnay with a support for customized
`Reports`. For more details on customization checkout the docs on

[6.5393]

[14.356]

This crate is a fork of [`anyhow`]  with a support for customized
error reports. For more details on customization checkout the docs on

Deletion in README.md at line 19 [13.12]
B:BD[10.1003] → [14.380:403]
B:BD[14.403] → [3.54:67]
∅:D[3.67] → [14.416:420]
B:BD[14.416] → [14.416:420]
∅:D[14.420] → [10.1022:1023]
B:BD[10.1022] → [10.1022:1023]
```
```toml
[dependencies]
eyre = "0.5"
```
```

Replacement in README.md at line 21 [13.12]

B:BD[14.448] → [14.448:526]

The heart of this crate is its ability to swap out the Handler type to change

[14.448]

[10.1102]

The heart of this crate is it's ability to swap out the Handler type to change

Replacement in README.md at line 24 [13.12]

B:BD[10.1247] → [14.527:602]

customize its behavior. Below is a list of known crates that export report

[10.1247]

[14.602]

customize it's behavior. Below is a list of known crates that export report

Replacement in README.md at line 34 [13.12]

B:BD[10.1853] → [10.1853:1926]

  out the README on [`color-eyre`] for screenshots of the report format.

[10.1853]

[14.709]

  out the README on [`color-eyre`] for details on the report format.

Replacement in README.md at line 37 [13.12]

B:BD[10.2074] → [14.781:895]

- [`jane-eyre`]: A a report handler crate that exists purely for the pun.
Currently just re-exports `color-eyre`.

[10.2074]

[15.3091]

- [`jane-eyre`]: A report handler crate that exists purely for the pun.
  Currently just re-exports `color-eyre`.

Replacement in README.md at line 151 [13.12]

B:BD[16.252] → [3.68:121]

eyre = { version = "0.5", default-features = false }

[16.252]

[16.307]

eyre = { version = "0.6", default-features = false }

Replacement in README.md at line 170 [13.12]

B:BD[13.436] → [17.314:389]

∅:D[17.389] → [18.106:330]

B:BD[18.106] → [18.106:330]

Use Eyre if you don't care what error type your functions return, you just
want it to be easy. This is common in application code. Use [thiserror] if you
are a library that wants to design your own dedicated error type(s) so that on
failures the caller gets exactly the information that you choose.

[13.436]

[18.330]

Use `eyre` if you don't think you'll do anything with an error other than
report it. This is common in application code. Use `thiserror` if you think
you need an error type that can be handled via match or reported. This is
common in library crates where you don't know how your users will handle
your errors.

Replacement in README.md at line 182 [13.12]
B:BD[12.564] → [12.564:574]
```
`anyhow`.
```
[12.564]
[19.45]
```
`anyhow`, though there are some differences still.
```

Deletion in README.md at line 184 [13.12]

B:BD[19.46] → [19.46:249]

∅:D[19.249] → [20.88:89]

∅:D[12.574] → [20.88:89]

B:BD[20.88] → [20.88:89]

B:BD[20.89] → [19.250:424]

∅:D[21.55] → [20.302:311]

∅:D[19.424] → [20.302:311]

∅:D[12.773] → [20.302:311]

B:BD[20.302] → [20.302:311]

B:BD[20.311] → [19.425:446]

∅:D[19.446] → [20.311:320]

B:BD[20.311] → [20.311:320]

B:BD[20.320] → [19.447:536]

∅:D[22.83] → [20.402:406]

∅:D[19.536] → [20.402:406]

B:BD[20.402] → [20.402:406]

∅:D[20.406] → [18.387:388]

B:BD[18.387] → [18.387:388]

B:BD[18.388] → [20.407:486]

B:BD[20.486] → [14.896:974]

∅:D[14.974] → [20.564:687]

B:BD[20.564] → [20.564:687]

B:BD[20.687] → [19.537:575]

∅:D[19.575] → [20.695:705]

B:BD[20.695] → [20.695:705]

B:BD[20.705] → [19.576:659]

∅:D[22.165] → [20.785:795]

∅:D[19.659] → [20.785:795]

B:BD[20.785] → [20.785:795]

B:BD[20.795] → [19.660:756]

There are two main incompatibilities that you might encounter when porting a
codebase from `anyhow` to `eyre`:
- type inference errors when using `eyre!`
- `.context` not being implemented for `Option`
#### Type Inference Errors
The type inference issue is caused by the generic parameter, which isn't
present in `anyhow::Error`. Specifically, the following works in anyhow:
```rust
use anyhow::anyhow;
// Works
let val = get_optional_val().ok_or_else(|| anyhow!("failed to get value")).unwrap_err();
```
Where as with `eyre!` this will fail due to being unable to infer the type for
the Handler parameter. The solution to this problem, should you encounter it,
is to give the compiler a hint for what type it should be resolving to, either
via your return type or a type annotation.
```rust,compile_fail
use eyre::eyre;
// Broken
let val = get_optional_val().ok_or_else(|| eyre!("failed to get value")).unwrap();
// Works
let val: Report = get_optional_val().ok_or_else(|| eyre!("failed to get value")).unwrap();
```

Replacement in README.md at line 212 [13.12]

B:BD[19.1565] → [19.1565:1639]

However, to help with porting we do provide a `ContextCompat` trait which

[19.1565]

[19.1639]

**NOTE**: However, to help with porting we do provide a `ContextCompat` trait which

Deletion in build.rs at line 38 [24.11]

B:BD[23.941] → [2.0:54]

    if !cfg!(feature = "std") {
        return;
    }

File addition: custom_handler.rs (----------)

[25.88]

use backtrace::Backtrace;
use eyre::EyreHandler;
use std::error::Error;
use std::{fmt, iter};
fn main() -> eyre::Result<()> {
    // Install our custom eyre report hook for constructing our custom Handlers
    install().unwrap();
    // construct a report with, hopefully, our custom handler!
    let mut report = eyre::eyre!("hello from custom error town!");
    // manually set the custom msg for this report after it has been constructed
    if let Some(handler) = report.handler_mut().downcast_mut::<Handler>() {
        handler.custom_msg = Some("you're the best users, you know that right???");
    }
    // print that shit!!
    Err(report)
}
// define a handler that captures backtraces unless told not to
fn install() -> Result<(), impl Error> {
    let capture_backtrace = std::env::var("RUST_BACKWARDS_TRACE")
        .map(|val| val != "0")
        .unwrap_or(true);
    let hook = Hook { capture_backtrace };
    eyre::set_hook(Box::new(move |e| Box::new(hook.make_handler(e))))
}
struct Hook {
    capture_backtrace: bool,
}
impl Hook {
    fn make_handler(&self, _error: &(dyn Error + 'static)) -> Handler {
        let backtrace = if self.capture_backtrace {
            Some(Backtrace::new())
        } else {
            None
        };
        Handler {
            backtrace,
            custom_msg: None,
        }
    }
}
struct Handler {
    // custom configured backtrace capture
    backtrace: Option<Backtrace>,
    // customizable message payload associated with reports
    custom_msg: Option<&'static str>,
}
impl EyreHandler for Handler {
    fn debug(&self, error: &(dyn Error + 'static), f: &mut fmt::Formatter<'_>) -> fmt::Result {
        if f.alternate() {
            return fmt::Debug::fmt(error, f);
        }
        let errors = iter::successors(Some(error), |error| error.source());
        for (ind, error) in errors.enumerate() {
            write!(f, "\n{:>4}: {}", ind, error)?;
        }
        if let Some(backtrace) = self.backtrace.as_ref() {
            writeln!(f, "\n\nBacktrace:\n{:?}", backtrace)?;
        }
        if let Some(msg) = self.custom_msg.as_ref() {
            writeln!(f, "\n\n{}", msg)?;
        }
        Ok(())
    }
}

Deletion in src/chain.rs at line 4 [27.11]
B:BD[26.93] → [26.93:117]
```
#[cfg(feature = "std")]
```
Deletion in src/chain.rs at line 6 [27.11]
B:BD[26.119] → [26.119:143]
```
#[cfg(feature = "std")]
```

Deletion in src/chain.rs at line 7 [27.11]

B:BD[26.172] → [26.172:261]


#[cfg(not(feature = "std"))]
pub(crate) struct Chain<'a> {
    state: ChainState<'a>,
}

Deletion in src/chain.rs at line 13 [27.11]
B:BD[28.180] → [26.262:290]
```
    #[cfg(feature = "std")]
```
Deletion in src/chain.rs at line 56 [27.11]
B:BD[28.450] → [26.291:327]
```
            #[cfg(feature = "std")]
```
Deletion in src/chain.rs at line 66 [27.11]
B:BD[28.508] → [26.328:352]
```
#[cfg(feature = "std")]
```
Deletion in src/chain.rs at line 96 [27.11]
B:BD[29.454] → [26.353:389]
```
            #[cfg(feature = "std")]
```
Deletion in src/chain.rs at line 101 [27.11]
B:BD[30.19] → [26.390:414]
```
#[cfg(feature = "std")]
```

Replacement in src/context.rs at line 2 [32.642]

B:BD[31.32] → [14.1050:1118]

use crate::{ContextCompat, EyreHandler, Report, StdError, WrapErr};

[31.32]

[33.31]

use crate::{ContextCompat, Report, StdError, WrapErr};

Replacement in src/context.rs at line 11 [32.642]
B:BD[34.29] → [14.1119:1145]
∅:D[14.1145] → [35.115:125]
B:BD[35.115] → [35.115:125]
B:BD[35.125] → [14.1146:1170]
∅:D[14.1170] → [35.149:155]
B:BD[35.149] → [35.149:155]
B:BD[35.155] → [14.1171:1223]
```
    pub trait StdError<H>
    where
        H: EyreHandler,
    {
        fn ext_report<D>(self, msg: D) -> Report<H>
```
[34.29]
[34.107]
```
    pub trait StdError {
        fn ext_report<D>(self, msg: D) -> Report
```
Replacement in src/context.rs at line 17 [32.642]
B:BD[32.1442] → [26.455:483]
B:BD[26.483] → [14.1224:1257]
```
    #[cfg(feature = "std")]
    impl<E, H> StdError<H> for E
```
[32.1442]
[36.174]
```
    impl<E> StdError for E
```
Deletion in src/context.rs at line 19 [32.642]
B:BD[36.184] → [14.1258:1282]
```
        H: EyreHandler,
```

Replacement in src/context.rs at line 21 [32.642]

B:BD[32.1587] → [14.1283:1335]

        fn ext_report<D>(self, msg: D) -> Report<H>

[32.1587]

[34.306]

        fn ext_report<D>(self, msg: D) -> Report

Replacement in src/context.rs at line 29 [32.642]
B:BD[34.451] → [14.1336:1374]
∅:D[37.1297] → [35.367:377]
∅:D[14.1374] → [35.367:377]
B:BD[35.367] → [35.367:377]
B:BD[35.377] → [14.1375:1399]
∅:D[14.1399] → [35.401:407]
B:BD[35.401] → [35.401:407]
B:BD[35.407] → [14.1400:1452]
```
    impl<H> StdError<H> for Report<H>
    where
        H: EyreHandler,
    {
        fn ext_report<D>(self, msg: D) -> Report<H>
```
[34.451]
[34.534]
```
    impl StdError for Report {
        fn ext_report<D>(self, msg: D) -> Report
```
Replacement in src/context.rs at line 39 [32.642]
B:BD[32.1686] → [14.1453:1501]
```
impl<T, E, H> WrapErr<T, E, H> for Result<T, E>
```
[32.1686]
[34.693]
```
impl<T, E> WrapErr<T, E> for Result<T, E>
```

Replacement in src/context.rs at line 41 [32.642]

B:BD[34.699] → [14.1502:1571]

    H: EyreHandler,
    E: ext::StdError<H> + Send + Sync + 'static,

[34.699]

[34.745]

    E: ext::StdError + Send + Sync + 'static,

Replacement in src/context.rs at line 43 [32.642]

B:BD[34.747] → [14.1572:1629]

    fn wrap_err<D>(self, msg: D) -> Result<T, Report<H>>

[34.747]

[38.447]

    fn wrap_err<D>(self, msg: D) -> Result<T, Report>

Replacement in src/context.rs at line 50 [32.642]

B:BD[32.1924] → [14.1630:1695]

    fn wrap_err_with<D, F>(self, msg: F) -> Result<T, Report<H>>

[32.1924]

[36.436]

    fn wrap_err_with<D, F>(self, msg: F) -> Result<T, Report>

Replacement in src/context.rs at line 58 [32.642]

B:BD[12.827] → [14.1696:1752]

    fn context<D>(self, msg: D) -> Result<T, Report<H>>

[12.827]

[12.883]

    fn context<D>(self, msg: D) -> Result<T, Report>

Replacement in src/context.rs at line 65 [32.642]

B:BD[12.972] → [14.1753:1817]

    fn with_context<D, F>(self, msg: F) -> Result<T, Report<H>>

[12.972]

[12.1036]

    fn with_context<D, F>(self, msg: F) -> Result<T, Report>

Replacement in src/context.rs at line 74 [32.642]
B:BD[19.2421] → [14.1818:1863]
∅:D[14.1863] → [19.2466:2472]
B:BD[19.2466] → [19.2466:2472]
B:BD[19.2472] → [14.1864:1884]
∅:D[14.1884] → [19.2492:2494]
B:BD[19.2492] → [19.2492:2494]
B:BD[19.2494] → [14.1885:1942]
```
impl<T, H> ContextCompat<T, H> for Option<T>
where
    H: EyreHandler,
{
    fn wrap_err<D>(self, msg: D) -> Result<T, Report<H>>
```
[19.2421]
[19.2551]
```
impl<T> ContextCompat<T> for Option<T> {
    fn wrap_err<D>(self, msg: D) -> Result<T, Report>
```

Replacement in src/context.rs at line 82 [32.642]

B:BD[19.2644] → [14.1943:2008]

    fn wrap_err_with<D, F>(self, msg: F) -> Result<T, Report<H>>

[19.2644]

[19.2709]

    fn wrap_err_with<D, F>(self, msg: F) -> Result<T, Report>

Replacement in src/context.rs at line 90 [32.642]

B:BD[19.2833] → [14.2009:2065]

    fn context<D>(self, msg: D) -> Result<T, Report<H>>

[19.2833]

[19.2889]

    fn context<D>(self, msg: D) -> Result<T, Report>

Replacement in src/context.rs at line 97 [32.642]

B:BD[19.3010] → [14.2066:2130]

    fn with_context<D, F>(self, msg: F) -> Result<T, Report<H>>

[19.3010]

[19.3074]

    fn with_context<D, F>(self, msg: F) -> Result<T, Report>

Replacement in src/context.rs at line 143 [32.642]
B:BD[32.2904] → [14.2131:2182]
```
impl<D, H> StdError for ContextError<D, Report<H>>
```
[32.2904]
[38.793]
```
impl<D> StdError for ContextError<D, Report>
```
Deletion in src/context.rs at line 145 [32.642]
B:BD[38.799] → [14.2183:2203]
```
    H: EyreHandler,
```
Replacement in src/context.rs at line 175 [32.642]
B:BD[39.214] → [14.2204:2244]
```
    pub trait Sealed<H: EyreHandler> {}
```
[39.214]
[39.238]
```
    pub trait Sealed {}
```

Replacement in src/context.rs at line 177 [32.642]

B:BD[39.239] → [14.2245:2387]

    impl<T, E, H: EyreHandler> Sealed<H> for Result<T, E> where E: ext::StdError<H> {}
    impl<T, H: EyreHandler> Sealed<H> for Option<T> {}

[39.239]

[32.3220]

    impl<T, E> Sealed for Result<T, E> where E: ext::StdError {}
    impl<T> Sealed for Option<T> {}

Deletion in src/error.rs at line 1 [32.3238]
B:BD[32.3238] → [26.524:547]
```
use crate::alloc::Box;
```
Deletion in src/error.rs at line 9 [32.3238]
∅:D[40.378] → [26.605:629]
B:BD[26.605] → [26.605:629]
```
#[cfg(feature = "std")]
```
Replacement in src/error.rs at line 11 [32.3238]
B:BD[32.3932] → [14.2413:2431]
∅:D[37.1577] → [41.1831:1837]
∅:D[14.2431] → [41.1831:1837]
B:BD[41.1831] → [41.1831:1837]
B:BD[41.1837] → [14.2432:2452]
∅:D[14.2452] → [41.1857:1859]
B:BD[41.1857] → [41.1857:1859]
```
impl<H> Report<H>
where
    H: EyreHandler,
{
```
[32.3932]
[42.0]
```
impl Report {
```
Deletion in src/error.rs at line 19 [32.3238]
B:BD[43.327] → [26.664:692]
B:BD[26.692] → [11.933:985]
```
    #[cfg(feature = "std")]
    #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
```
Deletion in src/error.rs at line 70 [32.3238]
B:BD[44.102] → [26.693:721]
```
    #[cfg(feature = "std")]
```

Replacement in src/error.rs at line 75 [32.3238]

B:BD[45.36] → [14.2453:2543]

∅:D[41.2075] → [26.722:758]

∅:D[14.2543] → [26.722:758]

B:BD[45.175] → [26.722:758]

B:BD[26.758] → [14.2544:2747]

            object_drop: object_drop::<E, H>,
            object_ref: object_ref::<E, H>,
            #[cfg(feature = "std")]
            object_mut: object_mut::<E, H>,
            object_boxed: object_boxed::<E, H>,
            object_downcast: object_downcast::<E, H>,
            object_drop_rest: object_drop_front::<E, H>,

[45.36]

[45.300]

            object_drop: object_drop::<E>,
            object_ref: object_ref::<E>,
            object_mut: object_mut::<E>,
            object_boxed: object_boxed::<E>,
            object_downcast: object_downcast::<E>,
            object_drop_rest: object_drop_front::<E>,

Replacement in src/error.rs at line 84 [32.3238]

B:BD[45.381] → [14.2748:2796]

        let handler = Some(H::default(&error));

[45.381]

[14.2796]

        let handler = Some(crate::capture_handler(&error));

Replacement in src/error.rs at line 96 [32.3238]

B:BD[45.480] → [14.2858:2976]

∅:D[41.2507] → [26.802:838]

∅:D[14.2976] → [26.802:838]

B:BD[45.661] → [26.802:838]

B:BD[26.838] → [14.2977:3208]

            object_drop: object_drop::<MessageError<M>, H>,
            object_ref: object_ref::<MessageError<M>, H>,
            #[cfg(feature = "std")]
            object_mut: object_mut::<MessageError<M>, H>,
            object_boxed: object_boxed::<MessageError<M>, H>,
            object_downcast: object_downcast::<M, H>,
            object_drop_rest: object_drop_front::<M, H>,

[45.480]

[45.814]

            object_drop: object_drop::<MessageError<M>>,
            object_ref: object_ref::<MessageError<M>>,
            object_mut: object_mut::<MessageError<M>>,
            object_boxed: object_boxed::<MessageError<M>>,
            object_downcast: object_downcast::<M>,
            object_drop_rest: object_drop_front::<M>,

Replacement in src/error.rs at line 106 [32.3238]

B:BD[45.962] → [14.3209:3257]

        let handler = Some(H::default(&error));

[45.962]

[14.3257]

        let handler = Some(crate::capture_handler(&error));

Replacement in src/error.rs at line 118 [32.3238]

B:BD[19.3806] → [14.3319:3437]

∅:D[14.3437] → [19.3924:3960]

B:BD[19.3924] → [19.3924:3960]

B:BD[19.3960] → [14.3438:3669]

            object_drop: object_drop::<DisplayError<M>, H>,
            object_ref: object_ref::<DisplayError<M>, H>,
            #[cfg(feature = "std")]
            object_mut: object_mut::<DisplayError<M>, H>,
            object_boxed: object_boxed::<DisplayError<M>, H>,
            object_downcast: object_downcast::<M, H>,
            object_drop_rest: object_drop_front::<M, H>,

[19.3806]

[19.4191]

            object_drop: object_drop::<DisplayError<M>>,
            object_ref: object_ref::<DisplayError<M>>,
            object_mut: object_mut::<DisplayError<M>>,
            object_boxed: object_boxed::<DisplayError<M>>,
            object_downcast: object_downcast::<M>,
            object_drop_rest: object_drop_front::<M>,

Replacement in src/error.rs at line 128 [32.3238]

B:BD[19.4339] → [14.3670:3722]

        let handler = Some(H::default(&NoneError));

[19.4339]

[14.3722]

        let handler = Some(crate::capture_handler(&NoneError));

Deletion in src/error.rs at line 133 [32.3238]
B:BD[31.88] → [26.919:947]
```
    #[cfg(feature = "std")]
```

Replacement in src/error.rs at line 141 [32.3238]

B:BD[46.323] → [14.3784:3908]

∅:D[41.3561] → [26.948:984]

∅:D[14.3908] → [26.948:984]

B:BD[46.513] → [26.948:984]

B:BD[26.984] → [14.3909:4153]

            object_drop: object_drop::<ContextError<D, E>, H>,
            object_ref: object_ref::<ContextError<D, E>, H>,
            #[cfg(feature = "std")]
            object_mut: object_mut::<ContextError<D, E>, H>,
            object_boxed: object_boxed::<ContextError<D, E>, H>,
            object_downcast: context_downcast::<D, E, H>,
            object_drop_rest: context_drop_rest::<D, E, H>,

[46.323]

[46.689]

            object_drop: object_drop::<ContextError<D, E>>,
            object_ref: object_ref::<ContextError<D, E>>,
            object_mut: object_mut::<ContextError<D, E>>,
            object_boxed: object_boxed::<ContextError<D, E>>,
            object_downcast: context_downcast::<D, E>,
            object_drop_rest: context_drop_rest::<D, E>,

Replacement in src/error.rs at line 150 [32.3238]

B:BD[46.768] → [14.4154:4202]

        let handler = Some(H::default(&error));

[46.768]

[14.4202]

        let handler = Some(crate::capture_handler(&error));

Deletion in src/error.rs at line 155 [32.3238]
B:BD[32.4612] → [26.985:1013]
```
    #[cfg(feature = "std")]
```

Replacement in src/error.rs at line 158 [32.3238]

B:BD[47.234] → [14.4264:4312]

        let handler = Some(H::default(&error));

[47.234]

        let handler = Some(crate::capture_handler(&error));

Replacement in src/error.rs at line 161 [32.3238]

B:BD[47.270] → [14.4313:4421]

∅:D[41.3971] → [26.1055:1091]

∅:D[14.4421] → [26.1055:1091]

B:BD[47.372] → [26.1055:1091]

B:BD[26.1091] → [14.4422:4703]

            object_drop: object_drop::<BoxedError, H>,
            object_ref: object_ref::<BoxedError, H>,
            #[cfg(feature = "std")]
            object_mut: object_mut::<BoxedError, H>,
            object_boxed: object_boxed::<BoxedError, H>,
            object_downcast: object_downcast::<Box<dyn StdError + Send + Sync>, H>,
            object_drop_rest: object_drop_front::<Box<dyn StdError + Send + Sync>, H>,

[47.270]

[47.641]

            object_drop: object_drop::<BoxedError>,
            object_ref: object_ref::<BoxedError>,
            object_mut: object_mut::<BoxedError>,
            object_boxed: object_boxed::<BoxedError>,
            object_downcast: object_downcast::<Box<dyn StdError + Send + Sync>>,
            object_drop_rest: object_drop_front::<Box<dyn StdError + Send + Sync>>,

Replacement in src/error.rs at line 179 [32.3238]

B:BD[45.1710] → [14.4766:4864]

    unsafe fn construct<E>(error: E, vtable: &'static ErrorVTable<H>, handler: Option<H>) -> Self

[45.1710]

[36.910]

    unsafe fn construct<E>(
        error: E,
        vtable: &'static ErrorVTable,
        handler: Option<Box<dyn EyreHandler>>,
    ) -> Self

Replacement in src/error.rs at line 198 [32.3238]

B:BD[48.458] → [14.4887:4978]

        let erased = mem::transmute::<Box<ErrorImpl<E, H>>, Box<ErrorImpl<(), H>>>(inner);

[48.458]

[49.212]

        let erased = mem::transmute::<Box<ErrorImpl<E>>, Box<ErrorImpl<()>>>(inner);

Replacement in src/error.rs at line 261 [32.3238]

B:BD[14.5028] → [14.5028:5111]

        let error: ContextError<D, Report<H>> = ContextError { msg, error: self };

[14.5028]

[50.47]

        let error: ContextError<D, Report> = ContextError { msg, error: self };

Replacement in src/error.rs at line 264 [32.3238]

B:BD[50.84] → [14.5112:5252]

∅:D[37.2516] → [26.1092:1128]

∅:D[4.3131] → [26.1092:1128]

∅:D[41.4829] → [26.1092:1128]

∅:D[14.5252] → [26.1092:1128]

B:BD[50.286] → [26.1092:1128]

B:BD[26.1128] → [14.5253:5519]

            object_drop: object_drop::<ContextError<D, Report<H>>, H>,
            object_ref: object_ref::<ContextError<D, Report<H>>, H>,
            #[cfg(feature = "std")]
            object_mut: object_mut::<ContextError<D, Report<H>>, H>,
            object_boxed: object_boxed::<ContextError<D, Report<H>>, H>,
            object_downcast: context_chain_downcast::<D, H>,
            object_drop_rest: context_chain_drop_rest::<D, H>,

[50.84]

[50.474]

            object_drop: object_drop::<ContextError<D, Report>>,
            object_ref: object_ref::<ContextError<D, Report>>,
            object_mut: object_mut::<ContextError<D, Report>>,
            object_boxed: object_boxed::<ContextError<D, Report>>,
            object_downcast: context_chain_downcast::<D>,
            object_drop_rest: context_chain_drop_rest::<D>,

Deletion in src/error.rs at line 297 [32.3238]
B:BD[51.422] → [26.1129:1157]
```
    #[cfg(feature = "std")]
```
Deletion in src/error.rs at line 306 [32.3238]
∅:D[37.2990] → [26.1158:1186]
∅:D[4.3700] → [26.1158:1186]
B:BD[52.230] → [26.1158:1186]
```
    #[cfg(feature = "std")]
```

Replacement in src/error.rs at line 426 [32.3238]

B:BD[14.5638] → [14.5638:5717]

    pub fn handler(&self) -> &H {
        self.inner.handler.as_ref().unwrap()

[14.5638]

[53.291]

    pub fn handler(&self) -> &dyn EyreHandler {
        self.inner.handler.as_ref().unwrap().as_ref()

Replacement in src/error.rs at line 431 [32.3238]

B:BD[14.5782] → [14.5782:5873]

    pub fn handler_mut(&mut self) -> &mut H {
        self.inner.handler.as_mut().unwrap()

[14.5782]

[14.5873]

    pub fn handler_mut(&mut self) -> &mut dyn EyreHandler {
        self.inner.handler.as_mut().unwrap().as_mut()

Replacement in src/error.rs at line 437 [32.3238]

B:BD[14.5955] → [14.5955:6034]

    pub fn context(&self) -> &H {
        self.inner.handler.as_ref().unwrap()

[14.5955]

[32.7472]

    pub fn context(&self) -> &dyn EyreHandler {
        self.inner.handler.as_ref().unwrap().as_ref()

Replacement in src/error.rs at line 443 [32.3238]

B:BD[14.6119] → [14.6119:6210]

    pub fn context_mut(&mut self) -> &mut H {
        self.inner.handler.as_mut().unwrap()

[14.6119]

[14.6210]

    pub fn context_mut(&mut self) -> &mut dyn EyreHandler {
        self.inner.handler.as_mut().unwrap().as_mut()

Replacement in src/error.rs at line 448 [32.3238]
B:BD[32.7481] → [26.1187:1211]
B:BD[26.1211] → [14.6217:6250]
```
#[cfg(feature = "std")]
impl<E, H> From<E> for Report<H>
```
[32.7481]
[38.1305]
```
impl<E> From<E> for Report
```
Deletion in src/error.rs at line 450 [32.3238]
B:BD[38.1311] → [14.6251:6271]
```
    H: EyreHandler,
```
Replacement in src/error.rs at line 457 [32.3238]
B:BD[32.7620] → [26.1212:1236]
B:BD[26.1236] → [14.6272:6315]
```
#[cfg(feature = "std")]
impl<H: EyreHandler> Deref for Report<H> {
```
[32.7620]
[54.1503]
```
impl Deref for Report {
```
Replacement in src/error.rs at line 465 [32.3238]
B:BD[32.7775] → [26.1237:1261]
B:BD[26.1261] → [14.6316:6362]
```
#[cfg(feature = "std")]
impl<H: EyreHandler> DerefMut for Report<H> {
```
[32.7775]
[32.7805]
```
impl DerefMut for Report {
```
Replacement in src/error.rs at line 471 [32.3238]
B:BD[32.7896] → [14.6363:6408]
```
impl<H: EyreHandler> Display for Report<H> {
```
[32.7896]
[19.4432]
```
impl Display for Report {
```
Replacement in src/error.rs at line 477 [32.3238]
B:BD[32.8843] → [14.6409:6452]
```
impl<H: EyreHandler> Debug for Report<H> {
```
[32.8843]
[19.4504]
```
impl Debug for Report {
```
Replacement in src/error.rs at line 483 [32.3238]
B:BD[32.8984] → [14.6453:6480]
∅:D[37.3413] → [41.5639:5645]
∅:D[14.6480] → [41.5639:5645]
B:BD[41.5639] → [41.5639:5645]
B:BD[41.5645] → [14.6481:6501]
∅:D[14.6501] → [41.5665:5667]
B:BD[41.5665] → [41.5665:5667]
```
impl<H> Drop for Report<H>
where
    H: EyreHandler,
{
```
[32.8984]
[32.9081]
```
impl Drop for Report {
```

Replacement in src/error.rs at line 496 [32.3238]

B:BD[55.174] → [14.6502:6524]

∅:D[14.6524] → [41.5690:5696]

B:BD[41.5690] → [41.5690:5696]

B:BD[41.5696] → [14.6525:6545]

∅:D[40.732] → [41.5720:5722]

∅:D[14.6545] → [41.5720:5722]

B:BD[41.5720] → [41.5720:5722]

B:BD[41.5722] → [14.6546:6686]

∅:D[41.5862] → [26.1262:1290]

∅:D[14.6686] → [26.1262:1290]

B:BD[56.169] → [26.1262:1290]

B:BD[26.1290] → [14.6687:6784]

struct ErrorVTable<H>
where
    H: EyreHandler,
{
    object_drop: unsafe fn(Box<ErrorImpl<(), H>>),
    object_ref: unsafe fn(&ErrorImpl<(), H>) -> &(dyn StdError + Send + Sync + 'static),
    #[cfg(feature = "std")]
    object_mut: unsafe fn(&mut ErrorImpl<(), H>) -> &mut (dyn StdError + Send + Sync + 'static),

[55.174]

[57.0]

struct ErrorVTable {
    object_drop: unsafe fn(Box<ErrorImpl<()>>),
    object_ref: unsafe fn(&ErrorImpl<()>) -> &(dyn StdError + Send + Sync + 'static),
    object_mut: unsafe fn(&mut ErrorImpl<()>) -> &mut (dyn StdError + Send + Sync + 'static),

Replacement in src/error.rs at line 501 [32.3238]

B:BD[57.38] → [14.6785:7028]

    object_boxed: unsafe fn(Box<ErrorImpl<(), H>>) -> Box<dyn StdError + Send + Sync + 'static>,
    object_downcast: unsafe fn(&ErrorImpl<(), H>, TypeId) -> Option<NonNull<()>>,
    object_drop_rest: unsafe fn(Box<ErrorImpl<(), H>>, TypeId),

[57.38]

[49.520]

    object_boxed: unsafe fn(Box<ErrorImpl<()>>) -> Box<dyn StdError + Send + Sync + 'static>,
    object_downcast: unsafe fn(&ErrorImpl<()>, TypeId) -> Option<NonNull<()>>,
    object_drop_rest: unsafe fn(Box<ErrorImpl<()>>, TypeId),

Replacement in src/error.rs at line 507 [32.3238]
B:BD[48.1435] → [14.7029:7083]
∅:D[14.7083] → [41.6258:6264]
B:BD[41.6258] → [41.6258:6264]
B:BD[41.6264] → [14.7084:7104]
∅:D[14.7104] → [41.6284:6286]
B:BD[41.6284] → [41.6284:6286]
```
unsafe fn object_drop<E, H>(e: Box<ErrorImpl<(), H>>)
where
    H: EyreHandler,
{
```
[48.1435]
[49.573]
```
unsafe fn object_drop<E>(e: Box<ErrorImpl<()>>) {
```

Replacement in src/error.rs at line 510 [32.3238]

B:BD[49.695] → [14.7105:7190]

    let unerased = mem::transmute::<Box<ErrorImpl<(), H>>, Box<ErrorImpl<E, H>>>(e);

[49.695]

[58.448]

    let unerased = mem::transmute::<Box<ErrorImpl<()>>, Box<ErrorImpl<E>>>(e);

Replacement in src/error.rs at line 515 [32.3238]
B:BD[48.1492] → [14.7191:7267]
∅:D[14.7267] → [41.6449:6455]
B:BD[41.6449] → [41.6449:6455]
B:BD[41.6455] → [14.7268:7288]
∅:D[14.7288] → [41.6475:6477]
B:BD[41.6475] → [41.6475:6477]
```
unsafe fn object_drop_front<E, H>(e: Box<ErrorImpl<(), H>>, target: TypeId)
where
    H: EyreHandler,
{
```
[48.1492]
[58.527]
```
unsafe fn object_drop_front<E>(e: Box<ErrorImpl<()>>, target: TypeId) {
```

Replacement in src/error.rs at line 520 [32.3238]

B:BD[59.615] → [14.7289:7388]

    let unerased = mem::transmute::<Box<ErrorImpl<(), H>>, Box<ErrorImpl<ManuallyDrop<E>, H>>>(e);

[59.615]

[49.774]

    let unerased = mem::transmute::<Box<ErrorImpl<()>>, Box<ErrorImpl<ManuallyDrop<E>>>>(e);

Replacement in src/error.rs at line 525 [32.3238]

B:BD[48.1549] → [14.7389:7481]

unsafe fn object_ref<E, H>(e: &ErrorImpl<(), H>) -> &(dyn StdError + Send + Sync + 'static)

[48.1549]

[55.451]

unsafe fn object_ref<E>(e: &ErrorImpl<()>) -> &(dyn StdError + Send + Sync + 'static)

Deletion in src/error.rs at line 527 [32.3238]
B:BD[55.457] → [14.7482:7502]
```
    H: EyreHandler,
```

Replacement in src/error.rs at line 530 [32.3238]

B:BD[48.1623] → [14.7503:7576]

    &(*(e as *const ErrorImpl<(), H> as *const ErrorImpl<E, H>))._object

[48.1623]

[32.9174]

    &(*(e as *const ErrorImpl<()> as *const ErrorImpl<E>))._object

Replacement in src/error.rs at line 534 [32.3238]

B:BD[48.1680] → [26.1291:1315]

B:BD[26.1315] → [14.7577:7677]

#[cfg(feature = "std")]
unsafe fn object_mut<E, H>(e: &mut ErrorImpl<(), H>) -> &mut (dyn StdError + Send + Sync + 'static)

[48.1680]

[55.606]

unsafe fn object_mut<E>(e: &mut ErrorImpl<()>) -> &mut (dyn StdError + Send + Sync + 'static)

Deletion in src/error.rs at line 536 [32.3238]
B:BD[55.612] → [14.7678:7698]
```
    H: EyreHandler,
```

Replacement in src/error.rs at line 539 [32.3238]

B:BD[48.1754] → [14.7699:7772]

    &mut (*(e as *mut ErrorImpl<(), H> as *mut ErrorImpl<E, H>))._object

[48.1754]

[60.305]

    &mut (*(e as *mut ErrorImpl<()> as *mut ErrorImpl<E>))._object

Replacement in src/error.rs at line 543 [32.3238]

B:BD[48.1811] → [14.7773:7873]

unsafe fn object_boxed<E, H>(e: Box<ErrorImpl<(), H>>) -> Box<dyn StdError + Send + Sync + 'static>

[48.1811]

[60.402]

unsafe fn object_boxed<E>(e: Box<ErrorImpl<()>>) -> Box<dyn StdError + Send + Sync + 'static>

Deletion in src/error.rs at line 545 [32.3238]
B:BD[60.408] → [14.7874:7894]
```
    H: EyreHandler,
```
Deletion in src/error.rs at line 546 [32.3238]
B:BD[60.449] → [14.7895:7925]
```
    H: Send + Sync + 'static,
```

Replacement in src/error.rs at line 548 [32.3238]

B:BD[48.1893] → [14.7926:7995]

    mem::transmute::<Box<ErrorImpl<(), H>>, Box<ErrorImpl<E, H>>>(e)

[48.1893]

[61.1375]

    mem::transmute::<Box<ErrorImpl<()>>, Box<ErrorImpl<E>>>(e)

Replacement in src/error.rs at line 552 [32.3238]

B:BD[48.1950] → [14.7996:8089]

unsafe fn object_downcast<E, H>(e: &ErrorImpl<(), H>, target: TypeId) -> Option<NonNull<()>>

[48.1950]

[45.2035]

unsafe fn object_downcast<E>(e: &ErrorImpl<()>, target: TypeId) -> Option<NonNull<()>>

Deletion in src/error.rs at line 554 [32.3238]
B:BD[45.2041] → [14.8090:8110]
```
    H: EyreHandler,
```

Replacement in src/error.rs at line 559 [32.3238]

B:BD[48.2062] → [14.8111:8190]

        let unerased = e as *const ErrorImpl<(), H> as *const ErrorImpl<E, H>;

[48.2062]

[62.165]

        let unerased = e as *const ErrorImpl<()> as *const ErrorImpl<E>;

Replacement in src/error.rs at line 568 [32.3238]

∅:D[41.7453] → [26.1316:1340]

B:BD[48.2136] → [26.1316:1340]

B:BD[26.1340] → [14.8191:8288]

#[cfg(feature = "std")]
unsafe fn context_downcast<D, E, H>(e: &ErrorImpl<(), H>, target: TypeId) -> Option<NonNull<()>>

[41.7453]

[59.865]

unsafe fn context_downcast<D, E>(e: &ErrorImpl<()>, target: TypeId) -> Option<NonNull<()>>

Deletion in src/error.rs at line 570 [32.3238]
B:BD[59.871] → [14.8289:8309]
```
    H: EyreHandler,
```

Replacement in src/error.rs at line 574 [32.3238]

B:BD[41.7626] → [14.8310:8406]

        let unerased = e as *const ErrorImpl<(), H> as *const ErrorImpl<ContextError<D, E>, H>;

[41.7626]

[41.7722]

        let unerased = e as *const ErrorImpl<()> as *const ErrorImpl<ContextError<D, E>>;

Replacement in src/error.rs at line 578 [32.3238]

B:BD[59.1190] → [14.8407:8503]

        let unerased = e as *const ErrorImpl<(), H> as *const ErrorImpl<ContextError<D, E>, H>;

[59.1190]

[62.303]

        let unerased = e as *const ErrorImpl<()> as *const ErrorImpl<ContextError<D, E>>;

Replacement in src/error.rs at line 587 [32.3238]

∅:D[41.7961] → [26.1341:1365]

B:BD[48.2210] → [26.1341:1365]

B:BD[26.1365] → [14.8504:8583]

#[cfg(feature = "std")]
unsafe fn context_drop_rest<D, E, H>(e: Box<ErrorImpl<(), H>>, target: TypeId)

[41.7961]

[59.1500]

unsafe fn context_drop_rest<D, E>(e: Box<ErrorImpl<()>>, target: TypeId)

Deletion in src/error.rs at line 589 [32.3238]
B:BD[59.1506] → [14.8584:8604]
```
    H: EyreHandler,
```

Replacement in src/error.rs at line 596 [32.3238]

B:BD[59.1746] → [14.8605:8705]

            Box<ErrorImpl<(), H>>,
            Box<ErrorImpl<ContextError<ManuallyDrop<D>, E>, H>>,

[59.1746]

[59.1840]

            Box<ErrorImpl<()>>,
            Box<ErrorImpl<ContextError<ManuallyDrop<D>, E>>>,

Replacement in src/error.rs at line 602 [32.3238]

B:BD[59.1932] → [14.8706:8806]

            Box<ErrorImpl<(), H>>,
            Box<ErrorImpl<ContextError<D, ManuallyDrop<E>>, H>>,

[59.1932]

[63.465]

            Box<ErrorImpl<()>>,
            Box<ErrorImpl<ContextError<D, ManuallyDrop<E>>>>,

Replacement in src/error.rs at line 610 [32.3238]

B:BD[37.3492] → [14.8807:8907]

unsafe fn context_chain_downcast<D, H>(e: &ErrorImpl<(), H>, target: TypeId) -> Option<NonNull<()>>

[37.3492]

[63.980]

unsafe fn context_chain_downcast<D>(e: &ErrorImpl<()>, target: TypeId) -> Option<NonNull<()>>

Deletion in src/error.rs at line 612 [32.3238]
B:BD[63.986] → [14.8908:8928]
```
    H: EyreHandler,
```

Replacement in src/error.rs at line 615 [32.3238]

B:BD[41.8654] → [40.733:756]

B:BD[40.756] → [14.8929:9022]

        let unerased =
            e as *const ErrorImpl<(), H> as *const ErrorImpl<ContextError<D, Report<H>>, H>;

[41.8654]

[41.8761]

        let unerased = e as *const ErrorImpl<()> as *const ErrorImpl<ContextError<D, Report>>;

Replacement in src/error.rs at line 620 [32.3238]

B:BD[48.2361] → [40.853:876]

B:BD[40.876] → [14.9023:9116]

        let unerased =
            e as *const ErrorImpl<(), H> as *const ErrorImpl<ContextError<D, Report<H>>, H>;

[48.2361]

[62.497]

        let unerased = e as *const ErrorImpl<()> as *const ErrorImpl<ContextError<D, Report>>;

Replacement in src/error.rs at line 627 [32.3238]

B:BD[37.3759] → [14.9117:9199]

unsafe fn context_chain_drop_rest<D, H>(e: Box<ErrorImpl<(), H>>, target: TypeId)

[37.3759]

[63.1558]

unsafe fn context_chain_drop_rest<D>(e: Box<ErrorImpl<()>>, target: TypeId)

Deletion in src/error.rs at line 629 [32.3238]
B:BD[63.1564] → [14.9200:9220]
```
    H: EyreHandler,
```

Replacement in src/error.rs at line 635 [32.3238]

B:BD[63.1800] → [14.9221:9329]

            Box<ErrorImpl<(), H>>,
            Box<ErrorImpl<ContextError<ManuallyDrop<D>, Report<H>>, H>>,

[63.1800]

[59.2026]

            Box<ErrorImpl<()>>,
            Box<ErrorImpl<ContextError<ManuallyDrop<D>, Report>>>,

Replacement in src/error.rs at line 642 [32.3238]

B:BD[63.1953] → [14.9330:9438]

            Box<ErrorImpl<(), H>>,
            Box<ErrorImpl<ContextError<D, ManuallyDrop<Report<H>>>, H>>,

[63.1953]

[63.2051]

            Box<ErrorImpl<()>>,
            Box<ErrorImpl<ContextError<D, ManuallyDrop<Report>>>>,

Replacement in src/error.rs at line 656 [32.3238]
B:BD[32.9247] → [14.9439:9473]
∅:D[14.9473] → [41.9514:9520]
B:BD[41.9514] → [41.9514:9520]
B:BD[41.9520] → [14.9474:9494]
∅:D[14.9494] → [41.9540:9542]
B:BD[41.9540] → [41.9540:9542]
B:BD[41.9542] → [14.9495:9567]
```
pub(crate) struct ErrorImpl<E, H>
where
    H: EyreHandler,
{
    vtable: &'static ErrorVTable<H>,
    pub(crate) handler: Option<H>,
```
[32.9247]
[59.2132]
```
pub(crate) struct ErrorImpl<E> {
    vtable: &'static ErrorVTable,
    pub(crate) handler: Option<Box<dyn EyreHandler>>,
```
Replacement in src/error.rs at line 672 [32.3238]
B:BD[32.9886] → [14.9568:9595]
∅:D[14.9595] → [41.9821:9827]
B:BD[41.9821] → [41.9821:9827]
B:BD[41.9827] → [14.9596:9616]
∅:D[14.9616] → [41.9847:9849]
B:BD[41.9847] → [41.9847:9849]
B:BD[41.9849] → [14.9617:9660]
```
impl<E, H> ErrorImpl<E, H>
where
    H: EyreHandler,
{
    fn erase(&self) -> &ErrorImpl<(), H> {
```
[32.9886]
[48.2672]
```
impl<E> ErrorImpl<E> {
    fn erase(&self) -> &ErrorImpl<()> {
```

Replacement in src/error.rs at line 677 [32.3238]

B:BD[48.2859] → [14.9661:9742]

        unsafe { &*(self as *const ErrorImpl<E, H> as *const ErrorImpl<(), H>) }

[48.2859]

[64.139]

        unsafe { &*(self as *const ErrorImpl<E> as *const ErrorImpl<()>) }

Replacement in src/error.rs at line 681 [32.3238]
B:BD[65.1798] → [14.9743:9768]
∅:D[14.9768] → [41.10000:10006]
B:BD[41.10000] → [41.10000:10006]
B:BD[41.10006] → [14.9769:9789]
∅:D[14.9789] → [41.10026:10028]
B:BD[41.10026] → [41.10026:10028]
```
impl<H> ErrorImpl<(), H>
where
    H: EyreHandler,
{
```
[65.1798]
[66.0]
```
impl ErrorImpl<()> {
```
Deletion in src/error.rs at line 688 [32.3238]
B:BD[32.10202] → [26.1366:1394]
```
    #[cfg(feature = "std")]
```
Replacement in src/error.rs at line 699 [32.3238]
B:BD[60.2159] → [14.9790:9830]
```
impl<E, H> StdError for ErrorImpl<E, H>
```
[60.2159]
[64.182]
```
impl<E> StdError for ErrorImpl<E>
```
Deletion in src/error.rs at line 701 [32.3238]
B:BD[64.188] → [14.9831:9851]
```
    H: EyreHandler,
```
Replacement in src/error.rs at line 708 [32.3238]
B:BD[60.2215] → [14.9852:9889]
```
impl<E, H> Debug for ErrorImpl<E, H>
```
[60.2215]
[60.2246]
```
impl<E> Debug for ErrorImpl<E>
```
Deletion in src/error.rs at line 710 [32.3238]
B:BD[60.2252] → [14.9890:9910]
```
    H: EyreHandler,
```
Replacement in src/error.rs at line 717 [32.3238]
B:BD[60.2465] → [14.9911:9950]
```
impl<E, H> Display for ErrorImpl<E, H>
```
[60.2465]
[60.2498]
```
impl<E> Display for ErrorImpl<E>
```
Deletion in src/error.rs at line 719 [32.3238]
B:BD[60.2504] → [14.9951:9971]
```
    H: EyreHandler,
```

Replacement in src/error.rs at line 726 [32.3238]

B:BD[60.2643] → [14.9972:10097]

impl<H: EyreHandler> From<Report<H>> for Box<dyn StdError + Send + Sync + 'static> {
    fn from(error: Report<H>) -> Self {

[60.2643]

[60.2744]

impl From<Report> for Box<dyn StdError + Send + Sync + 'static> {
    fn from(error: Report) -> Self {

Replacement in src/error.rs at line 742 [32.3238]

B:BD[67.9] → [14.10098:10209]

impl<H: EyreHandler> From<Report<H>> for Box<dyn StdError + 'static> {
    fn from(error: Report<H>) -> Self {

[67.9]

[67.96]

impl From<Report> for Box<dyn StdError + 'static> {
    fn from(error: Report) -> Self {

Replacement in src/error.rs at line 748 [32.3238]

B:BD[68.9] → [26.1395:1419]

B:BD[26.1419] → [14.10210:10281]

#[cfg(feature = "std")]
impl<H: EyreHandler> AsRef<dyn StdError + Send + Sync> for Report<H> {

[68.9]

[68.60]

impl AsRef<dyn StdError + Send + Sync> for Report {

Replacement in src/error.rs at line 754 [32.3238]
B:BD[68.151] → [26.1420:1444]
B:BD[26.1444] → [14.10282:10339]
```
#[cfg(feature = "std")]
impl<H: EyreHandler> AsRef<dyn StdError> for Report<H> {
```
[68.151]
[68.188]
```
impl AsRef<dyn StdError> for Report {
```
Deletion in src/fmt.rs at line 2 [66.270]
B:BD[66.300] → [14.10340:10364]
```
use crate::EyreHandler;
```
Replacement in src/fmt.rs at line 4 [66.270]
B:BD[66.330] → [14.10365:10390]
∅:D[14.10390] → [41.10803:10809]
B:BD[41.10803] → [41.10803:10809]
B:BD[41.10809] → [14.10391:10411]
∅:D[14.10411] → [41.10829:10831]
B:BD[41.10829] → [41.10829:10831]
```
impl<H> ErrorImpl<(), H>
where
    H: EyreHandler,
{
```
[66.330]
[19.4816]
```
impl ErrorImpl<()> {
```
Replacement in src/kind.rs at line 48 [70.10]
B:BD[69.1632] → [14.10578:10612]
```
use crate::{EyreHandler, Report};
```
[69.1632]
[33.275]
```
use crate::Report;
```
Deletion in src/kind.rs at line 51 [70.10]
B:BD[26.1472] → [26.1472:1496]
```
#[cfg(feature = "std")]
```

Replacement in src/kind.rs at line 65 [70.10]

B:BD[70.369] → [14.10613:10678]

    pub fn new<M, H: EyreHandler>(self, message: M) -> Report<H>

[70.369]

[70.414]

    pub fn new<M>(self, message: M) -> Report

Replacement in src/kind.rs at line 73 [70.10]
B:BD[70.540] → [3.122:172]
```
pub struct Trait<H>(std::marker::PhantomData<H>);
```
[70.540]
[70.558]
```
pub struct Trait;
```
Replacement in src/kind.rs at line 75 [70.10]
B:BD[70.559] → [3.173:205]
```
pub trait TraitKind<H>: Sized {
```
[70.559]
[70.588]
```
pub trait TraitKind: Sized {
```

Replacement in src/kind.rs at line 77 [70.10]

B:BD[70.602] → [3.206:284]

    fn eyre_kind(&self) -> Trait<H> {
        Trait(std::marker::PhantomData)

[70.602]

[70.653]

    fn eyre_kind(&self) -> Trait {
        Trait

Replacement in src/kind.rs at line 82 [70.10]

B:BD[70.662] → [3.285:369]

impl<E, H> TraitKind<H> for E
where
    E: Into<Report<H>>,
    H: EyreHandler,
{
}

[70.662]

[70.731]

impl<E> TraitKind for E where E: Into<Report> {}

Replacement in src/kind.rs at line 84 [70.10]

B:BD[70.732] → [3.370:436]

impl<H> Trait<H> {
    pub fn new<E>(self, error: E) -> Report<H>

[70.732]

[70.788]

impl Trait {
    pub fn new<E>(self, error: E) -> Report

Replacement in src/kind.rs at line 87 [70.10]

B:BD[70.798] → [3.437:489]

        E: Into<Report<H>>,
        H: EyreHandler,

[70.798]

[70.843]

        E: Into<Report>,

Deletion in src/kind.rs at line 93 [70.10]
B:BD[47.912] → [26.1518:1542]
```
#[cfg(feature = "std")]
```
Deletion in src/kind.rs at line 95 [70.10]
B:BD[47.931] → [26.1543:1567]
```
#[cfg(feature = "std")]
```
Deletion in src/kind.rs at line 102 [70.10]
B:BD[47.1027] → [26.1568:1592]
```
#[cfg(feature = "std")]
```
Deletion in src/kind.rs at line 104 [70.10]
B:BD[47.1082] → [26.1593:1617]
```
#[cfg(feature = "std")]
```

Replacement in src/kind.rs at line 105 [70.10]

B:BD[47.1095] → [14.10679:10771]

    pub fn new<H: EyreHandler>(self, error: Box<dyn StdError + Send + Sync>) -> Report<H> {

[47.1095]

[37.5048]

    pub fn new(self, error: Box<dyn StdError + Send + Sync>) -> Report {

Deletion in src/kind.rs at line 107 [70.10]

B:BD[37.5082] → [3.490:991]

    }
}
#[cfg(test)]
mod test {
    use super::*;
    use crate::eyre;
    use std::num::ParseIntError;
    struct NonDefaultHandler;
    impl EyreHandler for NonDefaultHandler {
        #[allow(unused_variables)]
        fn default(error: &(dyn StdError + 'static)) -> Self {
            Self
        }
        fn debug(
            &self,
            _error: &(dyn StdError + 'static),
            _f: &mut core::fmt::Formatter<'_>,
        ) -> core::fmt::Result {
            Ok(())
        }

Deletion in src/kind.rs at line 108 [70.10]

B:BD[3.997] → [3.997:1078]

∅:D[3.1078] → [47.1264:1270]

∅:D[37.5082] → [47.1264:1270]

∅:D[4.6128] → [47.1264:1270]

∅:D[41.11167] → [47.1264:1270]

B:BD[47.1264] → [47.1264:1270]

B:BD[47.1270] → [3.1079:1298]


    fn _parse(s: &str) -> Result<i32, ParseIntError> {
        s.parse::<i32>()
    }
    fn _throw_error() -> Result<(), Report<NonDefaultHandler>> {
        match _parse("abc") {
            Ok(_) => Ok(()),
            Err(e) => Err(eyre!(e).wrap_err("try parsing an actual number")),
        }
    }

Replacement in src/lib.rs at line 5 [32.11888]

B:BD[71.562] → [10.2525:2676]

//! This crate is a fork of [`anyhow`] by @dtolnay with a support for customized
//! `Reports`. For more details on customization checkout the docs on

[71.562]

[14.10944]

//! This crate is a fork of [`anyhow`]  with a support for customized
//! error reports. For more details on customization checkout the docs on

Replacement in src/lib.rs at line 11 [32.11888]

B:BD[10.2708] → [14.11003:11085]

//! The heart of this crate is its ability to swap out the Handler type to change

[10.2708]

[10.2818]

//! The heart of this crate is it's ability to swap out the Handler type to change

Replacement in src/lib.rs at line 14 [32.11888]

B:BD[10.2971] → [14.11086:11165]

//! customize its behavior. Below is a list of known crates that export report

[10.2971]

[14.11165]

//! customize it's behavior. Below is a list of known crates that export report

Replacement in src/lib.rs at line 24 [32.11888]

B:BD[10.3616] → [10.3616:3693]

//!   out the README on [`color-eyre`] for screenshots of the report format.

[10.3616]

[14.11280]

//!   out the README on [`color-eyre`] for details on the report format.

Replacement in src/lib.rs at line 27 [32.11888]

B:BD[10.3849] → [14.11356:11478]

//! - [`jane-eyre`]: A a report handler crate that exists purely for the pun.
//! Currently just re-exports `color-eyre`.

[10.3849]

[10.3970]

//! - [`jane-eyre`]: A report handler crate that exists purely for the pun.
//!   Currently just re-exports `color-eyre`.

Replacement in src/lib.rs at line 209 [32.11888]

B:BD[16.887] → [3.1299:1356]

//! eyre = { version = "0.5", default-features = false }

[16.887]

[16.946]

//! eyre = { version = "0.6", default-features = false }

Replacement in src/lib.rs at line 228 [32.11888]

B:BD[14.13647] → [14.13647:13962]

//! Use Eyre if you don't care what error type your functions return, you just
//! want it to be easy. This is common in application code. Use [thiserror] if you
//! are a library that wants to design your own dedicated error type(s) so that on
//! failures the caller gets exactly the information that you choose.

[14.13647]

[14.13962]

//! Use `eyre` if you don't think you'll do anything with an error other than
//! report it. This is common in application code. Use `thiserror` if you think
//! you need an error type that can be handled via match or reported. This is
//! common in library crates where you don't know how your users will handle
//! your errors.

Replacement in src/lib.rs at line 240 [32.11888]
B:BD[12.1705] → [12.1705:1719]
```
//! `anyhow`.
```
[12.1705]
[12.1719]
```
//! `anyhow`, though there are some differences still.
```

Deletion in src/lib.rs at line 242 [32.11888]

B:BD[12.1723] → [19.5103:5518]

∅:D[19.5518] → [12.1933:1937]

B:BD[12.1933] → [12.1933:1937]

B:BD[12.1937] → [19.5519:5611]

∅:D[19.5611] → [12.1962:1975]

B:BD[12.1962] → [12.1962:1975]

B:BD[12.1975] → [19.5612:5705]

∅:D[19.5705] → [12.2062:2157]

B:BD[12.2062] → [12.2062:2157]

B:BD[12.2157] → [14.14021:14103]

∅:D[14.14103] → [12.2239:2398]

B:BD[12.2239] → [12.2239:2398]

B:BD[12.2398] → [19.5706:5782]

∅:D[19.5782] → [12.2398:2412]

B:BD[12.2398] → [12.2398:2412]

B:BD[12.2412] → [19.5783:5870]

∅:D[12.2497] → [72.416:420]

∅:D[19.5870] → [72.416:420]

B:BD[17.1820] → [72.416:420]

B:BD[72.420] → [12.2498:2511]

B:BD[12.2511] → [19.5871:5978]

//! There are two main incompatibilities that you might encounter when porting a
//! codebase from `anyhow` to `eyre`:
//!
//! - type inference errors when using `eyre!`
//! - `.context` not being implemented for `Option`
//!
//! #### Type Inference Errors
//!
//! The type inference issue is caused by the generic parameter, which isn't
//! present in `anyhow::Error`. Specifically, the following works in anyhow:
//!
//! ```rust
//! # fn get_optional_val() -> Option<()> { None };
//! use anyhow::anyhow;
//!
//! // Works
//! let val = get_optional_val().ok_or_else(|| anyhow!("failed to get value")).unwrap_err();
//! ```
//!
//! Where as with `eyre!` this will fail due to being unable to infer the type for
//! the Handler parameter. The solution to this problem, should you encounter it,
//! is to give the compiler a hint for what type it should be resolving to, either
//! via your return type or a type annotation.
//!
//! ```rust,compile_fail
//! use eyre::eyre;
//!
//! # fn get_optional_val() -> Option<()> { None };
//! // Broken
//! let val = get_optional_val().ok_or_else(|| eyre!("failed to get value")).unwrap();
//!
//! // Works
//! let val: Report = get_optional_val().ok_or_else(|| eyre!("failed to get value")).unwrap();
//! ```
//!

Replacement in src/lib.rs at line 270 [32.11888]

B:BD[19.6887] → [19.6887:6965]

//! However, to help with porting we do provide a `ContextCompat` trait which

[19.6887]

[19.6965]

//! **NOTE**: However, to help with porting we do provide a `ContextCompat` trait which

Replacement in src/lib.rs at line 286 [32.11888]

B:BD[10.4340] → [3.1357:1411]

#![doc(html_root_url = "https://docs.rs/eyre/0.5.0")]

[10.4340]

[19.7071]

#![doc(html_root_url = "https://docs.rs/eyre/0.6.0")]

Deletion in src/lib.rs at line 312 [32.11888]
∅:D[73.130] → [26.1618:1661]
∅:D[11.2404] → [26.1618:1661]
B:BD[24.1909] → [26.1618:1661]
```
#![cfg_attr(not(feature = "std"), no_std)]
```
Deletion in src/lib.rs at line 317 [32.11888]
B:BD[74.111] → [26.1662:1732]
∅:D[75.66] → [32.11912:11913]
∅:D[74.111] → [32.11912:11913]
∅:D[26.1732] → [32.11912:11913]
∅:D[24.1909] → [32.11912:11913]
B:BD[32.11912] → [32.11912:11913]
B:BD[32.11913] → [26.1733:1766]
B:BD[26.1766] → [19.7566:7604]
∅:D[19.7604] → [26.1797:1826]
B:BD[26.1797] → [26.1797:1826]
B:BD[26.1826] → [19.7605:7641]
∅:D[19.7641] → [40.1173:1207]
B:BD[26.1855] → [40.1173:1207]
B:BD[40.1207] → [19.7642:7684]
∅:D[19.7684] → [40.1242:1243]
B:BD[40.1242] → [40.1242:1243]
B:BD[40.1243] → [19.7685:7759]
∅:D[40.1304] → [26.1855:1857]
∅:D[19.7759] → [26.1855:1857]
B:BD[26.1855] → [26.1855:1857]
```
mod alloc {
    #[cfg(not(feature = "std"))]
    extern crate alloc;
    #[cfg(not(feature = "std"))]
    pub(crate) use alloc::boxed::Box;
    #[cfg(feature = "std")]
    pub(crate) use std::boxed::Box;
    #[cfg(not(feature = "std"))]
    pub(crate) use alloc::string::String;
    // #[cfg(feature = "std")]
    // pub(crate) use std::string::String;
}
```
Deletion in src/lib.rs at line 328 [32.11888]
B:BD[32.12396] → [26.1859:1882]
```
use crate::alloc::Box;
```
Deletion in src/lib.rs at line 333 [32.11888]
B:BD[26.1884] → [26.1884:1935]
∅:D[33.362] → [76.0:1]
∅:D[26.1935] → [76.0:1]
B:BD[77.155] → [76.0:1]
B:BD[76.1] → [26.1936:1960]
```
#[cfg(not(feature = "std"))]
use core::fmt::Debug;
#[cfg(feature = "std")]
```
Deletion in src/lib.rs at line 335 [32.11888]
B:BD[26.1996] → [26.1996:2025]
B:BD[26.2025] → [40.1370:1408]
∅:D[40.1408] → [26.2059:2141]
B:BD[26.2059] → [26.2059:2141]
```
#[cfg(not(feature = "std"))]
pub trait StdError: Debug + Display {
    fn source(&self) -> Option<&(dyn StdError + 'static)> {
        None
    }
}
```
Insertion in src/lib.rs at line 338 [32.11888]
[12.2752]
[14.14238]
```
use once_cell::sync::OnceCell;
```

Replacement in src/lib.rs at line 418 [32.11888]

B:BD[78.2047] → [78.2047:2153]

B:BD[78.2153] → [35.1198:1231]

∅:D[79.576] → [78.2188:2422]

∅:D[35.1231] → [78.2188:2422]

∅:D[4.7809] → [78.2188:2422]

B:BD[78.2188] → [78.2188:2422]

/// to render the error and its cause chain yourself, it can be done something
/// like this:
///
/// ```
/// use eyre::{WrapErr, Result};
///
/// fn main() {
///     if let Err(err) = try_main() {
///         eprintln!("ERROR: {}", err);
///         err.chain().skip(1).for_each(|cause| eprintln!("because: {}", cause));
///         std::process::exit(1);
///     }
/// }

[78.2047]

[78.2422]

/// to render the error and its cause chain yourself, it can be done by defining
/// your own [`EyreHandler`] and [`hook`] to use it.

Replacement in src/lib.rs at line 421 [32.11888]

B:BD[78.2426] → [78.2426:2560]

B:BD[78.2560] → [14.14447:14485]

∅:D[37.6776] → [41.11355:11361]

∅:D[14.14485] → [41.11355:11361]

B:BD[41.11355] → [41.11355:11361]

B:BD[41.11361] → [14.14486:14506]

∅:D[14.14506] → [41.11381:11383]

B:BD[41.11381] → [41.11381:11383]

B:BD[41.11383] → [14.14507:14555]

/// fn try_main() -> Result<()> {
///     # const IGNORE: &str = stringify! {
///     ...
///     # };
///     # Ok(())
/// }
/// ```
pub struct Report<H = DefaultHandler>
where
    H: EyreHandler,
{
    inner: ManuallyDrop<Box<ErrorImpl<(), H>>>,

[78.2426]

[41.11431]

/// [`EyreHandler`]: trait.EyreHandler.html
/// [`hook`]: fn.set_hook.html
pub struct Report {
    inner: ManuallyDrop<Box<ErrorImpl<()>>>,
}
type ErrorHook =
    Box<dyn Fn(&(dyn StdError + 'static)) -> Box<dyn EyreHandler> + Sync + Send + 'static>;
static HOOK: OnceCell<ErrorHook> = OnceCell::new();
/// Error indicating that `set_hook` was unable to install the provided ErrorHook
#[derive(Debug)]
pub struct InstallError;
impl core::fmt::Display for InstallError {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.write_str("cannot install provided ErrorHook, a hook has already been installed")
    }

Replacement in src/lib.rs at line 442 [32.11888]

B:BD[41.11434] → [14.14556:14618]

/// Error Report Handler trait for customizing `eyre::Report`

[41.11434]

[12.2991]

impl StdError for InstallError {}
/// Install the provided error hook for constructing EyreHandlers when converting
/// Errors to Reports

Replacement in src/lib.rs at line 447 [32.11888]
B:BD[12.2995] → [12.2995:3016]
```
/// ## Customization
```
[12.2995]
[12.3016]
```
/// # Details
```

Replacement in src/lib.rs at line 449 [32.11888]

B:BD[12.3020] → [14.14619:14744]

/// In order to insert your own custom context and report format you must first
/// implement the `eyre::EyreHandler` trait.

[12.3020]

[12.3132]

/// To customize the format and content of error reports from `eyre` you must
/// first define a new `EyreHandler` type to capture and store the extra context
/// and to define the format of how to display the chain of errors and this
/// stored context. Once this type has been defined you must also define a global
/// hook used to construct these handlers whenever `Report`s are constructed.

Replacement in src/lib.rs at line 455 [32.11888]
B:BD[12.3136] → [14.14745:14822]
∅:D[14.14822] → [12.3213:3255]
B:BD[12.3213] → [12.3213:3255]
```
/// Once you've defined a custom Handler type you can use it throughout your
/// application by defining a type alias.
```
[12.3136]
[12.3255]
```
/// # Examples
```
Replacement in src/lib.rs at line 457 [32.11888]
B:BD[12.3259] → [25.365:377]
```
/// ```rust
```
[12.3259]
[25.377]
```
/// ```rust,should_panic
```

Replacement in src/lib.rs at line 460 [32.11888]

∅:D[14.14850] → [25.434:486]

B:BD[25.434] → [25.434:486]

B:BD[25.486] → [19.7760:7788]

/// # use eyre::Chain;
/// # use std::error::Error;
/// use indenter::indented;

[14.14850]

[25.486]

/// use std::error::Error;
/// use std::{fmt, iter};
///
/// fn main() -> eyre::Result<()> {
///     // Install our custom eyre report hook for constructing our custom Handlers
///     install().unwrap();
///
///     // construct a report with, hopefully, our custom handler!
///     let mut report = eyre::eyre!("hello from custom error town!");
///
///     // manually set the custom msg for this report after it has been constructed
///     if let Some(handler) = report.handler_mut().downcast_mut::<Handler>() {
///         handler.custom_msg = Some("you're the best users, you know that right???");
///     }
///
///     // print that shit!!
///     Err(report)
/// }
///
/// // define a handler that captures backtraces unless told not to
/// fn install() -> Result<(), impl Error> {
///     let capture_backtrace = std::env::var("RUST_BACKWARDS_TRACE")
///         .map(|val| val != "0")
///         .unwrap_or(true);
///
///     let hook = Hook { capture_backtrace };
///
///     eyre::set_hook(Box::new(move |e| Box::new(hook.make_handler(e))))
/// }
///
/// struct Hook {
///     capture_backtrace: bool,
/// }

Replacement in src/lib.rs at line 494 [32.11888]

B:BD[25.490] → [14.14851:14876]

∅:D[14.14876] → [25.515:545]

B:BD[25.515] → [25.515:545]

/// pub struct Handler {
///     backtrace: Backtrace,

[25.490]

[25.545]

/// impl Hook {
///     fn make_handler(&self, _error: &(dyn Error + 'static)) -> Handler {
///         let backtrace = if self.capture_backtrace {
///             Some(Backtrace::new())
///         } else {
///             None
///         };
///
///         Handler {
///             backtrace,
///             custom_msg: None,
///         }
///     }
/// }
///
/// struct Handler {
///     // custom configured backtrace capture
///     backtrace: Option<Backtrace>,
///     // customizable message payload associated with reports
///     custom_msg: Option<&'static str>,

Replacement in src/lib.rs at line 517 [32.11888]

∅:D[14.14912] → [25.590:1452]

B:BD[25.590] → [25.590:1452]

B:BD[25.1452] → [19.7789:7857]

∅:D[19.7857] → [25.1536:1567]

B:BD[25.1536] → [25.1536:1567]

B:BD[25.1567] → [19.7858:7919]

∅:D[19.7919] → [25.1643:1850]

B:BD[25.1643] → [25.1643:1850]

///     // ...
/// #     #[allow(unused_variables)]
/// #     fn default(error: &(dyn Error + 'static)) -> Self {
/// #         let backtrace = Backtrace::new();
/// #         Self { backtrace }
/// #     }
/// #     fn debug(
/// #         &self,
/// #         error: &(dyn Error + 'static),
/// #         f: &mut core::fmt::Formatter<'_>,
/// #     ) -> core::fmt::Result {
/// #         use core::fmt::Write as _;
/// #         if f.alternate() {
/// #             return core::fmt::Debug::fmt(error, f);
/// #         }
/// #         write!(f, "{}", error)?;
/// #         if let Some(cause) = error.source() {
/// #             write!(f, "\n\nCaused by:")?;
/// #             let multiple = cause.source().is_some();
/// #             for (n, error) in Chain::new(cause).enumerate() {
/// #                 writeln!(f)?;
/// #                 if multiple {
/// #                     write!(indented(f).ind(n), "{}", error)?;
/// #                 } else {
/// #                     write!(indented(f), "{}", error)?;
/// #                 }
/// #             }
/// #         }
/// #         let backtrace = &self.backtrace;
/// #         write!(f, "\n\nStack backtrace:\n{:?}", backtrace)?;
/// #         Ok(())
/// #     }

[14.14912]

[25.1850]

///     fn debug(&self, error: &(dyn Error + 'static), f: &mut fmt::Formatter<'_>) -> fmt::Result {
///         if f.alternate() {
///             return fmt::Debug::fmt(error, f);
///         }
///
///         let errors = iter::successors(Some(error), |error| error.source());
///
///         for (ind, error) in errors.enumerate() {
///             write!(f, "\n{:>4}: {}", ind, error)?;
///         }
///
///         if let Some(backtrace) = self.backtrace.as_ref() {
///             writeln!(f, "\n\nBacktrace:\n{:?}", backtrace)?;
///         }
///
///         if let Some(msg) = self.custom_msg.as_ref() {
///             writeln!(f, "\n\n{}", msg)?;
///         }
///
///         Ok(())
///     }

Deletion in src/lib.rs at line 539 [32.11888]
∅:D[25.1856] → [12.3327:3331]
B:BD[12.3327] → [12.3327:3331]
B:BD[12.3331] → [14.14913:15030]
```
///
/// type Report = eyre::Report<Handler>;
/// type Result<T, E = eyre::Report<Handler>> = core::result::Result<T, E>;
```

Replacement in src/lib.rs at line 540 [32.11888]

B:BD[12.3442] → [14.15031:15154]

pub trait EyreHandler: Sized + Send + Sync + 'static {
    /// Default construct a `Handler` when constructing a `Report`.

[12.3442]

[12.3511]

pub fn set_hook(hook: ErrorHook) -> Result<(), InstallError> {
    HOOK.set(hook).map_err(|_| InstallError)
}
fn capture_handler(error: &(dyn StdError + 'static)) -> Box<dyn EyreHandler> {
    let hook = HOOK
        .get_or_init(|| Box::new(DefaultHandler::default_with))
        .as_ref();
    hook(error)
}
impl dyn EyreHandler {

Replacement in src/lib.rs at line 554 [32.11888]

B:BD[12.3519] → [12.3519:3724]

    /// This method provides a reference to the error being wrapped to support conditional
    /// capturing of context like `backtrace` depending on whether the source error already
    /// captured one.

[12.3519]

[12.3724]

    pub fn is<T: EyreHandler>(&self) -> bool {
        // Get `TypeId` of the type this function is instantiated with.
        let t = core::any::TypeId::of::<T>();
        // Get `TypeId` of the type in the trait object (`self`).
        let concrete = self.type_id();
        // Compare both `TypeId`s on equality.
        t == concrete
    }

Replacement in src/lib.rs at line 566 [32.11888]

B:BD[12.3732] → [12.3732:3750]

    /// # Example

[12.3732]

[12.3750]

    pub fn downcast_ref<T: EyreHandler>(&self) -> Option<&T> {
        if self.is::<T>() {
            unsafe { Some(&*(self as *const dyn EyreHandler as *const T)) }
        } else {
            None
        }
    }

Replacement in src/lib.rs at line 575 [32.11888]

B:BD[12.3758] → [25.1975:2025]

B:BD[25.2025] → [14.15155:15186]

∅:D[14.15186] → [25.2056:2114]

B:BD[25.2056] → [25.2056:2114]

∅:D[25.2114] → [12.3826:3834]

B:BD[12.3826] → [12.3826:3834]

B:BD[12.3834] → [14.15187:15216]

∅:D[14.15216] → [25.2115:2149]

B:BD[12.3888] → [25.2115:2149]

∅:D[25.2149] → [12.3930:3948]

B:BD[12.3930] → [12.3930:3948]

B:BD[12.3948] → [14.15217:15256]

∅:D[14.15256] → [25.2150:2191]

B:BD[12.3987] → [25.2150:2191]

∅:D[25.2191] → [12.4026:4090]

B:BD[12.4026] → [12.4026:4090]

B:BD[12.4090] → [25.2192:2242]

∅:D[25.2242] → [12.4271:4355]

B:BD[12.4271] → [12.4271:4355]

B:BD[12.4355] → [25.2243:2962]

B:BD[25.2962] → [19.7920:8002]

∅:D[19.8002] → [25.3050:3085]

B:BD[25.3050] → [25.3050:3085]

B:BD[25.3085] → [19.8003:8078]

∅:D[19.8078] → [25.3165:3400]

B:BD[25.3165] → [25.3165:3400]

∅:D[25.3400] → [12.4355:4365]

B:BD[12.4355] → [12.4355:4365]

B:BD[12.4373] → [12.4373:4385]

∅:D[12.4385] → [40.1409:1465]

B:BD[41.11489] → [40.1409:1465]

    /// ```rust
    /// use backtrace::Backtrace;
    /// use eyre::EyreHandler;
    /// # use eyre::Chain;
    /// use std::error::Error;
    ///
    /// pub struct Handler {
    ///     backtrace: Backtrace,
    /// }
    ///
    /// impl EyreHandler for Handler {
    /// #     #[allow(unused_variables)]
    ///     fn default(error: &(dyn Error + 'static)) -> Self {
    ///         let backtrace = Backtrace::new();
    ///
    ///         Self { backtrace }
    ///     }
    ///
    ///     // ...
    /// #     fn debug(
    /// #         &self,
    /// #         error: &(dyn Error + 'static),
    /// #         f: &mut core::fmt::Formatter<'_>,
    /// #     ) -> core::fmt::Result {
    /// #         use core::fmt::Write as _;
    /// #         if f.alternate() {
    /// #             return core::fmt::Debug::fmt(error, f);
    /// #         }
    /// #         write!(f, "{}", error)?;
    /// #         if let Some(cause) = error.source() {
    /// #             write!(f, "\n\nCaused by:")?;
    /// #             let multiple = cause.source().is_some();
    /// #             for (n, error) in Chain::new(cause).enumerate() {
    /// #                 writeln!(f)?;
    /// #                 if multiple {
    /// #                     write!(indenter::indented(f).ind(n), "{}", error)?;
    /// #                 } else {
    /// #                     write!(indenter::indented(f), "{}", error)?;
    /// #                 }
    /// #             }
    /// #         }
    /// #         let backtrace = &self.backtrace;
    /// #         write!(f, "\n\nStack backtrace:\n{:?}", backtrace)?;
    /// #         Ok(())
    /// #     }
    /// }
    /// ```
    fn default(err: &(dyn StdError + 'static)) -> Self;

[12.3758]

[12.4386]

    pub fn downcast_mut<T: EyreHandler>(&mut self) -> Option<&mut T> {
        if self.is::<T>() {
            unsafe { Some(&mut *(self as *mut dyn EyreHandler as *mut T)) }
        } else {
            None
        }
    }
}

Insertion in src/lib.rs at line 584 [32.11888]

[12.4387]

/// Error Report Handler trait for customizing `eyre::Report`
pub trait EyreHandler: core::any::Any + Send + Sync {

Deletion in src/lib.rs at line 604 [32.11888]

∅:D[14.15358] → [25.3628:3840]

B:BD[12.4591] → [25.3628:3840]

∅:D[25.3840] → [12.4591:4618]

B:BD[12.4591] → [12.4591:4618]

    /// #     #[allow(unused_variables)]
    /// #     fn default(error: &(dyn Error + 'static)) -> Self {
    /// #         let backtrace = Backtrace::new();
    /// #         Self { backtrace }
    /// #     }
    ///     // ...
    ///

Insertion in src/lib.rs at line 669 [32.11888]

[40.1786]

[19.8247]

}
impl DefaultHandler {
    #[allow(unused_variables)]
    fn default_with(error: &(dyn StdError + 'static)) -> Box<dyn EyreHandler> {
        let backtrace = backtrace_if_absent!(error);
        Box::new(Self { backtrace })
    }

Deletion in src/lib.rs at line 695 [32.11888]
∅:D[14.15579] → [80.0:90]
B:BD[41.11724] → [80.0:90]
∅:D[80.90] → [41.11792:11846]
∅:D[40.1847] → [41.11792:11846]
B:BD[41.11792] → [41.11792:11846]
B:BD[41.11846] → [40.1848:1875]
∅:D[40.1875] → [41.11893:11900]
B:BD[41.11893] → [41.11893:11900]
```
    #[allow(unused_variables)]
    fn default(error: &(dyn StdError + 'static)) -> Self {
        let backtrace = backtrace_if_absent!(error);
        Self { backtrace }
    }
```
Deletion in src/lib.rs at line 758 [32.11888]
B:BD[77.1141] → [26.2142:2166]
```
#[cfg(feature = "std")]
```
Replacement in src/lib.rs at line 764 [32.11888]
B:BD[32.12854] → [81.0:23]
```
/// `Result<T, Error>`
```
[32.12854]
[82.0]
```
/// type alias for `Result<T, Report>`
```

Replacement in src/lib.rs at line 812 [32.11888]

B:BD[83.667] → [14.15580:15657]

pub type Result<T, E = Report<DefaultHandler>> = core::result::Result<T, E>;

[83.667]

[84.83]

pub type Result<T, E = Report> = core::result::Result<T, E>;

Replacement in src/lib.rs at line 979 [32.11888]
B:BD[85.3492] → [14.15658:15714]
∅:D[14.15714] → [35.1579:1585]
B:BD[35.1579] → [35.1579:1585]
B:BD[35.1585] → [14.15715:15735]
∅:D[14.15735] → [35.1605:1607]
B:BD[35.1605] → [35.1605:1607]
```
pub trait WrapErr<T, E, H>: context::private::Sealed<H>
where
    H: EyreHandler,
{
```
[85.3492]
[17.2520]
```
pub trait WrapErr<T, E>: context::private::Sealed {
```

Replacement in src/lib.rs at line 981 [32.11888]

B:BD[17.2572] → [14.15736:15793]

    fn wrap_err<D>(self, msg: D) -> Result<T, Report<H>>

[17.2572]

[84.1425]

    fn wrap_err<D>(self, msg: D) -> Result<T, Report>

Replacement in src/lib.rs at line 987 [32.11888]

B:BD[84.1597] → [14.15794:15857]

    fn wrap_err_with<D, F>(self, f: F) -> Result<T, Report<H>>

[84.1597]

[12.6537]

    fn wrap_err_with<D, F>(self, f: F) -> Result<T, Report>

Replacement in src/lib.rs at line 993 [32.11888]

B:BD[12.6689] → [14.15858:15914]

    fn context<D>(self, msg: D) -> Result<T, Report<H>>

[12.6689]

[84.1655]

    fn context<D>(self, msg: D) -> Result<T, Report>

Replacement in src/lib.rs at line 998 [32.11888]

B:BD[12.6867] → [14.15915:15977]

    fn with_context<D, F>(self, f: F) -> Result<T, Report<H>>

[12.6867]

[19.9972]

    fn with_context<D, F>(self, f: F) -> Result<T, Report>

Replacement in src/lib.rs at line 1047 [32.11888]
B:BD[19.11613] → [14.15978:16037]
∅:D[14.16037] → [19.11672:11678]
B:BD[19.11672] → [19.11672:11678]
B:BD[19.11678] → [14.16038:16058]
∅:D[14.16058] → [19.11698:11700]
B:BD[19.11698] → [19.11698:11700]
```
pub trait ContextCompat<T, H>: context::private::Sealed<H>
where
    H: EyreHandler,
{
```
[19.11613]
[19.11700]
```
pub trait ContextCompat<T>: context::private::Sealed {
```

Replacement in src/lib.rs at line 1050 [32.11888]

B:BD[19.11831] → [14.16059:16115]

    fn context<D>(self, msg: D) -> Result<T, Report<H>>

[19.11831]

[19.11887]

    fn context<D>(self, msg: D) -> Result<T, Report>

Replacement in src/lib.rs at line 1056 [32.11888]

B:BD[19.12078] → [14.16116:16178]

    fn with_context<D, F>(self, f: F) -> Result<T, Report<H>>

[19.12078]

[19.12079]

    fn with_context<D, F>(self, f: F) -> Result<T, Report>

Replacement in src/lib.rs at line 1062 [32.11888]

B:BD[19.12241] → [14.16179:16236]

    fn wrap_err<D>(self, msg: D) -> Result<T, Report<H>>

[19.12241]

[12.6929]

    fn wrap_err<D>(self, msg: D) -> Result<T, Report>

Replacement in src/lib.rs at line 1067 [32.11888]

B:BD[19.12430] → [14.16237:16300]

    fn wrap_err_with<D, F>(self, f: F) -> Result<T, Report<H>>

[19.12430]

[19.12493]

    fn wrap_err_with<D, F>(self, f: F) -> Result<T, Report>

Replacement in src/lib.rs at line 1076 [32.11888]
B:BD[86.210] → [14.16301:16339]
```
    use crate::{EyreHandler, Report};
```
[86.210]
[33.424]
```
    use crate::Report;
```
Deletion in src/lib.rs at line 1079 [32.11888]
B:BD[86.269] → [40.2538:2609]
∅:D[40.2609] → [87.919:920]
∅:D[41.12466] → [87.919:920]
B:BD[87.919] → [87.919:920]
```
    //     #[cfg(backtrace)]
    //     use std::backtrace::Backtrace;
```
Deletion in src/lib.rs at line 1085 [32.11888]
B:BD[26.2263] → [26.2263:2295]
```
        #[cfg(feature = "std")]
```

Replacement in src/lib.rs at line 1088 [32.11888]

B:BD[70.1152] → [14.16340:16392]

    pub fn new_adhoc<M, H>(message: M) -> Report<H>

[70.1152]

[86.314]

    pub fn new_adhoc<M>(message: M) -> Report

Deletion in src/lib.rs at line 1090 [32.11888]
B:BD[86.324] → [14.16393:16417]
```
        H: EyreHandler,
```
Deletion in src/wrapper.rs at line 66 [88.78]
B:BD[47.1434] → [26.2358:2382]
```
#[cfg(feature = "std")]
```
Deletion in src/wrapper.rs at line 69 [88.78]
B:BD[47.1516] → [26.2383:2407]
```
#[cfg(feature = "std")]
```
Deletion in src/wrapper.rs at line 75 [88.78]
B:BD[47.1643] → [26.2408:2432]
```
#[cfg(feature = "std")]
```
Deletion in src/wrapper.rs at line 81 [88.78]
B:BD[47.1774] → [26.2433:2457]
```
#[cfg(feature = "std")]
```
Replacement in tests/test_downcast.rs at line 6 [90.311]
B:BD[89.659] → [37.7755:7791]
```
use eyre::{DefaultContext, Report};
```
[89.659]
[91.1101]
```
use eyre::Report;
```

Replacement in tests/test_downcast.rs at line 93 [90.311]

B:BD[91.1493] → [37.7861:7943]

    let error: Report<DefaultContext> = Report::new(LargeAlignedError("oh no!"));

[91.1493]

[92.418]

    let error = Report::new(LargeAlignedError("oh no!"));

Deletion in tests/test_repr.rs at line 4 [93.32]
B:BD[4.10396] → [41.13219:13245]
```
use eyre::DefaultContext;
```

Replacement in tests/test_repr.rs at line 30 [93.32]

B:BD[89.801] → [37.8103:8175]

    drop(Report::<DefaultContext>::new(DetectDrop::new(&has_dropped)));

[89.801]

[89.802]

    drop(Report::new(DetectDrop::new(&has_dropped)));

Replacement in tests/test_source.rs at line 36 [94.17]
B:BD[94.715] → [37.8245:8281]
```
    let error: Report = eyre!(msg);
```
[94.715]
[95.115]
```
    let error = eyre!(msg);
```

Replacement in tests/ui/no-impl.stderr at line 7 [97.310]

B:BD[96.42] → [3.1515:1634]

  | doesn't satisfy `Error: eyre::kind::TraitKind<_>`
  | doesn't satisfy `Error: std::convert::Into<eyre::Report<_>>`

[96.42]

[96.158]

  | doesn't satisfy `Error: eyre::kind::TraitKind`
  | doesn't satisfy `Error: std::convert::Into<eyre::Report>`

Replacement in tests/ui/no-impl.stderr at line 15 [97.310]

B:BD[4.11262] → [3.1635:1755]

          `Error: std::convert::Into<eyre::Report<_>>`
          which is required by `Error: eyre::kind::TraitKind<_>`

[4.11262]

[96.327]

          `Error: std::convert::Into<eyre::Report>`
          which is required by `Error: eyre::kind::TraitKind`

Replacement in tests/ui/no-impl.stderr at line 19 [97.310]

B:BD[96.427] → [3.1756:1878]

          `&Error: std::convert::Into<eyre::Report<_>>`
          which is required by `&Error: eyre::kind::TraitKind<_>`

[96.427]

[98.0]

          `&Error: std::convert::Into<eyre::Report>`
          which is required by `&Error: eyre::kind::TraitKind`

Dependencies

In channels

Change contents

Replacement in Cargo.toml at line 3 [5.13]

Deletion in Cargo.toml at line 13 [5.13]

Insertion in Cargo.toml at line 23 [5.13]

Replacement in README.md at line 15 [13.12]

Deletion in README.md at line 19 [13.12]

Replacement in README.md at line 21 [13.12]

Replacement in README.md at line 24 [13.12]

Replacement in README.md at line 34 [13.12]

Replacement in README.md at line 37 [13.12]

Replacement in README.md at line 151 [13.12]

Replacement in README.md at line 170 [13.12]

Replacement in README.md at line 182 [13.12]

Deletion in README.md at line 184 [13.12]

Replacement in README.md at line 212 [13.12]

Deletion in build.rs at line 38 [24.11]

File addition: custom_handler.rs (----------)

Deletion in src/chain.rs at line 4 [27.11]

Deletion in src/chain.rs at line 6 [27.11]

Deletion in src/chain.rs at line 7 [27.11]

Deletion in src/chain.rs at line 13 [27.11]

Deletion in src/chain.rs at line 56 [27.11]

Deletion in src/chain.rs at line 66 [27.11]

Deletion in src/chain.rs at line 96 [27.11]

Deletion in src/chain.rs at line 101 [27.11]

Replacement in src/context.rs at line 2 [32.642]

Replacement in src/context.rs at line 11 [32.642]

Replacement in src/context.rs at line 17 [32.642]

Deletion in src/context.rs at line 19 [32.642]

Replacement in src/context.rs at line 21 [32.642]

Replacement in src/context.rs at line 29 [32.642]

Replacement in src/context.rs at line 39 [32.642]

Replacement in src/context.rs at line 41 [32.642]

Replacement in src/context.rs at line 43 [32.642]

Replacement in src/context.rs at line 50 [32.642]

Replacement in src/context.rs at line 58 [32.642]

Replacement in src/context.rs at line 65 [32.642]

Replacement in src/context.rs at line 74 [32.642]

Replacement in src/context.rs at line 82 [32.642]

Replacement in src/context.rs at line 90 [32.642]

Replacement in src/context.rs at line 97 [32.642]

Replacement in src/context.rs at line 143 [32.642]

Deletion in src/context.rs at line 145 [32.642]

Replacement in src/context.rs at line 175 [32.642]

Replacement in src/context.rs at line 177 [32.642]

Deletion in src/error.rs at line 1 [32.3238]

Deletion in src/error.rs at line 9 [32.3238]

Replacement in src/error.rs at line 11 [32.3238]

Deletion in src/error.rs at line 19 [32.3238]

Deletion in src/error.rs at line 70 [32.3238]

Replacement in src/error.rs at line 75 [32.3238]

Replacement in src/error.rs at line 84 [32.3238]

Replacement in src/error.rs at line 96 [32.3238]

Replacement in src/error.rs at line 106 [32.3238]

Replacement in src/error.rs at line 118 [32.3238]

Replacement in src/error.rs at line 128 [32.3238]

Deletion in src/error.rs at line 133 [32.3238]

Replacement in src/error.rs at line 141 [32.3238]

Replacement in src/error.rs at line 150 [32.3238]

Deletion in src/error.rs at line 155 [32.3238]

Replacement in src/error.rs at line 158 [32.3238]

Replacement in src/error.rs at line 161 [32.3238]

Replacement in src/error.rs at line 179 [32.3238]

Replacement in src/error.rs at line 198 [32.3238]

Replacement in src/error.rs at line 261 [32.3238]

Replacement in src/error.rs at line 264 [32.3238]

Deletion in src/error.rs at line 297 [32.3238]

Deletion in src/error.rs at line 306 [32.3238]

Replacement in src/error.rs at line 426 [32.3238]

Replacement in src/error.rs at line 431 [32.3238]

Replacement in src/error.rs at line 437 [32.3238]

Replacement in src/error.rs at line 443 [32.3238]

Replacement in src/error.rs at line 448 [32.3238]

Deletion in src/error.rs at line 450 [32.3238]

Replacement in src/error.rs at line 457 [32.3238]

Replacement in src/error.rs at line 465 [32.3238]

Replacement in src/error.rs at line 471 [32.3238]

Replacement in src/error.rs at line 477 [32.3238]