use crate::wrapper::{DisplayError, MessageError};

use crate::wrapper::{BoxedError, DisplayError, MessageError};

    pub(crate) fn from_boxed(
        error: Box<dyn StdError + Send + Sync>,
        backtrace: Option<Backtrace>,
    ) -> Self {
        let error = BoxedError(error);
        let vtable = &ErrorVTable {
            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>>,
        };
        // Safety: BoxedError is repr(transparent) so it is okay for the vtable
        // to allow casting to Box<dyn StdError + Send + Sync>.
        unsafe { Error::construct(error, vtable, backtrace) }
    }

use std::error::Error as StdError;

    }
}
pub struct Boxed;
pub trait BoxedKind: Sized {
    #[inline]
    fn anyhow_kind(&self) -> Boxed {
        Boxed

impl BoxedKind for Box<dyn StdError + Send + Sync> {}
impl Boxed {
    pub fn new(self, error: Box<dyn StdError + Send + Sync>) -> Error {
        let backtrace = backtrace_if_absent!(error);
        Error::from_boxed(error, backtrace)
    }
}

    pub use crate::kind::{AdhocKind, TraitKind};

    pub use crate::kind::{AdhocKind, BoxedKind, TraitKind};

        use $crate::private::{AdhocKind, TraitKind};

        use $crate::private::{AdhocKind, BoxedKind, TraitKind};

use crate::backtrace::Backtrace;

#[repr(transparent)]
pub struct BoxedError(pub Box<dyn StdError + Send + Sync>);
impl Debug for BoxedError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        Debug::fmt(&self.0, f)
    }
}
impl Display for BoxedError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        Display::fmt(&self.0, f)
    }
}
impl StdError for BoxedError {
    #[cfg(backtrace)]
    fn backtrace(&self) -> Option<&Backtrace> {
        self.0.backtrace()
    }
    fn source(&self) -> Option<&(dyn StdError + 'static)> {
        self.0.source()
    }
}

use anyhow::anyhow;
use std::error::Error as StdError;
use std::io;
use thiserror::Error;
#[derive(Error, Debug)]
#[error("outer")]
struct MyError {
    source: io::Error,
}
#[test]
fn test_boxed_str() {
    let error = Box::<dyn StdError + Send + Sync>::from("oh no!");
    let error = anyhow!(error);
    assert_eq!("oh no!", error.to_string());
    assert_eq!(
        "oh no!",
        error
            .downcast_ref::<Box<dyn StdError + Send + Sync>>()
            .unwrap()
            .to_string()
    );
}
#[test]
fn test_boxed_thiserror() {
    let error = MyError {
        source: io::Error::new(io::ErrorKind::Other, "oh no!"),
    };
    let error = anyhow!(error);
    assert_eq!("oh no!", error.source().unwrap().to_string());
}
#[test]
fn test_boxed_anyhow() {
    let error = anyhow!("oh no!").context("it failed");
    let error = anyhow!(error);
    assert_eq!("oh no!", error.source().unwrap().to_string());
}