yaahc/eyre - Change X4XC4Q2MJC6Q45SOWNGIG2PWZFE4AG5E3M5ZW3OGV6ABUVC2XNGQC

Rename ErrReport to Report (#9) * Rename ErrReport to Report * bump versions to prep for a release

Created by Jane Lusby on April 13, 2020

X4XC4Q2MJC6Q45SOWNGIG2PWZFE4AG5E3M5ZW3OGV6ABUVC2XNGQC

Dependencies

In channels

main

Change contents

Replacement in Cargo.toml at line 3 [7.13]

B:BD[6.14] → [5.0:53]

version = "0.3.7" # remember to update html_root_url

[6.14]

[8.53]

version = "0.3.8" # remember to update html_root_url

Replacement in README.md at line 8 [11.12]

B:BD[9.1] → [10.1849:1924]

This library provides [`eyre::ErrReport`][ErrReport], a trait object based

[9.1]

[10.1924]

This library provides [`eyre::Report`][Report], a trait object based

Replacement in README.md at line 34 [11.12]

B:BD[12.1243] → [12.1243:1320]

  implementation is conspicuously absent on `ErrReport`. Instead it contains

[12.1243]

[12.1320]

  implementation is conspicuously absent on `Report`. Instead it contains

Replacement in README.md at line 44 [11.12]

∅:D[4.237] → [12.1857:1930]

B:BD[12.1857] → [12.1857:1930]

  and `context`/`context_mut` on `ErrReport` for working with the custom

[4.237]

[12.1930]

  and `context`/`context_mut` on `Report` for working with the custom

Replacement in README.md at line 86 [11.12]

B:BD[8.4308] → [8.4308:4386]

When overriding the context it no longer makes sense for `eyre::ErrReport` to

[8.4308]

[8.4386]

When overriding the context it no longer makes sense for `eyre::Report` to

Replacement in README.md at line 111 [11.12]

B:BD[12.2481] → [12.2481:2561]

the `Error` trait. The main `ErrReport` type provides versions of these methods

[12.2481]

[12.2561]

the `Error` trait. The main `Report` type provides versions of these methods

Replacement in README.md at line 115 [11.12]

B:BD[12.2670] → [12.2670:2748]

**Note**: The `backtrace()` fn on `ErrReport` relies on the implementation of

[12.2670]

[12.2748]

**Note**: The `backtrace()` fn on `Report` relies on the implementation of

Replacement in README.md at line 138 [11.12]
B:BD[8.5513] → [8.5513:5558]
```
type ErrReport = eyre::ErrReport<MyContext>;
```
[8.5513]
[8.5558]
```
type Report = eyre::Report<MyContext>;
```

Replacement in README.md at line 141 [11.12]

B:BD[8.5580] → [8.5580:5657]

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

[8.5580]

[11.431]

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

Replacement in README.md at line 148 [11.12]

B:BD[13.13] → [10.2081:2159]

- Use `Result<T, eyre::ErrReport>`, or equivalently `eyre::Result<T>`, as the

[13.13]

[13.91]

- Use `Result<T, eyre::Report>`, or equivalently `eyre::Result<T>`, as the

Replacement in README.md at line 227 [11.12]

B:BD[6.804] → [10.2160:2227]

  supports string interpolation and produces an `eyre::ErrReport`.

[6.804]

[13.1763]

  supports string interpolation and produces an `eyre::Report`.

Replacement in README.md at line 252 [11.12]

B:BD[14.457] → [10.2228:2310]

require an explicit `.map_err(ErrReport::msg)` when working with a non-Eyre error

[14.457]

[15.258]

require an explicit `.map_err(Report::msg)` when working with a non-Eyre error

Replacement in README.md at line 259 [11.12]

B:BD[13.1770] → [10.2311:2388]

The `eyre::ErrReport` type works something like `failure::Error`, but unlike

[13.1770]

[16.102]

The `eyre::Report` type works something like `failure::Error`, but unlike

Replacement in README.md at line 301 [11.12]

B:BD[17.795] → [17.795:886]

let val: ErrReport = get_optional_val.ok_or_else(|| eyre!("failed to get value)).unwrap();

[17.795]

[17.886]

let val: Report = get_optional_val.ok_or_else(|| eyre!("failed to get value)).unwrap();

Replacement in README.md at line 303 [11.12]

B:BD[17.890] → [18.56:119]

[ErrReport]: https://docs.rs/eyre/*/eyre/struct.ErrReport.html

[17.890]

[19.303]

[Report]: https://docs.rs/eyre/*/eyre/struct.Report.html

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

B:BD[20.32] → [21.223:279]

use crate::{ErrReport, EyreContext, StdError, WrapErr};

[20.32]

[23.31]

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

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

B:BD[24.155] → [24.155:210]

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

[24.155]

[25.107]

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

Replacement in src/context.rs at line 26 [22.642]

B:BD[22.1587] → [24.270:325]

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

[22.1587]

[25.306]

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

Replacement in src/context.rs at line 30 [22.642]

B:BD[25.378] → [15.528:571]

            ErrReport::from_msg(msg, self)

[25.378]

[25.434]

            Report::from_msg(msg, self)

Replacement in src/context.rs at line 34 [22.642]
B:BD[25.451] → [24.326:367]
```
    impl<C> StdError<C> for ErrReport<C>
```
[25.451]
[24.367]
```
    impl<C> StdError<C> for Report<C>
```

Replacement in src/context.rs at line 38 [22.642]

B:BD[24.407] → [24.407:462]

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

[24.407]

[25.534]

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

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

B:BD[25.747] → [24.582:642]

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

[25.747]

[26.447]

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

Replacement in src/context.rs at line 59 [22.642]

B:BD[22.1924] → [24.643:711]

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

[22.1924]

[27.436]

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

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

B:BD[22.2904] → [28.1605:1659]

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

[22.2904]

[26.793]

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

Replacement in src/error.rs at line 4 [22.3238]
∅:D[21.304] → [6.1928:1962]
B:BD[29.573] → [6.1928:1962]
```
use crate::{ErrReport, StdError};
```
[21.304]
[21.305]
```
use crate::{Report, StdError};
```
Replacement in src/error.rs at line 17 [22.3238]
B:BD[22.3932] → [28.1810:1831]
```
impl<C> ErrReport<C>
```
[22.3932]
[28.1831]
```
impl<C> Report<C>
```

Replacement in src/error.rs at line 23 [22.3238]

B:BD[22.4009] → [6.1981:2062]

    /// The error type must be threadsafe and `'static`, so that the `ErrReport`

[22.4009]

[30.169]

    /// The error type must be threadsafe and `'static`, so that the `Report`

Replacement in src/error.rs at line 33 [22.3238]
B:BD[22.4341] → [28.1860:1895]
```
        ErrReport::from_std(error)
```
[22.4341]
[31.17]
```
        Report::from_std(error)
```

Replacement in src/error.rs at line 38 [22.3238]

B:BD[31.98] → [6.2110:2188]

    /// If the argument implements std::error::Error, prefer `ErrReport::new`

[31.98]

[31.172]

    /// If the argument implements std::error::Error, prefer `Report::new`

Replacement in src/error.rs at line 44 [22.3238]

B:BD[31.422] → [6.2262:2343]

    /// `ErrReport::msg("...")` is equivalent to `eyre!("...")` but occasionally

[31.422]

[31.501]

    /// `Report::msg("...")` is equivalent to `eyre!("...")` but occasionally

Replacement in src/error.rs at line 59 [22.3238]
B:BD[31.931] → [6.2344:2383]
```
    /// use eyre::{ErrReport, Result};
```
[31.931]
[31.968]
```
    /// use eyre::{Report, Result};
```
Replacement in src/error.rs at line 68 [22.3238]
B:BD[31.1252] → [6.2384:2425]
```
    ///         .map_err(ErrReport::msg)
```
[31.1252]
[31.1289]
```
    ///         .map_err(Report::msg)
```
Replacement in src/error.rs at line 77 [22.3238]
B:BD[31.1471] → [28.1896:1935]
```
        ErrReport::from_adhoc(message)
```
[31.1471]
[32.95]
```
        Report::from_adhoc(message)
```

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

B:BD[5.102] → [5.102:166]

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

[5.102]

[22.4396]

        unsafe { Report::construct(error, vtable, context) }

Replacement in src/error.rs at line 119 [22.3238]

B:BD[5.215] → [5.215:279]

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

[5.215]

[33.1044]

        unsafe { Report::construct(error, vtable, context) }

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

B:BD[5.328] → [5.328:392]

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

[5.328]

[22.4605]

        unsafe { Report::construct(error, vtable, context) }

Replacement in src/error.rs at line 162 [22.3238]

B:BD[34.797] → [5.442:506]

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

[34.797]

[34.859]

        unsafe { Report::construct(error, vtable, context) }

Replacement in src/error.rs at line 187 [22.3238]
B:BD[35.259] → [6.2815:2843]
```
        ErrReport { inner }
```
[35.259]
[36.390]
```
        Report { inner }
```

Replacement in src/error.rs at line 239 [22.3238]

B:BD[37.1438] → [3.518:580]

    ///         eyre::ErrReport::new(error).wrap_err(message)

[37.1438]

[37.1497]

    ///         eyre::Report::new(error).wrap_err(message)

Replacement in src/error.rs at line 248 [22.3238]

∅:D[5.705] → [21.538:624]

B:BD[36.559] → [21.538:624]

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

[5.705]

[38.47]

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

Replacement in src/error.rs at line 251 [22.3238]

B:BD[38.84] → [28.4683:4829]

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

[38.84]

[29.1092]

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

Replacement in src/error.rs at line 254 [22.3238]

B:BD[29.1128] → [28.4830:4978]

            object_mut: object_mut::<ContextError<D, ErrReport<C>>, C>,
            object_boxed: object_boxed::<ContextError<D, ErrReport<C>>, C>,

[29.1128]

[28.4978]

            object_mut: object_mut::<ContextError<D, Report<C>>, C>,
            object_boxed: object_boxed::<ContextError<D, Report<C>>, C>,

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

B:BD[38.662] → [5.706:770]

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

[38.662]

[22.5336]

        unsafe { Report::construct(error, vtable, context) }

Replacement in src/error.rs at line 264 [22.3238]
B:BD[22.5343] → [6.3417:3463]
```
    /// Get the backtrace for this ErrReport.
```
[22.5343]
[39.1084]
```
    /// Get the backtrace for this Report.
```

Replacement in src/error.rs at line 280 [22.3238]

B:BD[22.5921] → [6.3464:3543]

    /// An iterator of the chain of source errors contained by this ErrReport.

[22.5921]

[22.5980]

    /// An iterator of the chain of source errors contained by this Report.

Replacement in src/error.rs at line 289 [22.3238]
B:BD[40.46] → [6.3544:3573]
```
    /// use eyre::ErrReport;
```
[40.46]
[40.73]
```
    /// use eyre::Report;
```

Replacement in src/error.rs at line 292 [22.3238]

B:BD[40.102] → [6.3574:3660]

    /// pub fn underlying_io_error_kind(error: &ErrReport) -> Option<io::ErrorKind> {

[40.102]

[40.184]

    /// pub fn underlying_io_error_kind(error: &Report) -> Option<io::ErrorKind> {

Replacement in src/error.rs at line 310 [22.3238]
B:BD[41.195] → [6.3661:3700]
```
    /// [`chain()`][ErrReport::chain].
```
[41.195]
[29.1158]
```
    /// [`chain()`][Report::chain].
```

Replacement in src/error.rs at line 357 [22.3238]

B:BD[42.881] → [6.3701:3768]

            // ErrReport has a Drop impl which we want to not run.

[42.881]

[43.631]

            // Report has a Drop impl which we want to not run.

Replacement in src/error.rs at line 373 [22.3238]
B:BD[44.46] → [28.5234:5273]
```
    /// # use eyre::{ErrReport, eyre};
```
[44.46]
[44.76]
```
    /// # use eyre::{Report, eyre};
```

Replacement in src/error.rs at line 392 [22.3238]

B:BD[44.579] → [28.5274:5321]

    /// # let error: ErrReport = eyre!("...");

[44.579]

[44.617]

    /// # let error: Report = eyre!("...");

Replacement in src/error.rs at line 449 [22.3238]
B:BD[29.1211] → [28.5322:5358]
```
impl<E, C> From<E> for ErrReport<C>
```
[29.1211]
[26.1305]
```
impl<E, C> From<E> for Report<C>
```
Replacement in src/error.rs at line 455 [22.3238]
B:BD[45.219] → [28.5380:5415]
```
        ErrReport::from_std(error)
```
[45.219]
[22.7611]
```
        Report::from_std(error)
```
Replacement in src/error.rs at line 460 [22.3238]
B:BD[29.1236] → [28.5416:5462]
```
impl<C: EyreContext> Deref for ErrReport<C> {
```
[29.1236]
[46.1503]
```
impl<C: EyreContext> Deref for Report<C> {
```
Replacement in src/error.rs at line 469 [22.3238]
B:BD[29.1261] → [28.5463:5512]
```
impl<C: EyreContext> DerefMut for ErrReport<C> {
```
[29.1261]
[22.7805]
```
impl<C: EyreContext> DerefMut for Report<C> {
```
Replacement in src/error.rs at line 475 [22.3238]
B:BD[22.7896] → [28.5513:5561]
```
impl<C: EyreContext> Display for ErrReport<C> {
```
[22.7896]
[47.106]
```
impl<C: EyreContext> Display for Report<C> {
```
Replacement in src/error.rs at line 481 [22.3238]
B:BD[22.8843] → [28.5562:5608]
```
impl<C: EyreContext> Debug for ErrReport<C> {
```
[22.8843]
[48.88]
```
impl<C: EyreContext> Debug for Report<C> {
```
Replacement in src/error.rs at line 487 [22.3238]
B:BD[22.8984] → [28.5609:5639]
```
impl<C> Drop for ErrReport<C>
```
[22.8984]
[28.5639]
```
impl<C> Drop for Report<C>
```

Replacement in src/error.rs at line 636 [22.3238]

B:BD[49.512] → [28.8398:8479]

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

[49.512]

[28.8479]

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

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

B:BD[21.756] → [21.756:852]

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

[21.756]

[28.8761]

            e as *const ErrorImpl<(), C> as *const ErrorImpl<ContextError<D, Report<C>>, C>;

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

B:BD[21.876] → [21.876:972]

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

[21.876]

[50.497]

            e as *const ErrorImpl<(), C> as *const ErrorImpl<ContextError<D, Report<C>>, C>;

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

B:BD[49.1482] → [28.8938:9019]

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

[49.1482]

[28.9019]

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

Replacement in src/error.rs at line 667 [22.3238]

B:BD[28.9291] → [28.9291:9367]

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

[28.9291]

[51.2026]

            Box<ErrorImpl<ContextError<ManuallyDrop<D>, Report<C>>, C>>,

Replacement in src/error.rs at line 669 [22.3238]

B:BD[51.2040] → [6.4488:4572]

        // Drop the entire rest of the data structure rooted in the next ErrReport.

[51.2040]

        // Drop the entire rest of the data structure rooted in the next Report.

Replacement in src/error.rs at line 674 [22.3238]

B:BD[28.9403] → [28.9403:9479]

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

[28.9403]

[49.2051]

            Box<ErrorImpl<ContextError<D, ManuallyDrop<Report<C>>>, C>>,

Replacement in src/error.rs at line 801 [22.3238]

B:BD[47.2643] → [28.10367:10498]

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

[47.2643]

[47.2744]

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

Replacement in src/error.rs at line 806 [22.3238]

B:BD[42.3141] → [6.4754:4821]

            // ErrReport has a Drop impl which we want to not run.

[42.3141]

[47.2807]

            // Report has a Drop impl which we want to not run.

Replacement in src/error.rs at line 817 [22.3238]

B:BD[52.9] → [28.10499:10616]

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

[52.9]

[52.96]

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

Replacement in src/error.rs at line 824 [22.3238]

B:BD[29.1419] → [28.10617:10691]

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

[29.1419]

[53.60]

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

Replacement in src/error.rs at line 831 [22.3238]

B:BD[29.1444] → [28.10692:10752]

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

[29.1444]

[53.188]

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

Replacement in src/kind.rs at line 3 [55.10]

B:BD[54.80] → [6.5092:5253]

// When eyre! is given a single expr argument to turn into eyre::ErrReport, we
// want the resulting ErrReport to pick up the input's implementation of source()

[54.80]

[54.237]

// When eyre! is given a single expr argument to turn into eyre::Report, we
// want the resulting Report to pick up the input's implementation of source()

Replacement in src/kind.rs at line 11 [55.10]
B:BD[6.5277] → [6.5277:5315]
```
//         fn new(self) -> ErrReport;
```
[6.5277]
[54.480]
```
//         fn new(self) -> Report;
```
Replacement in src/kind.rs at line 18 [55.10]
B:BD[54.600] → [6.5346:5393]
```
//         default fn new(self) -> ErrReport {
```
[54.600]
[54.643]
```
//         default fn new(self) -> Report {
```
Replacement in src/kind.rs at line 27 [55.10]
B:BD[54.817] → [6.5424:5463]
```
//         fn new(self) -> ErrReport {
```
[54.817]
[54.852]
```
//         fn new(self) -> Report {
```
Replacement in src/kind.rs at line 47 [55.10]
B:BD[54.1632] → [21.1135:1172]
```
use crate::{ErrReport, EyreContext};
```
[54.1632]
[23.275]
```
use crate::{EyreContext, Report};
```

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

B:BD[55.369] → [28.10926:10994]

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

[55.369]

[55.414]

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

Replacement in src/kind.rs at line 72 [55.10]
B:BD[55.482] → [28.10995:11034]
```
        ErrReport::from_adhoc(message)
```
[55.482]
[55.531]
```
        Report::from_adhoc(message)
```

Replacement in src/kind.rs at line 85 [55.10]

B:BD[55.662] → [6.5837:5889]

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

[55.662]

[55.731]

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

Replacement in src/kind.rs at line 88 [55.10]

B:BD[55.745] → [6.5890:5937]

    pub fn new<E>(self, error: E) -> ErrReport

[55.745]

[55.788]

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

Replacement in src/kind.rs at line 90 [55.10]
B:BD[55.798] → [6.5938:5966]
```
        E: Into<ErrReport>,
```
[55.798]
[55.843]
```
        E: Into<Report>,
```

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

B:BD[34.1095] → [28.11035:11167]

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

[34.1095]

[34.1264]

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

Replacement in src/lib.rs at line 1 [22.11888]

B:BD[22.11888] → [6.6129:6214]

//! This library provides [`eyre::ErrReport`][ErrReport], a trait object based error

[22.11888]

[56.79]

//! This library provides [`eyre::Report`][Report], a trait object based error

Replacement in src/lib.rs at line 26 [22.11888]

B:BD[57.1411] → [57.1411:1492]

//!   implementation is conspicuously absent on `ErrReport`. Instead it contains

[57.1411]

[57.1492]

//!   implementation is conspicuously absent on `Report`. Instead it contains

Replacement in src/lib.rs at line 36 [22.11888]

B:BD[57.2143] → [57.2143:2220]

//!   and `context`/`context_mut` on `ErrReport` for working with the custom

[57.2143]

[57.2220]

//!   and `context`/`context_mut` on `Report` for working with the custom

Replacement in src/lib.rs at line 78 [22.11888]

B:BD[57.3657] → [57.3657:3739]

//! When overriding the context it no longer makes sense for `eyre::ErrReport` to

[57.3657]

[57.3739]

//! When overriding the context it no longer makes sense for `eyre::Report` to

Replacement in src/lib.rs at line 103 [22.11888]

B:BD[57.5138] → [57.5138:5222]

//! the `Error` trait. The main `ErrReport` type provides versions of these methods

[57.5138]

[57.5222]

//! the `Error` trait. The main `Report` type provides versions of these methods

Replacement in src/lib.rs at line 107 [22.11888]

B:BD[57.5342] → [57.5342:5424]

//! **Note**: The `backtrace()` fn on `ErrReport` relies on the implementation of

[57.5342]

[57.5424]

//! **Note**: The `backtrace()` fn on `Report` relies on the implementation of

Replacement in src/lib.rs at line 130 [22.11888]
B:BD[57.6204] → [57.6204:6253]
```
//! type ErrReport = eyre::ErrReport<MyContext>;
```
[57.6204]
[57.6253]
```
//! type Report = eyre::Report<MyContext>;
```

Replacement in src/lib.rs at line 133 [22.11888]

B:BD[57.6282] → [57.6282:6363]

//! type Result<T, E = eyre::ErrReport<MyContext>> = core::result::Result<T, E>;

[57.6282]

[57.6363]

//! type Result<T, E = eyre::Report<MyContext>> = core::result::Result<T, E>;

Replacement in src/lib.rs at line 139 [22.11888]

B:BD[56.179] → [6.6215:6293]

//! - Use `Result<T, eyre::ErrReport>`, or equivalently `eyre::Result<T>`, as

[56.179]

[56.257]

//! - Use `Result<T, eyre::Report>`, or equivalently `eyre::Result<T>`, as

Replacement in src/lib.rs at line 143 [22.11888]
B:BD[56.390] → [6.6294:6335]
```
//!   the `std::error::ErrReport` trait.
```
[56.390]
[56.427]
```
//!   the `std::error::Report` trait.
```
Replacement in src/lib.rs at line 221 [22.11888]
B:BD[56.1608] → [28.11168:11205]
```
//!   # use eyre::{ErrReport, eyre};
```
[56.1608]
[58.871]
```
//!   # use eyre::{Report, eyre};
```
Replacement in src/lib.rs at line 240 [22.11888]
B:BD[58.1338] → [28.11206:11251]
```
//!   # let error: ErrReport = eyre!("...");
```
[58.1338]
[58.1374]
```
//!   # let error: Report = eyre!("...");
```

Replacement in src/lib.rs at line 280 [22.11888]

B:BD[6.6536] → [6.6536:6607]

//!   supports string interpolation and produces an `eyre::ErrReport`.

[6.6536]

[56.2126]

//!   supports string interpolation and produces an `eyre::Report`.

Replacement in src/lib.rs at line 306 [22.11888]

B:BD[14.1027] → [6.6761:6920]

//! `std::error::ErrReport` trait which is only available through std, no_std mode
//! will require an explicit `.map_err(ErrReport::msg)` when working with a

[14.1027]

[15.1746]

//! `std::error::Report` trait which is only available through std, no_std mode
//! will require an explicit `.map_err(Report::msg)` when working with a

Replacement in src/lib.rs at line 310 [22.11888]

B:BD[59.420] → [59.420:487]

//! [ErrReport]: https://docs.rs/eyre/*/eyre/struct.ErrReport.html

[59.420]

[59.487]

//! [Report]: https://docs.rs/eyre/*/eyre/struct.Report.html

Replacement in src/lib.rs at line 317 [22.11888]

B:BD[56.2544] → [5.1339:1393]

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

[56.2544]

[39.1865]

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

Insertion in src/lib.rs at line 374 [22.11888]
[6.7005]
[60.79]
```
#[doc(hidden)]
pub use Report as ErrReport;
```

Replacement in src/lib.rs at line 377 [22.11888]

B:BD[60.80] → [6.7006:7071]

/// The `ErrReport` type, a wrapper around a dynamic error type.

[60.80]

[61.217]

/// The core error reporting type of the library, a wrapper around a dynamic error reporting type.

Replacement in src/lib.rs at line 379 [22.11888]

B:BD[61.221] → [6.7072:7150]

/// `ErrReport` works a lot like `Box<dyn std::error::Error>`, but with these

[61.221]

[61.295]

/// `Report` works a lot like `Box<dyn std::error::Error>`, but with these

Replacement in src/lib.rs at line 382 [22.11888]

B:BD[61.316] → [6.7151:7310]

/// - `ErrReport` requires that the error is `Send`, `Sync`, and `'static`.
/// - `ErrReport` guarantees that a backtrace is available, even if the underlying

[61.316]

[61.467]

/// - `Report` requires that the error is `Send`, `Sync`, and `'static`.
/// - `Report` guarantees that a backtrace is available, even if the underlying

Replacement in src/lib.rs at line 385 [22.11888]

B:BD[61.506] → [6.7311:7392]

/// - `ErrReport` is represented as a narrow pointer &mdash; exactly one word in

[61.506]

[61.583]

/// - `Report` is represented as a narrow pointer &mdash; exactly one word in

Replacement in src/lib.rs at line 394 [22.11888]

B:BD[3.1336] → [3.1336:1407]

/// impl of the error from which you constructed your eyre::ErrReport.

[3.1336]

[62.333]

/// impl of the error from which you constructed your eyre::Report.

Replacement in src/lib.rs at line 468 [22.11888]
B:BD[62.2560] → [28.11314:11355]
```
pub struct ErrReport<C = DefaultContext>
```
[62.2560]
[28.11355]
```
pub struct Report<C = DefaultContext>
```

Replacement in src/lib.rs at line 581 [22.11888]

B:BD[61.723] → [6.7834:7898]

/// This type is the iterator returned by [`ErrReport::chain`].

[61.723]

[61.783]

/// This type is the iterator returned by [`Report::chain`].

Replacement in src/lib.rs at line 586 [22.11888]
B:BD[61.813] → [6.7899:7924]
```
/// use eyre::ErrReport;
```
[61.813]
[61.836]
```
/// use eyre::Report;
```

Replacement in src/lib.rs at line 589 [22.11888]

B:BD[61.857] → [6.7925:8007]

/// pub fn underlying_io_error_kind(error: &ErrReport) -> Option<io::ErrorKind> {

[61.857]

[61.935]

/// pub fn underlying_io_error_kind(error: &Report) -> Option<io::ErrorKind> {

Replacement in src/lib.rs at line 652 [22.11888]

B:BD[63.667] → [28.12124:12204]

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

[63.667]

[60.83]

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

Replacement in src/lib.rs at line 799 [22.11888]

B:BD[15.2572] → [24.1608:1668]

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

[15.2572]

[60.1425]

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

Replacement in src/lib.rs at line 805 [22.11888]

B:BD[60.1597] → [24.1669:1735]

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

[60.1597]

[60.1655]

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

Replacement in src/lib.rs at line 814 [22.11888]
B:BD[64.210] → [21.2496:2537]
```
    use crate::{ErrReport, EyreContext};
```
[64.210]
[23.424]
```
    use crate::{EyreContext, Report};
```

Replacement in src/lib.rs at line 830 [22.11888]

B:BD[55.1152] → [28.12467:12522]

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

[55.1152]

[64.314]

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

Replacement in src/lib.rs at line 835 [22.11888]
B:BD[64.382] → [28.12548:12587]
```
        ErrReport::from_adhoc(message)
```
[64.382]
[65.1760]
```
        Report::from_adhoc(message)
```
Replacement in tests/test_autotrait.rs at line 1 [66.20]
B:BD[66.20] → [6.9471:9492]
```
use eyre::ErrReport;
```
[66.20]
[66.40]
```
use eyre::Report;
```
Replacement in tests/test_autotrait.rs at line 6 [66.20]
B:BD[66.99] → [6.9493:9525]
```
    assert_send::<ErrReport>();
```
[66.99]
[66.127]
```
    assert_send::<Report>();
```
Replacement in tests/test_autotrait.rs at line 12 [66.20]
B:BD[66.188] → [6.9526:9558]
```
    assert_sync::<ErrReport>();
```
[66.188]
[66.216]
```
    assert_sync::<Report>();
```
Replacement in tests/test_backtrace.rs at line 9 [67.41]
B:BD[67.167] → [28.12588:12621]
```
    use eyre::{eyre, ErrReport};
```
[67.167]
[67.191]
```
    use eyre::{eyre, Report};
```
Replacement in tests/test_backtrace.rs at line 11 [67.41]
B:BD[67.192] → [28.12622:12666]
```
    let error: ErrReport = eyre!("oh no!");
```
[67.192]
[67.227]
```
    let error: Report = eyre!("oh no!");
```
Replacement in tests/test_boxed.rs at line 1 [34.2018]
B:BD[34.2018] → [21.2610:2639]
```
use eyre::{eyre, ErrReport};
```
[34.2018]
[34.2039]
```
use eyre::{eyre, Report};
```
Replacement in tests/test_boxed.rs at line 15 [34.2018]
B:BD[34.2292] → [28.12697:12738]
```
    let error: ErrReport = eyre!(error);
```
[34.2292]
[34.2324]
```
    let error: Report = eyre!(error);
```
Replacement in tests/test_chain.rs at line 1 [68.16]
B:BD[68.16] → [6.9801:9830]
```
use eyre::{eyre, ErrReport};
```
[68.16]
[68.46]
```
use eyre::{eyre, Report};
```
Replacement in tests/test_chain.rs at line 3 [68.16]
B:BD[68.47] → [6.9831:9857]
```
fn error() -> ErrReport {
```
[68.47]
[15.2976]
```
fn error() -> Report {
```
Replacement in tests/test_context.rs at line 4 [70.18]
B:BD[69.48] → [21.2640:2680]
```
use eyre::{ErrReport, Result, WrapErr};
```
[69.48]
[69.86]
```
use eyre::{Report, Result, WrapErr};
```
Replacement in tests/test_context.rs at line 59 [70.18]
B:BD[69.938] → [6.9991:10033]
```
fn make_chain() -> (ErrReport, Dropped) {
```
[69.938]
[69.976]
```
fn make_chain() -> (Report, Dropped) {
```
Replacement in tests/test_context.rs at line 80 [70.18]
∅:D[71.913] → [6.10034:10075]
B:BD[69.1490] → [6.10034:10075]
```
    let high = Err::<(), ErrReport>(mid)
```
[71.913]
[15.3102]
```
    let high = Err::<(), Report>(mid)
```
Replacement in tests/test_convert.rs at line 4 [73.18]
B:BD[72.553] → [6.10076:10107]
```
use eyre::{ErrReport, Result};
```
[72.553]
[73.77]
```
use eyre::{Report, Result};
```

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

B:BD[72.589] → [28.12739:12813]

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

[72.589]

[73.352]

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

Replacement in tests/test_downcast.rs at line 6 [74.311]
B:BD[72.659] → [28.12814:12853]
```
use eyre::{DefaultContext, ErrReport};
```
[72.659]
[75.1101]
```
use eyre::{DefaultContext, Report};
```

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

B:BD[72.695] → [28.12854:12928]

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

[72.695]

[76.299]

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

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

B:BD[75.1493] → [28.12929:13017]

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

[75.1493]

[77.418]

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

Replacement in tests/test_repr.rs at line 5 [78.32]
B:BD[28.13245] → [21.2810:2831]
```
use eyre::ErrReport;
```
[28.13245]
[78.118]
```
use eyre::Report;
```

Replacement in tests/test_repr.rs at line 11 [78.32]

B:BD[74.853] → [6.10397:10467]

    assert_eq!(mem::size_of::<ErrReport>(), mem::size_of::<usize>());

[74.853]

[78.348]

    assert_eq!(mem::size_of::<Report>(), mem::size_of::<usize>());

Replacement in tests/test_repr.rs at line 17 [78.32]

B:BD[21.2848] → [21.2848:2897]

        mem::size_of::<Result<(), ErrReport>>(),

[21.2848]

[21.2897]

        mem::size_of::<Result<(), Report>>(),

Replacement in tests/test_repr.rs at line 25 [78.32]
B:BD[78.436] → [6.10551:10578]
```
    assert::<ErrReport>();
```
[78.436]
[78.459]
```
    assert::<Report>();
```

Replacement in tests/test_repr.rs at line 31 [78.32]

B:BD[72.801] → [21.2937:3027]

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

[72.801]

[72.802]

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

Replacement in tests/test_source.rs at line 1 [79.17]
B:BD[79.17] → [21.3028:3057]
```
use eyre::{eyre, ErrReport};
```
[79.17]
[79.38]
```
use eyre::{eyre, Report};
```
Replacement in tests/test_source.rs at line 29 [79.17]
B:BD[79.578] → [28.13352:13396]
```
    let error: ErrReport = eyre!("oh no!");
```
[79.578]
[79.613]
```
    let error: Report = eyre!("oh no!");
```
Replacement in tests/test_source.rs at line 36 [79.17]
B:BD[79.715] → [28.13397:13436]
```
    let error: ErrReport = eyre!(msg);
```
[79.715]
[80.115]
```
    let error: Report = eyre!(msg);
```
Replacement in tests/test_source.rs at line 40 [79.17]
B:BD[80.185] → [28.13437:13476]
```
    let error: ErrReport = eyre!(msg);
```
[80.185]
[79.745]
```
    let error: Report = eyre!(msg);
```

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

B:BD[79.818] → [28.13477:13533]

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

[79.818]

[79.865]

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

Replacement in tests/test_source.rs at line 53 [79.17]

B:BD[79.998] → [28.13534:13587]

    let error: ErrReport = eyre!(TestError::Io(io));

[79.998]

[79.1042]

    let error: Report = eyre!(TestError::Io(io));

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

B:BD[6.10862] → [15.3193:3257]

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

[6.10862]

[6.10914]

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

Replacement in tests/ui/no-impl.stderr at line 8 [81.310]

B:BD[2.93] → [2.93:158]

  | doesn't satisfy `Error: std::convert::Into<eyre::ErrReport>`

[2.93]

[2.158]

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

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

B:BD[6.11262] → [2.210:265]

          `Error: std::convert::Into<eyre::ErrReport>`

[6.11262]

[2.265]

          `Error: std::convert::Into<eyre::Report>`

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

B:BD[2.427] → [2.427:483]

          `&Error: std::convert::Into<eyre::ErrReport>`

[2.427]

[2.483]

          `&Error: std::convert::Into<eyre::Report>`