yaahc/eyre - Change 3ZZ75E2AOF7DO3TMR422QV7ZXNYOQZTOGF67LVSCEMX6N75Y36LAC

Allow customization of error context

Created by Jane Lusby on February 27, 2020

3ZZ75E2AOF7DO3TMR422QV7ZXNYOQZTOGF67LVSCEMX6N75Y36LAC

Dependencies

In channels

main

Change contents

Replacement in src/backtrace.rs at line 7 [4.15]

B:BD[4.130] → [4.130:229]

#[cfg(backtrace)]
macro_rules! backtrace {
    () => {
        Some(Backtrace::capture())
    };
}

[4.130]

[4.229]

// #[cfg(backtrace)]
// macro_rules! backtrace {
//     () => {
//         Some(Backtrace::capture())
//     };
// }

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

B:BD[5.32] → [3.31:73]

use crate::{Report, ErrReport, StdError};

[5.32]

[7.0]

use crate::{Report, DefaultContext, ErrReport, StdError, EyreContext};

Replacement in src/context.rs at line 13 [6.642]

B:BD[8.54] → [9.1160:1217]

        fn ext_context<C>(self, context: C) -> ErrReport

[8.54]

[8.107]

        fn ext_context<D>(self, context: D) -> ErrReport<DefaultContext>

Replacement in src/context.rs at line 15 [6.642]

B:BD[8.121] → [8.121:169]

            C: Display + Send + Sync + 'static;

[8.121]

[6.1435]

            D: Display + Send + Sync + 'static;

Replacement in src/context.rs at line 23 [6.642]

B:BD[6.1587] → [9.1218:1275]

        fn ext_context<C>(self, context: C) -> ErrReport

[6.1587]

[8.306]

        fn ext_context<D>(self, context: D) -> ErrReport<DefaultContext>

Replacement in src/context.rs at line 25 [6.642]

B:BD[8.320] → [8.320:368]

            C: Display + Send + Sync + 'static,

[8.320]

[8.368]

            D: Display + Send + Sync + 'static,

Replacement in src/context.rs at line 27 [6.642]

B:BD[8.378] → [10.0:56]

B:BD[10.56] → [9.1276:1338]

            let backtrace = backtrace_if_absent!(self);
            ErrReport::from_context(context, self, backtrace)

[8.378]

[8.434]

            ErrReport::from_context(context, self)

Replacement in src/context.rs at line 31 [6.642]

B:BD[8.451] → [9.1339:1430]

    impl StdError for ErrReport {
        fn ext_context<C>(self, context: C) -> ErrReport

[8.451]

[8.534]

    impl StdError for ErrReport<DefaultContext> {
        fn ext_context<D>(self, context: D) -> ErrReport<DefaultContext>

Replacement in src/context.rs at line 34 [6.642]

B:BD[8.548] → [8.548:596]

            C: Display + Send + Sync + 'static,

[8.548]

[8.596]

            D: Display + Send + Sync + 'static,

Replacement in src/context.rs at line 45 [6.642]

B:BD[8.747] → [9.1431:1491]

    fn context<C>(self, context: C) -> Result<T, ErrReport>

[8.747]

[11.447]

    fn context<D>(self, context: D) -> Result<T, ErrReport<DefaultContext>>

Replacement in src/context.rs at line 47 [6.642]

B:BD[11.457] → [11.457:501]

        C: Display + Send + Sync + 'static,

[11.457]

[11.501]

        D: Display + Send + Sync + 'static,

Replacement in src/context.rs at line 52 [6.642]

B:BD[6.1924] → [9.1492:1560]

    fn with_context<C, F>(self, context: F) -> Result<T, ErrReport>

[6.1924]

[12.436]

    fn with_context<D, F>(self, context: F) -> Result<T, ErrReport<DefaultContext>>

Replacement in src/context.rs at line 54 [6.642]

∅:D[12.446] → [6.1992:2036]

B:BD[6.1992] → [6.1992:2036]

B:BD[6.2036] → [13.85:111]

        C: Display + Send + Sync + 'static,
        F: FnOnce() -> C,

[12.446]

[6.2071]

        D: Display + Send + Sync + 'static,
        F: FnOnce() -> D,

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

∅:D[3.195] → [9.1595:1655]

B:BD[14.514] → [9.1595:1655]

    fn context<C>(self, context: C) -> Result<T, ErrReport>

[3.195]

[14.570]

    fn context<D>(self, context: D) -> Result<T, ErrReport<DefaultContext>>

Replacement in src/context.rs at line 84 [6.642]

B:BD[14.580] → [14.580:624]

        C: Display + Send + Sync + 'static,

[14.580]

[14.624]

        D: Display + Send + Sync + 'static,

Replacement in src/context.rs at line 86 [6.642]

B:BD[14.630] → [9.1656:1731]

        self.ok_or_else(|| ErrReport::from_display(context, backtrace!()))

[14.630]

[6.2167]

        self.ok_or_else(|| ErrReport::from_display(context))

Replacement in src/context.rs at line 89 [6.642]

B:BD[14.703] → [9.1732:1800]

    fn with_context<C, F>(self, context: F) -> Result<T, ErrReport>

[14.703]

[14.767]

    fn with_context<D, F>(self, context: F) -> Result<T, ErrReport<DefaultContext>>

Replacement in src/context.rs at line 91 [6.642]

B:BD[14.777] → [14.777:847]

        C: Display + Send + Sync + 'static,
        F: FnOnce() -> C,

[14.777]

[14.847]

        D: Display + Send + Sync + 'static,
        F: FnOnce() -> D,

Replacement in src/context.rs at line 94 [6.642]

B:BD[14.853] → [9.1801:1878]

        self.ok_or_else(|| ErrReport::from_display(context(), backtrace!()))

[14.853]

[14.926]

        self.ok_or_else(|| ErrReport::from_display(context()))

Replacement in src/context.rs at line 98 [6.642]
B:BD[6.2237] → [15.90:130]
```
impl<C, E> Debug for ContextError<C, E>
```
[6.2176]
[11.548]
```
impl<D, E> Debug for ContextError<D, E>
```
Replacement in src/context.rs at line 100 [6.642]
B:BD[11.568] → [11.568:584]
```
    C: Display,
```
[11.554]
[15.131]
```
    D: Display,
```

Replacement in src/context.rs at line 105 [6.642]

B:BD[16.32] → [17.46:100]

            .field("context", &Quoted(&self.context))

[16.32]

[16.89]

            .field("msg", &Quoted(&self.msg))

Replacement in src/context.rs at line 111 [6.642]
B:BD[6.2421] → [15.146:188]
```
impl<C, E> Display for ContextError<C, E>
```
[6.2421]
[11.629]
```
impl<D, E> Display for ContextError<D, E>
```
Replacement in src/context.rs at line 113 [6.642]
B:BD[11.635] → [11.635:651]
```
    C: Display,
```
[11.635]
[11.651]
```
    D: Display,
```
Replacement in src/context.rs at line 116 [6.642]
B:BD[6.2533] → [6.2533:2572]
```
        Display::fmt(&self.context, f)
```
[6.2533]
[6.2572]
```
        Display::fmt(&self.msg, f)
```
Replacement in src/context.rs at line 120 [6.642]
B:BD[6.2581] → [15.189:232]
```
impl<C, E> StdError for ContextError<C, E>
```
[6.2581]
[11.697]
```
impl<D, E> StdError for ContextError<D, E>
```
Replacement in src/context.rs at line 122 [6.642]
B:BD[11.730] → [11.730:746]
```
    C: Display,
```
[11.703]
[15.233]
```
    D: Display,
```

Replacement in src/context.rs at line 135 [6.642]

B:BD[6.2904] → [9.1879:1927]

impl<C> StdError for ContextError<C, ErrReport>

[6.2904]

[11.793]

impl<D, C> StdError for ContextError<D, ErrReport<C>>

Replacement in src/context.rs at line 137 [6.642]
B:BD[11.799] → [11.799:815]
```
    C: Display,
```
[11.799]
[11.815]
```
    C: EyreContext,
    D: Display,
```
Replacement in src/context.rs at line 150 [6.642]
B:BD[17.110] → [17.110:131]
```
struct Quoted<C>(C);
```
[17.110]
[17.131]
```
struct Quoted<D>(D);
```
Replacement in src/context.rs at line 152 [6.642]
B:BD[17.132] → [17.132:160]
```
impl<C> Debug for Quoted<C>
```
[17.132]
[17.160]
```
impl<D> Debug for Quoted<D>
```
Replacement in src/context.rs at line 154 [6.642]
B:BD[17.166] → [17.166:182]
```
    C: Display,
```
[17.166]
[17.182]
```
    D: Display,
```
Insertion in src/error.rs at line 2 [6.3238]
[18.547]
[4.313]
```
use std::any::Any;
```
Insertion in src/error.rs at line 10 [6.3238]
[7.243]
[18.604]
```
use crate::EyreContext;
```
Replacement in src/error.rs at line 15 [6.3238]
B:BD[6.3932] → [9.1963:1980]
```
impl ErrReport {
```
[6.3932]
[19.0]
```
impl<C> ErrReport<C>
where
    C: EyreContext,
{
```

Replacement in src/error.rs at line 31 [6.3238]

B:BD[6.4341] → [20.0:53]

B:BD[20.53] → [9.2063:2109]

        let backtrace = backtrace_if_absent!(error);
        ErrReport::from_std(error, backtrace)

[6.4341]

[21.17]

        ErrReport::from_std(error)

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

B:BD[21.1471] → [9.2426:2479]

        ErrReport::from_adhoc(message, backtrace!())

[21.1471]

[20.95]

        ErrReport::from_adhoc(message)

Replacement in src/error.rs at line 79 [6.3238]

∅:D[18.721] → [20.102:180]

B:BD[20.102] → [20.102:180]

    pub(crate) fn from_std<E>(error: E, backtrace: Option<Backtrace>) -> Self

[18.721]

[20.180]

    pub(crate) fn from_std<E>(error: E) -> Self

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

B:BD[22.36] → [22.36:79]

B:BD[22.134] → [22.134:175]

            object_drop: object_drop::<E>,
            object_ref: object_ref::<E>,

[22.36]

[18.722]

            object_drop: object_drop::<E, C>,
            object_ref: object_ref::<E, C>,

Replacement in src/error.rs at line 87 [6.3238]

∅:D[18.758] → [22.175:261]

B:BD[22.175] → [22.175:261]

B:BD[22.300] → [23.32:83]

B:BD[23.83] → [24.0:54]

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

[18.758]

[22.300]

            object_mut: object_mut::<E, C>,
            object_boxed: object_boxed::<E, C>,
            object_downcast: object_downcast::<E, C>,
            object_drop_rest: object_drop_front::<E, C>,

Replacement in src/error.rs at line 94 [6.3238]

B:BD[22.381] → [9.2480:2546]

        unsafe { ErrReport::construct(error, vtable, backtrace) }

[22.381]

[6.4396]

        unsafe { ErrReport::construct(error, vtable) }

Replacement in src/error.rs at line 97 [6.3238]

B:BD[6.4403] → [20.242:324]

    pub(crate) fn from_adhoc<M>(message: M, backtrace: Option<Backtrace>) -> Self

[6.4403]

[12.787]

    pub(crate) fn from_adhoc<M>(message: M) -> Self

Replacement in src/error.rs at line 104 [6.3238]

B:BD[22.480] → [22.480:537]

B:BD[22.606] → [22.606:661]

            object_drop: object_drop::<MessageError<M>>,
            object_ref: object_ref::<MessageError<M>>,

[22.480]

[18.802]

            object_drop: object_drop::<MessageError<M>, C>,
            object_ref: object_ref::<MessageError<M>, C>,

Replacement in src/error.rs at line 107 [6.3238]

∅:D[18.838] → [22.661:775]

B:BD[22.661] → [22.661:775]

B:BD[22.814] → [23.84:135]

B:BD[23.135] → [24.55:109]

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

[18.838]

[22.814]

            object_mut: object_mut::<MessageError<M>, C>,
            object_boxed: object_boxed::<MessageError<M>, C>,
            object_downcast: object_downcast::<M, C>,
            object_drop_rest: object_drop_front::<M, C>,

Replacement in src/error.rs at line 115 [6.3238]

B:BD[22.962] → [9.2547:2613]

        unsafe { ErrReport::construct(error, vtable, backtrace) }

[22.962]

[14.1044]

        unsafe { ErrReport::construct(error, vtable) }

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

B:BD[14.1051] → [14.1051:1135]

    pub(crate) fn from_display<M>(message: M, backtrace: Option<Backtrace>) -> Self

[14.1051]

[14.1135]

    pub(crate) fn from_display<M>(message: M) -> Self

Replacement in src/error.rs at line 125 [6.3238]

B:BD[22.1061] → [22.1061:1118]

B:BD[22.1187] → [22.1187:1242]

            object_drop: object_drop::<DisplayError<M>>,
            object_ref: object_ref::<DisplayError<M>>,

[22.1061]

[18.882]

            object_drop: object_drop::<DisplayError<M>, C>,
            object_ref: object_ref::<DisplayError<M>, C>,

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

∅:D[18.918] → [22.1242:1356]

B:BD[22.1242] → [22.1242:1356]

B:BD[22.1395] → [23.136:187]

B:BD[23.187] → [24.110:164]

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

[18.918]

[22.1395]

            object_mut: object_mut::<DisplayError<M>, C>,
            object_boxed: object_boxed::<DisplayError<M>, C>,
            object_downcast: object_downcast::<M, C>,
            object_drop_rest: object_drop_front::<M, C>,

Replacement in src/error.rs at line 136 [6.3238]

B:BD[22.1543] → [9.2614:2680]

        unsafe { ErrReport::construct(error, vtable, backtrace) }

[22.1543]

[5.81]

        unsafe { ErrReport::construct(error, vtable) }

Replacement in src/error.rs at line 140 [6.3238]

∅:D[18.947] → [10.115:212]

B:BD[5.88] → [10.115:212]

    pub(crate) fn from_context<C, E>(context: C, error: E, backtrace: Option<Backtrace>) -> Self

[18.947]

[5.155]

    pub(crate) fn from_context<D, E>(msg: D, error: E) -> Self

Replacement in src/error.rs at line 142 [6.3238]

B:BD[5.165] → [5.165:209]

        C: Display + Send + Sync + 'static,

[5.165]

[5.209]

        D: Display + Send + Sync + 'static,

Replacement in src/error.rs at line 145 [6.3238]

B:BD[5.260] → [10.213:286]

        let error: ContextError<C, E> = ContextError { context, error };

[5.260]

[10.286]

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

Replacement in src/error.rs at line 148 [6.3238]

B:BD[10.323] → [10.323:383]

B:BD[10.455] → [10.455:513]

            object_drop: object_drop::<ContextError<C, E>>,
            object_ref: object_ref::<ContextError<C, E>>,

[10.323]

[18.948]

            object_drop: object_drop::<ContextError<D, E>, C>,
            object_ref: object_ref::<ContextError<D, E>, C>,

Replacement in src/error.rs at line 151 [6.3238]

∅:D[18.984] → [10.513:633]

B:BD[10.513] → [10.513:633]

B:BD[24.208] → [24.208:320]

            object_mut: object_mut::<ContextError<C, E>>,
            object_boxed: object_boxed::<ContextError<C, E>>,
            object_downcast: context_downcast::<C, E>,
            object_drop_rest: context_drop_rest::<C, E>,

[18.984]

[10.689]

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

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

B:BD[10.768] → [9.2681:2747]

        unsafe { ErrReport::construct(error, vtable, backtrace) }

[10.768]

[6.4605]

        unsafe { ErrReport::construct(error, vtable) }

Deletion in src/error.rs at line 164 [6.3238]
B:BD[25.141] → [25.141:179]
```
        backtrace: Option<Backtrace>,
```

Replacement in src/error.rs at line 168 [6.3238]

B:BD[25.270] → [25.270:372]

            object_drop: object_drop::<BoxedError>,
            object_ref: object_ref::<BoxedError>,

[25.270]

[18.1055]

            object_drop: object_drop::<BoxedError, C>,
            object_ref: object_ref::<BoxedError, C>,

Replacement in src/error.rs at line 171 [6.3238]

∅:D[18.1091] → [25.372:641]

B:BD[25.372] → [25.372:641]

            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>>,

[18.1091]

[25.641]

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

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

B:BD[25.797] → [9.2748:2814]

        unsafe { ErrReport::construct(error, vtable, backtrace) }

[25.797]

[25.859]

        unsafe { ErrReport::construct(error, vtable) }

Replacement in src/error.rs at line 189 [6.3238]

B:BD[22.1756] → [22.1756:1832]

        vtable: &'static ErrorVTable,
        backtrace: Option<Backtrace>,

[22.1756]

[22.1832]

        vtable: &'static ErrorVTable<C>,

Insertion in src/error.rs at line 194 [6.3238]
[6.4726]
[26.836]
```
        let context = C::default(&error);
```
Replacement in src/error.rs at line 197 [6.3238]
B:BD[26.918] → [26.918:941]
```
            backtrace,
```
[26.897]
[27.0]
```
            context,
```

Replacement in src/error.rs at line 206 [6.3238]

∅:D[28.458] → [29.127:212]

B:BD[26.972] → [29.127:212]

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

[28.458]

[29.212]

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

Replacement in src/error.rs at line 265 [6.3238]
∅:D[30.180] → [31.451:499]
∅:D[32.1534] → [31.451:499]
B:BD[31.451] → [31.451:499]
```
    pub fn context<C>(self, context: C) -> Self
```
[32.1534]
[31.499]
```
    pub fn context<D>(self, msg: D) -> Self
```

Replacement in src/error.rs at line 267 [6.3238]

B:BD[31.509] → [31.509:553]

        C: Display + Send + Sync + 'static,

[31.509]

[31.553]

        D: Display + Send + Sync + 'static,

Replacement in src/error.rs at line 269 [6.3238]
B:BD[31.559] → [9.2933:2996]
∅:D[33.35] → [31.619:640]
∅:D[34.181] → [31.619:640]
∅:D[9.2996] → [31.619:640]
B:BD[31.619] → [31.619:640]
```
        let error: ContextError<C, ErrReport> = ContextError {
            context,
```
[31.559]
[15.306]
```
        let error: ContextError<D, ErrReport<C>> = ContextError {
            msg,
```

Replacement in src/error.rs at line 275 [6.3238]

B:BD[33.84] → [9.2997:3131]

            object_drop: object_drop::<ContextError<C, ErrReport>>,
            object_ref: object_ref::<ContextError<C, ErrReport>>,

[33.84]

[18.1092]

            object_drop: object_drop::<ContextError<D, ErrReport<C>>, C>,
            object_ref: object_ref::<ContextError<D, ErrReport<C>>, C>,

Replacement in src/error.rs at line 278 [6.3238]

B:BD[18.1128] → [9.3132:3268]

∅:D[9.3268] → [35.46:164]

B:BD[35.46] → [35.46:164]

            object_mut: object_mut::<ContextError<C, ErrReport>>,
            object_boxed: object_boxed::<ContextError<C, ErrReport>>,
            object_downcast: context_chain_downcast::<C>,
            object_drop_rest: context_chain_drop_rest::<C>,

[18.1128]

[33.474]

            object_mut: object_mut::<ContextError<D, ErrReport<C>>, C>,
            object_boxed: object_boxed::<ContextError<D, ErrReport<C>>, C>,
            object_downcast: context_chain_downcast::<D, C>,
            object_drop_rest: context_chain_drop_rest::<D, C>,

Deletion in src/error.rs at line 284 [6.3238]
B:BD[33.486] → [9.3269:3349]
∅:D[9.3349] → [33.564:595]
B:BD[33.564] → [33.564:595]
```
        // As the cause is eyre::ErrReport, we already have a backtrace for it.
        let backtrace = None;
```

Replacement in src/error.rs at line 285 [6.3238]

B:BD[33.662] → [9.3350:3416]

        unsafe { ErrReport::construct(error, vtable, backtrace) }

[33.662]

[6.5336]

        unsafe { ErrReport::construct(error, vtable) }

Replacement in src/error.rs at line 348 [6.3238]

B:BD[36.152] → [36.152:226]

    /// type of the context `C` **or** the type of the error on which the

[36.152]

[36.226]

    /// type of the context `D` **or** the type of the error on which the

Replacement in src/error.rs at line 398 [6.3238]
B:BD[37.46] → [9.3769:3795]
```
    /// # use eyre::eyre;
```
[37.46]
[37.76]
```
    /// # use eyre::{ErrReport, eyre};
```
Replacement in src/error.rs at line 417 [6.3238]
B:BD[37.579] → [9.3796:3832]
```
    /// # let error = eyre!("...");
```
[37.579]
[37.617]
```
    /// # let error: ErrReport = eyre!("...");
```
Replacement in src/error.rs at line 458 [6.3238]
B:BD[18.1211] → [9.3833:3863]
```
impl<E> From<E> for ErrReport
```
[18.1211]
[11.1305]
```
impl<E, C> From<E> for ErrReport<C>
```
Insertion in src/error.rs at line 460 [6.3238]
[11.1311]
[11.1311]
```
    C: EyreContext,
```

Replacement in src/error.rs at line 464 [6.3238]

B:BD[38.219] → [39.0:53]

B:BD[39.53] → [9.3864:3910]

        let backtrace = backtrace_if_absent!(error);
        ErrReport::from_std(error, backtrace)

[38.219]

[6.7611]

        ErrReport::from_std(error)

Replacement in src/error.rs at line 469 [6.3238]
B:BD[18.1236] → [9.3911:3938]
```
impl Deref for ErrReport {
```
[18.1236]
[40.1503]
```
impl<C: EyreContext> Deref for ErrReport<C> {
```
Replacement in src/error.rs at line 478 [6.3238]
B:BD[18.1261] → [9.3939:3969]
```
impl DerefMut for ErrReport {
```
[18.1261]
[6.7805]
```
impl<C: EyreContext> DerefMut for ErrReport<C> {
```
Replacement in src/error.rs at line 484 [6.3238]
B:BD[6.7896] → [9.3970:3999]
```
impl Display for ErrReport {
```
[6.7896]
[41.106]
```
impl<C: EyreContext> Display for ErrReport<C> {
```
Replacement in src/error.rs at line 490 [6.3238]
B:BD[6.8843] → [9.4000:4027]
```
impl Debug for ErrReport {
```
[6.8843]
[42.88]
```
impl<C: EyreContext> Debug for ErrReport<C> {
```
Replacement in src/error.rs at line 496 [6.3238]
B:BD[6.8984] → [9.4028:4054]
```
impl Drop for ErrReport {
```
[6.8984]
[6.9081]
```
impl<C> Drop for ErrReport<C>
where
    C: EyreContext,
{
```

Replacement in src/error.rs at line 512 [6.3238]

B:BD[43.174] → [43.174:195]

B:BD[43.195] → [29.471:519]

B:BD[44.447] → [45.83:169]

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

[43.174]

[18.1262]

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

Replacement in src/error.rs at line 519 [6.3238]

∅:D[18.1290] → [45.169:263]

B:BD[45.169] → [45.169:263]

∅:D[45.263] → [41.210:304]

∅:D[46.455] → [41.210:304]

B:BD[47.251] → [41.210:304]

∅:D[35.294] → [23.1192:1271]

B:BD[22.1987] → [23.1192:1271]

B:BD[23.1271] → [24.460:521]

    object_mut: unsafe fn(&mut ErrorImpl<()>) -> &mut (dyn StdError + Send + Sync + 'static),
    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),

[18.1290]

[29.520]

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

Replacement in src/error.rs at line 526 [6.3238]

∅:D[28.1435] → [29.523:573]

B:BD[29.523] → [29.523:573]

unsafe fn object_drop<E>(e: Box<ErrorImpl<()>>) {

[28.1435]

[29.573]

unsafe fn object_drop<E, C>(e: Box<ErrorImpl<(), C>>)
where
    C: EyreContext,
{

Replacement in src/error.rs at line 532 [6.3238]

B:BD[29.695] → [29.695:774]

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

[29.695]

[44.448]

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

Replacement in src/error.rs at line 537 [6.3238]

∅:D[28.1492] → [24.522:594]

B:BD[44.471] → [24.522:594]

unsafe fn object_drop_front<E>(e: Box<ErrorImpl<()>>, target: TypeId) {

[28.1492]

[44.527]

unsafe fn object_drop_front<E, C>(e: Box<ErrorImpl<(), C>>, target: TypeId)
where
    C: EyreContext,
{

Replacement in src/error.rs at line 545 [6.3238]

∅:D[24.615] → [44.725:818]

B:BD[44.725] → [44.725:818]

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

[24.615]

[29.774]

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

Replacement in src/error.rs at line 550 [6.3238]

∅:D[28.1549] → [45.264:350]

B:BD[43.364] → [45.264:350]

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

[28.1549]

[43.451]

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

Insertion in src/error.rs at line 552 [6.3238]
[43.457]
[43.457]
```
    C: EyreContext,
```

Replacement in src/error.rs at line 556 [6.3238]

∅:D[28.1623] → [27.29:96]

B:BD[43.500] → [27.29:96]

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

[28.1623]

[6.9174]

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

Replacement in src/error.rs at line 561 [6.3238]

∅:D[18.1315] → [45.351:445]

∅:D[28.1680] → [45.351:445]

B:BD[6.9177] → [45.351:445]

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

[18.1315]

[43.606]

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

Insertion in src/error.rs at line 563 [6.3238]
[43.612]
[43.612]
```
    C: EyreContext,
```

Replacement in src/error.rs at line 567 [6.3238]

∅:D[28.1754] → [27.97:164]

B:BD[43.655] → [27.97:164]

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

[28.1754]

[41.305]

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

Replacement in src/error.rs at line 571 [6.3238]

∅:D[28.1811] → [41.308:402]

B:BD[41.308] → [41.308:402]

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

[28.1811]

[41.402]

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

Insertion in src/error.rs at line 573 [6.3238]
[41.408]
[41.408]
```
    C: EyreContext,
```
Insertion in src/error.rs at line 575 [6.3238]
[41.449]
[41.449]
```
    C: Send + Sync + 'static,
```

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

∅:D[28.1893] → [41.451:514]

B:BD[41.451] → [41.451:514]

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

[28.1893]

[23.1375]

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

Replacement in src/error.rs at line 582 [6.3238]

∅:D[28.1950] → [23.1378:1465]

B:BD[23.1378] → [23.1378:1465]

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

[28.1950]

[22.2035]

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

Insertion in src/error.rs at line 584 [6.3238]
[22.2041]
[23.1466]
```
    C: EyreContext,
```

Replacement in src/error.rs at line 590 [6.3238]

∅:D[28.2062] → [23.1520:1593]

B:BD[23.1520] → [23.1520:1593]

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

[28.2062]

[27.165]

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

Replacement in src/error.rs at line 598 [6.3238]

B:BD[24.619] → [28.2063:2136]

// Safety: requires layout of *e to match ErrorImpl<ContextError<C, E>>.

[24.619]

[18.1316]

// Safety: requires layout of *e to match ErrorImpl<ContextError<D, E>>.

Replacement in src/error.rs at line 600 [6.3238]

∅:D[18.1340] → [24.774:865]

∅:D[28.2136] → [24.774:865]

B:BD[22.2094] → [24.774:865]

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

[18.1340]

[24.865]

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

Replacement in src/error.rs at line 602 [6.3238]
B:BD[24.871] → [24.871:887]
```
    C: 'static,
```
[24.871]
[24.887]
```
    C: EyreContext,
    D: 'static,
```

Replacement in src/error.rs at line 606 [6.3238]

B:BD[24.905] → [24.905:1032]

B:BD[24.1032] → [27.230:302]

    if TypeId::of::<C>() == target {
        let unerased = e as *const ErrorImpl<()> as *const ErrorImpl<ContextError<C, E>>;
        let addr = &(*unerased)._object.context as *const C as *mut ();

[24.905]

[24.1103]

    if TypeId::of::<D>() == target {
        let unerased = e as *const ErrorImpl<(), C> as *const ErrorImpl<ContextError<D, E>, C>;
        let addr = &(*unerased)._object.msg as *const D as *mut ();

Replacement in src/error.rs at line 611 [6.3238]

B:BD[24.1190] → [24.1190:1280]

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

[24.1190]

[27.303]

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

Replacement in src/error.rs at line 619 [6.3238]

B:BD[24.1427] → [28.2137:2210]

// Safety: requires layout of *e to match ErrorImpl<ContextError<C, E>>.

[24.1427]

[18.1341]

// Safety: requires layout of *e to match ErrorImpl<ContextError<D, E>>.

Replacement in src/error.rs at line 621 [6.3238]
∅:D[18.1365] → [24.1427:1500]
∅:D[28.2210] → [24.1427:1500]
B:BD[24.1427] → [24.1427:1500]
```
unsafe fn context_drop_rest<C, E>(e: Box<ErrorImpl<()>>, target: TypeId)
```
[18.1365]
[24.1500]
```
unsafe fn context_drop_rest<D, E, C>(e: Box<ErrorImpl<(), C>>, target: TypeId)
```
Replacement in src/error.rs at line 623 [6.3238]
B:BD[24.1506] → [24.1506:1522]
```
    C: 'static,
```
[24.1506]
[24.1522]
```
    C: EyreContext,
    D: 'static,
```

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

B:BD[24.1540] → [24.1540:1618]

    // Called after downcasting by value to either the C or the E and doing a

[24.1540]

[24.1618]

    // Called after downcasting by value to either the D or the E and doing a

Replacement in src/error.rs at line 629 [6.3238]
B:BD[24.1668] → [24.1668:1705]
```
    if TypeId::of::<C>() == target {
```
[24.1668]
[24.1705]
```
    if TypeId::of::<D>() == target {
```

Replacement in src/error.rs at line 631 [6.3238]

B:BD[24.1746] → [24.1746:1840]

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

[24.1746]

[24.1840]

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

Replacement in src/error.rs at line 637 [6.3238]

B:BD[24.1932] → [24.1932:2026]

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

[24.1932]

[35.465]

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

Replacement in src/error.rs at line 644 [6.3238]

B:BD[35.512] → [9.4055:4136]

∅:D[28.2288] → [35.886:980]

∅:D[9.4136] → [35.886:980]

B:BD[35.886] → [35.886:980]

// Safety: requires layout of *e to match ErrorImpl<ContextError<C, ErrReport>>.
unsafe fn context_chain_downcast<C>(e: &ErrorImpl<()>, target: TypeId) -> Option<NonNull<()>>

[35.512]

[35.980]

// Safety: requires layout of *e to match ErrorImpl<ContextError<D, ErrReport>>.
unsafe fn context_chain_downcast<D, C>(e: &ErrorImpl<(), C>, target: TypeId) -> Option<NonNull<()>>

Replacement in src/error.rs at line 647 [6.3238]
B:BD[35.986] → [35.986:1002]
```
    C: 'static,
```
[35.986]
[35.1002]
```
    C: EyreContext,
    D: 'static,
```

Replacement in src/error.rs at line 650 [6.3238]

B:BD[35.1004] → [35.1004:1041]

B:BD[35.1041] → [9.4137:4235]

∅:D[9.4235] → [27.424:496]

B:BD[35.1135] → [27.424:496]

    if TypeId::of::<C>() == target {
        let unerased = e as *const ErrorImpl<()> as *const ErrorImpl<ContextError<C, ErrReport>>;
        let addr = &(*unerased)._object.context as *const C as *mut ();

[35.1004]

[35.1206]

    if TypeId::of::<D>() == target {
        let unerased = e as *const ErrorImpl<(), C> as *const ErrorImpl<ContextError<D, ErrReport<C>>, C>;
        let addr = &(*unerased)._object.msg as *const D as *mut ();

Replacement in src/error.rs at line 656 [6.3238]

B:BD[28.2361] → [9.4236:4334]

        let unerased = e as *const ErrorImpl<()> as *const ErrorImpl<ContextError<C, ErrReport>>;

[28.2361]

[27.497]

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

Replacement in src/error.rs at line 662 [6.3238]

B:BD[35.1482] → [9.4335:4416]

∅:D[28.2439] → [35.1482:1558]

∅:D[9.4416] → [35.1482:1558]

B:BD[35.1482] → [35.1482:1558]

// Safety: requires layout of *e to match ErrorImpl<ContextError<C, ErrReport>>.
unsafe fn context_chain_drop_rest<C>(e: Box<ErrorImpl<()>>, target: TypeId)

[35.1482]

[35.1558]

// Safety: requires layout of *e to match ErrorImpl<ContextError<D, ErrReport>>.
unsafe fn context_chain_drop_rest<D, C>(e: Box<ErrorImpl<(), C>>, target: TypeId)

Replacement in src/error.rs at line 665 [6.3238]
B:BD[35.1564] → [35.1564:1580]
```
    C: 'static,
```
[35.1564]
[35.1580]
```
    C: EyreContext,
    D: 'static,
```

Replacement in src/error.rs at line 668 [6.3238]

B:BD[35.1582] → [35.1582:1660]

    // Called after downcasting by value to either the C or one of the causes

[35.1582]

[35.1660]

    // Called after downcasting by value to either the D or one of the causes

Replacement in src/error.rs at line 670 [6.3238]
B:BD[35.1722] → [35.1722:1759]
```
    if TypeId::of::<C>() == target {
```
[35.1722]
[35.1759]
```
    if TypeId::of::<D>() == target {
```

Replacement in src/error.rs at line 672 [6.3238]

B:BD[35.1800] → [35.1800:1832]

B:BD[35.1832] → [9.4417:4487]

            Box<ErrorImpl<()>>,
            Box<ErrorImpl<ContextError<ManuallyDrop<C>, ErrReport>>>,

[35.1800]

[24.2026]

            Box<ErrorImpl<(), C>>,
            Box<ErrorImpl<ContextError<ManuallyDrop<D>, ErrReport<C>>, C>>,

Replacement in src/error.rs at line 679 [6.3238]

B:BD[35.1953] → [35.1953:1985]

B:BD[35.1985] → [9.4573:4643]

            Box<ErrorImpl<()>>,
            Box<ErrorImpl<ContextError<C, ManuallyDrop<ErrReport>>>>,

[35.1953]

[35.2051]

            Box<ErrorImpl<(), C>>,
            Box<ErrorImpl<ContextError<D, ManuallyDrop<ErrReport<C>>>, C>>,

Replacement in src/error.rs at line 693 [6.3238]

B:BD[6.9247] → [48.28:61]

∅:D[48.61] → [43.675:709]

B:BD[49.91] → [43.675:709]

∅:D[50.1864] → [6.9318:9352]

B:BD[6.9318] → [6.9318:9352]

pub(crate) struct ErrorImpl<E> {
    vtable: &'static ErrorVTable,
    backtrace: Option<Backtrace>,

[6.9247]

[24.2132]

pub(crate) struct ErrorImpl<E, C>
where
    C: EyreContext,
{
    vtable: &'static ErrorVTable<C>,
    context: C,

Replacement in src/error.rs at line 704 [6.3238]

B:BD[6.9369] → [24.2240:2381]

// repr C to ensure that ContextError<C, E> has the same layout as
// ContextError<ManuallyDrop<C>, E> and ContextError<C, ManuallyDrop<E>>.

[6.9369]

[24.2381]

// repr C to ensure that ContextError<D, E> has the same layout as
// ContextError<ManuallyDrop<D>, E> and ContextError<D, ManuallyDrop<E>>.

Replacement in src/error.rs at line 707 [6.3238]
∅:D[24.2392] → [5.313:372]
B:BD[6.9369] → [5.313:372]
```
pub(crate) struct ContextError<C, E> {
    pub context: C,
```
[24.2392]
[5.372]
```
pub(crate) struct ContextError<D, E> {
    pub msg: D,
```

Replacement in src/error.rs at line 712 [6.3238]

B:BD[51.1] → [51.1:64]

impl<E> ErrorImpl<E> {
    fn erase(&self) -> &ErrorImpl<()> {

[6.9886]

[28.2672]

impl<E, C> ErrorImpl<E, C>
where
    C: EyreContext,
{
    fn erase(&self) -> &ErrorImpl<(), C> {

Replacement in src/error.rs at line 720 [6.3238]

∅:D[28.2859] → [51.64:139]

B:BD[51.64] → [51.64:139]

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

[28.2859]

[51.139]

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

Replacement in src/error.rs at line 724 [6.3238]
∅:D[14.1798] → [49.92:113]
B:BD[6.9952] → [49.92:113]
```
impl ErrorImpl<()> {
```
[14.1798]
[52.0]
```
impl<C> ErrorImpl<(), C>
where
    C: EyreContext,
{
```

Insertion in src/error.rs at line 739 [6.3238]

[45.555]

[41.515]

    }
    pub fn context<T: Any>(&self) -> Option<&T> {
        self.context.context_raw(TypeId::of::<T>())?.downcast_ref::<T>()

Replacement in src/error.rs at line 751 [6.3238]

B:BD[41.765] → [41.765:810]

        self.backtrace
            .as_ref()

[41.765]

[41.810]

        self.context()

Replacement in src/error.rs at line 761 [6.3238]
B:BD[41.2159] → [51.148:182]
```
impl<E> StdError for ErrorImpl<E>
```
[41.2159]
[51.182]
```
impl<E, C> StdError for ErrorImpl<E, C>
```
Insertion in src/error.rs at line 763 [6.3238]
[51.188]
[51.188]
```
    C: EyreContext,
```
Replacement in src/error.rs at line 776 [6.3238]
B:BD[41.2215] → [41.2215:2246]
```
impl<E> Debug for ErrorImpl<E>
```
[41.2215]
[41.2246]
```
impl<E, C> Debug for ErrorImpl<E, C>
```
Insertion in src/error.rs at line 778 [6.3238]
[41.2252]
[41.2252]
```
    C: EyreContext,
```
Replacement in src/error.rs at line 786 [6.3238]
B:BD[41.2465] → [41.2465:2498]
```
impl<E> Display for ErrorImpl<E>
```
[41.2465]
[41.2498]
```
impl<E, C> Display for ErrorImpl<E, C>
```
Insertion in src/error.rs at line 788 [6.3238]
[41.2504]
[41.2504]
```
    C: EyreContext,
```

Replacement in src/error.rs at line 796 [6.3238]

B:BD[41.2643] → [9.4644:4753]

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

[41.2643]

[41.2744]

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

Replacement in src/error.rs at line 812 [6.3238]

B:BD[53.9] → [9.4822:4917]

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

[53.9]

[53.96]

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

Replacement in src/error.rs at line 819 [6.3238]

B:BD[18.1419] → [9.4918:4973]

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

[18.1419]

[54.60]

impl<C: EyreContext> AsRef<dyn StdError + Send + Sync> for ErrReport<C> {

Replacement in src/error.rs at line 826 [6.3238]

B:BD[18.1444] → [9.4974:5015]

impl AsRef<dyn StdError> for ErrReport {

[18.1444]

[54.188]

impl<C: EyreContext> AsRef<dyn StdError> for ErrReport<C> {

Insertion in src/fmt.rs at line 4 [52.270]
[2.37]
[52.329]
```
use crate::EyreContext;
```
Replacement in src/fmt.rs at line 6 [52.270]
B:BD[52.330] → [52.330:351]
```
impl ErrorImpl<()> {
```
[52.330]
[55.0]
```
impl<C> ErrorImpl<(), C>
where
    C: EyreContext,
{
```
Replacement in src/kind.rs at line 47 [57.10]
B:BD[56.1632] → [9.5638:5660]
```
use crate::ErrReport;
```
[56.1632]
[7.275]
```
use crate::{EyreContext, ErrReport};
```

Replacement in src/kind.rs at line 53 [57.10]

B:BD[57.97] → [57.97:146]

#[cfg(backtrace)]
use std::backtrace::Backtrace;

[57.97]

[57.146]

// #[cfg(backtrace)]
// use std::backtrace::Backtrace;

Replacement in src/kind.rs at line 68 [57.10]

B:BD[57.369] → [9.5697:5746]

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

[57.369]

[57.414]

    pub fn new<M, C: EyreContext>(self, message: M) -> ErrReport<C>

Replacement in src/kind.rs at line 72 [57.10]

B:BD[57.482] → [9.5747:5800]

        ErrReport::from_adhoc(message, backtrace!())

[57.482]

[57.531]

        ErrReport::from_adhoc(message)

Replacement in src/kind.rs at line 112 [57.10]

B:BD[25.1095] → [9.6003:6079]

∅:D[9.6079] → [25.1167:1220]

B:BD[25.1167] → [25.1167:1220]

B:BD[25.1220] → [9.6080:6128]

    pub fn new(self, error: Box<dyn StdError + Send + Sync>) -> ErrReport {
        let backtrace = backtrace_if_absent!(error);
        ErrReport::from_boxed(error, backtrace)

[25.1095]

[25.1264]

    pub fn new<C: EyreContext>(self, error: Box<dyn StdError + Send + Sync>) -> ErrReport<C> {
        ErrReport::from_boxed(error)

Replacement in src/lib.rs at line 91 [6.11888]
B:BD[58.1608] → [9.6397:6421]
```
//!   # use eyre::eyre;
```
[58.1608]
[59.871]
```
//!   # use eyre::{ErrReport, eyre};
```
Replacement in src/lib.rs at line 110 [6.11888]
B:BD[59.1338] → [9.6422:6456]
```
//!   # let error = eyre!("...");
```
[59.1338]
[59.1374]
```
//!   # let error: ErrReport = eyre!("...");
```

Insertion in src/lib.rs at line 214 [6.11888]

[7.362]

[18.1883]

use std::backtrace::Backtrace;
use std::any::{Any, TypeId};

Replacement in src/lib.rs at line 325 [6.11888]

B:BD[60.2560] → [9.7810:7833]

∅:D[9.7833] → [48.629:674]

B:BD[48.629] → [48.629:674]

pub struct ErrReport {
    inner: ManuallyDrop<Box<ErrorImpl<()>>>,

[60.2560]

[48.674]

pub struct ErrReport<C = DefaultContext>
where
    C: EyreContext,
{
    inner: ManuallyDrop<Box<ErrorImpl<(), C>>>,
}
pub trait EyreContext: Sized + Send + Sync + 'static {
    fn default(err: &(dyn std::error::Error + 'static)) -> Self;
    fn context_raw(&self, typeid: TypeId) -> Option<&dyn Any>;
}
pub struct DefaultContext {
    backtrace: Option<Backtrace>,
}
impl EyreContext for DefaultContext {
    fn default(error: &(dyn std::error::Error + 'static)) -> Self {
        let backtrace = backtrace_if_absent!(error);
        Self {
            backtrace
        }
    }
    fn context_raw(&self, typid: TypeId) -> Option<&dyn Any> {
        match typid {
            t if t == TypeId::of::<Backtrace>() => self.backtrace.as_ref().map(|b| b as &dyn Any),
            _ => None,
        }
    }

Replacement in src/lib.rs at line 433 [6.11888]

B:BD[61.667] → [9.8192:8256]

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

[61.667]

[62.83]

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

Replacement in src/lib.rs at line 578 [6.11888]

B:BD[62.1369] → [9.8491:8551]

    fn context<C>(self, context: C) -> Result<T, ErrReport>

[62.1369]

[62.1425]

    fn context<C>(self, context: C) -> Result<T, ErrReport<DefaultContext>>

Replacement in src/lib.rs at line 584 [6.11888]

B:BD[62.1597] → [9.8552:8614]

    fn with_context<C, F>(self, f: F) -> Result<T, ErrReport>

[62.1597]

[62.1655]

    fn with_context<C, F>(self, f: F) -> Result<T, ErrReport<DefaultContext>>

Replacement in src/lib.rs at line 593 [6.11888]
B:BD[63.210] → [9.8615:8641]
```
    use crate::ErrReport;
```
[63.210]
[7.424]
```
    use crate::{EyreContext, ErrReport};
```

Replacement in src/lib.rs at line 596 [6.11888]

B:BD[63.269] → [64.862:919]

    #[cfg(backtrace)]
    use std::backtrace::Backtrace;

[63.269]

[64.919]

//     #[cfg(backtrace)]
//     use std::backtrace::Backtrace;

Replacement in src/lib.rs at line 609 [6.11888]

B:BD[57.1152] → [9.8642:8691]

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

[57.1152]

[63.314]

    pub fn new_adhoc<M, C>(message: M) -> ErrReport<C>

Insertion in src/lib.rs at line 611 [6.11888]
[63.324]
[63.324]
```
        C: EyreContext,
```

Replacement in src/lib.rs at line 614 [6.11888]

B:BD[63.382] → [9.8692:8745]

        ErrReport::from_adhoc(message, backtrace!())

[63.382]

[65.1760]

        ErrReport::from_adhoc(message)

Replacement in tests/test_backtrace.rs at line 9 [66.41]
B:BD[66.167] → [9.9559:9579]
```
    use eyre::eyre;
```
[66.167]
[66.191]
```
    use eyre::{eyre, ErrReport};
```
Replacement in tests/test_backtrace.rs at line 11 [66.41]
B:BD[66.192] → [9.9580:9613]
```
    let error = eyre!("oh no!");
```
[66.192]
[66.227]
```
    let error: ErrReport = eyre!("oh no!");
```
Replacement in tests/test_boxed.rs at line 1 [25.2018]
B:BD[25.2018] → [9.9614:9630]
```
use eyre::eyre;
```
[25.2018]
[25.2039]
```
use eyre::{ErrReport, eyre};
```
Replacement in tests/test_boxed.rs at line 15 [25.2018]
B:BD[25.2292] → [9.9631:9661]
```
    let error = eyre!(error);
```
[25.2292]
[25.2324]
```
    let error: ErrReport = eyre!(error);
```

Replacement in tests/test_convert.rs at line 10 [68.18]

B:BD[67.589] → [9.10108:10171]

    let error = ErrReport::new(DetectDrop::new(&has_dropped));

[67.589]

[68.352]

    let error: ErrReport = ErrReport::new(DetectDrop::new(&has_dropped));

Replacement in tests/test_downcast.rs at line 6 [69.311]
B:BD[67.659] → [9.10172:10193]
```
use eyre::ErrReport;
```
[67.659]
[46.1101]
```
use eyre::{DefaultContext, ErrReport};
```

Replacement in tests/test_downcast.rs at line 74 [69.311]

B:BD[67.695] → [9.10194:10257]

    let error = ErrReport::new(DetectDrop::new(&has_dropped));

[67.695]

[70.299]

    let error: ErrReport = ErrReport::new(DetectDrop::new(&has_dropped));

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

B:BD[46.1493] → [9.10258:10319]

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

[46.1493]

[71.418]

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

Replacement in tests/test_fmt.rs at line 48 [73.14]
B:BD[72.461] → [72.461:488]
```
    context: \"f failed\",
```
[72.461]
[72.488]
```
    msg: \"f failed\",
```
Replacement in tests/test_fmt.rs at line 58 [73.14]
B:BD[72.624] → [72.624:651]
```
    context: \"g failed\",
```
[72.624]
[72.651]
```
    msg: \"g failed\",
```
Replacement in tests/test_fmt.rs at line 60 [73.14]
B:BD[72.671] → [72.671:702]
```
        context: \"f failed\",
```
[72.671]
[72.702]
```
        msg: \"f failed\",
```
Replacement in tests/test_macros.rs at line 4 [74.123]
B:BD[69.809] → [9.10356:10374]
```
use eyre::ensure;
```
[69.809]
[74.383]
```
use eyre::{Result, ensure};
```
Replacement in tests/test_macros.rs at line 15 [74.123]
B:BD[75.67] → [75.67:84]
```
    let f = || {
```
[75.67]
[75.84]
```
    let f = || -> Result<()> {
```
Replacement in tests/test_macros.rs at line 22 [74.123]
B:BD[75.196] → [75.196:213]
```
    let f = || {
```
[75.196]
[75.213]
```
    let f = ||  -> Result<()>{
```
Replacement in tests/test_macros.rs at line 28 [74.123]
B:BD[75.320] → [75.320:337]
```
    let f = || {
```
[75.320]
[75.337]
```
    let f = ||  -> Result<()>{
```
Insertion in tests/test_repr.rs at line 5 [76.32]
[9.10396]
[76.118]
```
use eyre::DefaultContext;
```

Replacement in tests/test_repr.rs at line 28 [76.32]

B:BD[67.801] → [9.10579:10636]

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

[67.801]

[67.802]

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

Replacement in tests/test_source.rs at line 1 [77.17]
B:BD[77.17] → [9.10637:10653]
```
use eyre::eyre;
```
[77.17]
[77.38]
```
use eyre::{ErrReport, eyre};
```
Replacement in tests/test_source.rs at line 29 [77.17]
B:BD[77.578] → [9.10654:10687]
```
    let error = eyre!("oh no!");
```
[77.578]
[77.613]
```
    let error: ErrReport = eyre!("oh no!");
```
Replacement in tests/test_source.rs at line 36 [77.17]
B:BD[77.715] → [9.10688:10716]
```
    let error = eyre!(msg);
```
[77.715]
[78.115]
```
    let error: ErrReport = eyre!(msg);
```
Replacement in tests/test_source.rs at line 40 [77.17]
B:BD[78.185] → [9.10717:10745]
```
    let error = eyre!(msg);
```
[78.185]
[77.745]
```
    let error: ErrReport = eyre!(msg);
```

Replacement in tests/test_source.rs at line 46 [77.17]

B:BD[77.818] → [9.10746:10791]

    let error = eyre!("{} {}!", "oh", "no");

[77.818]

[77.865]

    let error: ErrReport = eyre!("{} {}!", "oh", "no");

Replacement in tests/test_source.rs at line 53 [77.17]
B:BD[77.998] → [9.10792:10834]
```
    let error = eyre!(TestError::Io(io));
```
[77.998]
[77.1042]
```
    let error: ErrReport = eyre!(TestError::Io(io));
```

Replacement in tests/test_source.rs at line 59 [77.17]

B:BD[9.10862] → [9.10862:10914]

    let error = eyre!("oh no!").context("context");

[9.10862]

[9.10914]

    let error: ErrReport = eyre!("oh no!").context("context");