object_is: object_is::<ContextError<C, Error>>,
            object_downcast: object_downcast::<ContextError<C, Error>>,
            object_drop_rest: object_drop_front::<ContextError<C, Error>>,

            object_is: context_chain_is::<C>,
            object_downcast: context_chain_downcast::<C>,
            object_drop_rest: context_chain_drop_rest::<C>,

        unsafe { (self.inner.vtable.object_is)(target) }

        unsafe { (self.inner.vtable.object_is)(&self.inner, target) }

    object_is: unsafe fn(TypeId) -> bool,

    object_is: unsafe fn(&ErrorImpl<()>, TypeId) -> bool,

unsafe fn object_is<E>(target: TypeId) -> bool

unsafe fn object_is<E>(e: &ErrorImpl<()>, target: TypeId) -> bool

    let _ = e;

unsafe fn context_is<C, E>(target: TypeId) -> bool

unsafe fn context_is<C, E>(e: &ErrorImpl<()>, target: TypeId) -> bool

    let _ = e;

        >(e);
        drop(unerased);
    }
}
unsafe fn context_chain_is<C>(e: &ErrorImpl<()>, target: TypeId) -> bool
where
    C: 'static,
{
    if TypeId::of::<C>() == target {
        true
    } else {
        let unerased = e as *const ErrorImpl<()> as *const ErrorImpl<ContextError<C, Error>>;
        let source = &(*unerased)._error.error;
        (source.inner.vtable.object_is)(&source.inner, target)
    }
}
unsafe fn context_chain_downcast<C>(e: &ErrorImpl<()>, target: TypeId) -> Option<NonNull<()>>
where
    C: 'static,
{
    if TypeId::of::<C>() == target {
        let unerased = e as *const ErrorImpl<()> as *const ErrorImpl<ContextError<C, Error>>;
        let addr = &(*unerased)._error.context as *const C as *mut ();
        Some(NonNull::new_unchecked(addr))
    } else {
        let unerased = e as *const ErrorImpl<()> as *const ErrorImpl<ContextError<C, Error>>;
        let source = &(*unerased)._error.error;
        (source.inner.vtable.object_downcast)(&source.inner, target)
    }
}
unsafe fn context_chain_drop_rest<C>(e: Box<ErrorImpl<()>>, target: TypeId)
where
    C: 'static,
{
    // Called after downcasting by value to either the C or one of the causes
    // and doing a ptr::read to take ownership of that value.
    if TypeId::of::<C>() == target {
        let unerased = mem::transmute::<
            Box<ErrorImpl<()>>,
            Box<ErrorImpl<ContextError<ManuallyDrop<C>, Error>>>,

    } else {
        let unerased = mem::transmute::<
            Box<ErrorImpl<()>>,
            Box<ErrorImpl<ContextError<C, ManuallyDrop<Error>>>>,
        >(e);
        let inner = ptr::read(&unerased._error.error.inner);
        drop(unerased);
        let erased = ManuallyDrop::into_inner(inner);
        (erased.vtable.object_drop_rest)(erased, target);