object_drop_front: object_drop_front::<E>,

            object_drop_rest: object_drop_front::<E>,

            object_drop_front: object_drop_front::<MessageError<M>>,

            object_drop_rest: object_drop_front::<M>,

            object_drop_front: object_drop_front::<DisplayError<M>>,

            object_drop_rest: object_drop_front::<M>,

            object_drop_front: object_drop_front::<ContextError<C, E>>,

            object_is: object_is::<ContextError<C, E>>,
            object_downcast: object_downcast::<ContextError<C, E>>,

            object_is: context_is::<C, E>,
            object_downcast: context_downcast::<C, E>,
            object_drop_rest: context_drop_rest::<C, E>,

            object_drop_front: object_drop_front::<ContextError<C, Error>>,

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

            (erased.vtable.object_drop_front)(erased);

            (erased.vtable.object_drop_rest)(erased, target);

    object_drop_front: unsafe fn(Box<ErrorImpl<()>>),

    object_drop_rest: unsafe fn(Box<ErrorImpl<()>>, TypeId),

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

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

    let _ = target;

}
unsafe fn context_is<C, E>(target: TypeId) -> bool
where
    C: 'static,
    E: 'static,
{
    TypeId::of::<C>() == target || TypeId::of::<E>() == target

// repr C to ensure that `E` remains in the final position

unsafe fn context_downcast<C, E>(e: &ErrorImpl<()>, target: TypeId) -> Option<NonNull<()>>
where
    C: 'static,
    E: 'static,
{
    if TypeId::of::<C>() == target {
        let unerased = e as *const ErrorImpl<()> as *const ErrorImpl<ContextError<C, E>>;
        let addr = &(*unerased)._error.context as *const C as *mut ();
        Some(NonNull::new_unchecked(addr))
    } else if TypeId::of::<E>() == target {
        let unerased = e as *const ErrorImpl<()> as *const ErrorImpl<ContextError<C, E>>;
        let addr = &(*unerased)._error.error as *const E as *mut ();
        Some(NonNull::new_unchecked(addr))
    } else {
        None
    }
}
unsafe fn context_drop_rest<C, E>(e: Box<ErrorImpl<()>>, target: TypeId)
where
    C: 'static,
    E: 'static,
{
    // Called after downcasting by value to either the C or the E 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>, E>>>,
        >(e);
        drop(unerased);
    } else {
        let unerased = mem::transmute::<
            Box<ErrorImpl<()>>,
            Box<ErrorImpl<ContextError<C, ManuallyDrop<E>>>>,
        >(e);
        drop(unerased);
    }
}
// repr C to ensure that E remains in the final position.

    // NOTE: Don't use directly. Use only through vtable. Erased type may have different alignment.

    // NOTE: Don't use directly. Use only through vtable. Erased type may have
    // different alignment.

// repr C to ensure that ContextError<C, E> has the same layout as
// ContextError<ManuallyDrop<C>, E> and ContextError<C, ManuallyDrop<E>>.
#[repr(C)]