version = "0.3.10" # remember to update html_root_url

version = "0.4.0" # remember to update html_root_url

indenter = "^0.1.1"

indenter = "0.1.3"

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

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

    #[cfg(backtrace)]
    fn backtrace(&self) -> Option<&Backtrace> {
        Some(self.error.backtrace())
    }

use core::any::Any;

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

    /// Get the backtrace for this Report.
    ///
    /// Backtraces are only available on the nightly channel. Tracking issue:
    /// [rust-lang/rust#53487][tracking].
    ///
    /// In order for the backtrace to be meaningful, one of the two environment
    /// variables `RUST_LIB_BACKTRACE=1` or `RUST_BACKTRACE=1` must be defined
    /// and `RUST_LIB_BACKTRACE` must not be `0`. Backtraces are somewhat
    /// expensive to capture in Rust, so we don't necessarily want to be
    /// capturing them all over the place all the time.
    ///
    /// - If you want panics and errors to both have backtraces, set
    ///   `RUST_BACKTRACE=1`;
    /// - If you want only errors to have backtraces, set
    ///   `RUST_LIB_BACKTRACE=1`;
    /// - If you want only panics to have backtraces, set `RUST_BACKTRACE=1` and
    ///   `RUST_LIB_BACKTRACE=0`.
    ///
    /// [tracking]: https://github.com/rust-lang/rust/issues/53487
    #[cfg(backtrace)]
    pub fn backtrace(&self) -> &Backtrace {
        self.inner.backtrace()
    }

    }
    pub fn member_ref<T: Any>(&self) -> Option<&T> {
        self.inner.member_ref()

    pub fn member_mut<T: Any>(&mut self) -> Option<&mut T> {
        self.inner.member_mut()
    }

    /// Get a reference to the Context for this Report.

    /// Get a mutable reference to the Context for this Report.

    }
    pub fn member_ref<T: Any>(&self) -> Option<&T> {
        self.context
            .as_ref()
            .unwrap()
            .member_ref(TypeId::of::<T>())?
            .downcast_ref::<T>()
    }
    pub fn member_mut<T: Any>(&mut self) -> Option<&mut T> {
        self.context
            .as_mut()
            .unwrap()
            .member_mut(TypeId::of::<T>())?
            .downcast_mut::<T>()

    #[cfg(backtrace)]
    pub(crate) fn backtrace(&self) -> &Backtrace {
        // This unwrap can only panic if the underlying error's backtrace method
        // is nondeterministic, which would only happen in maliciously
        // constructed code.
        self.member_ref()
            .or_else(|| self.error().backtrace())
            .expect("backtrace capture failed")
    }

    #[cfg(backtrace)]
    fn backtrace(&self) -> Option<&Backtrace> {
        Some(self.erase().backtrace())
    }

//! eyre = "0.3"

//! eyre = "0.4"

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

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

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

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

use core::any::{Any, TypeId};

    /// Member access function
    ///
    /// The main reason to implement this fn is to provide support for `eyre::Report::backtrace`
    /// which will call this fn on `nightly` when attempting access the captured
    /// `std::backtrace::Backtrace`
    ///
    /// # Example
    fn member_ref(&self, _typeid: TypeId) -> Option<&dyn Any> {
        None
    }

    #[doc(hidden)]
    fn member_mut(&mut self, _typeid: TypeId) -> Option<&mut dyn Any> {
        None
    }
    #[doc(hidden)]

    /// Override for the `Display` format

#[allow(dead_code)]

    fn member_ref(&self, typeid: TypeId) -> Option<&dyn Any> {
        if typeid == TypeId::of::<Backtrace>() {
            self.backtrace.as_ref().map(|b| b as &dyn Any)
        } else {
            None
        }
    }

#[rustversion::not(nightly)]
#[ignore]
#[test]
fn test_backtrace() {}
#[rustversion::nightly]
#[test]
fn test_backtrace() {
    use eyre::{eyre, Report};
    let error: Report = eyre!("oh no!");
    let _ = error.backtrace();
}

#[test]
fn test_context() {
    use eyre::{eyre, Report};
    let error: Report = eyre!("oh no!");
    let _ = error.context();
}