let type_id = TypeId::of::<E>();

        let vtable = &ErrorVTable {
            object_drop: object_drop::<E>,
            object_drop_front: object_drop_front::<E>,
            object_ref: object_ref::<E>,
            object_mut: object_mut::<E>,
            object_boxed: object_boxed::<E>,
            object_is: object_is::<E>,
        };

        // Safety: passing typeid of the right type E.
        unsafe { Error::construct(error, type_id, backtrace) }

        // Safety: passing vtable that operates on the right type E.
        unsafe { Error::construct(error, vtable, backtrace) }

        let type_id = TypeId::of::<M>();

        let vtable = &ErrorVTable {
            object_drop: object_drop::<MessageError<M>>,
            object_drop_front: object_drop_front::<MessageError<M>>,
            object_ref: object_ref::<MessageError<M>>,
            object_mut: object_mut::<MessageError<M>>,
            object_boxed: object_boxed::<MessageError<M>>,
            object_is: object_is::<M>,
        };

        // Safety: MessageError is repr(transparent) so MessageError<M> has the
        // same layout as the typeid specifies.
        unsafe { Error::construct(error, type_id, backtrace) }

        // Safety: MessageError is repr(transparent) so it is okay for the
        // vtable to allow casting the MessageError<M> to M.
        unsafe { Error::construct(error, vtable, backtrace) }

        let type_id = TypeId::of::<M>();

        let vtable = &ErrorVTable {
            object_drop: object_drop::<DisplayError<M>>,
            object_drop_front: object_drop_front::<DisplayError<M>>,
            object_ref: object_ref::<DisplayError<M>>,
            object_mut: object_mut::<DisplayError<M>>,
            object_boxed: object_boxed::<DisplayError<M>>,
            object_is: object_is::<M>,
        };

        // Safety: DisplayError is repr(transparent) so DisplayError<M> has the
        // same layout as the typeid specifies.
        unsafe { Error::construct(error, type_id, backtrace) }

        // Safety: DisplayError is repr(transparent) so it is okay for the
        // vtable to allow casting the DisplayError<M> to M.
        unsafe { Error::construct(error, vtable, backtrace) }

    // Unsafe because the type represented by type_id must have the same layout
    // as E or else we allow invalid downcasts.
    unsafe fn construct<E>(error: E, type_id: TypeId, backtrace: Option<Backtrace>) -> Self

    // Unsafe because the given vtable must have sensible behavior on the error
    // value of type E.
    unsafe fn construct<E>(
        error: E,
        vtable: &'static ErrorVTable,
        backtrace: Option<Backtrace>,
    ) -> Self

        let vtable = &ErrorVTable {
            object_drop: object_drop::<E>,
            object_drop_front: object_drop_front::<E>,
            object_ref: object_ref::<E>,
            object_mut: object_mut::<E>,
            object_boxed: object_boxed::<E>,
        };

            type_id,

        TypeId::of::<E>() == self.inner.type_id

        let target = TypeId::of::<E>();
        unsafe { (self.inner.vtable.object_is)(target) }

    object_is: unsafe fn(TypeId) -> bool,

unsafe fn object_is<T>(target: TypeId) -> bool
where
    T: 'static,
{
    TypeId::of::<T>() == target
}

    type_id: TypeId,