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

        Error::construct(error, TypeId::of::<E>(), backtrace)

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

        Error::construct(MessageError(message), TypeId::of::<M>(), backtrace)

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

    fn construct<E>(error: E, type_id: TypeId, backtrace: Option<Backtrace>) -> Self

    //
    // 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 {
            let vtable = &ErrorVTable {
                object: object_raw::<E>,
                object_mut: object_mut_raw::<E>,
            };
            let inner = Box::new(ErrorImpl {
                vtable,
                type_id,
                backtrace,
                error,
            });
            Error {
                inner: mem::transmute::<Box<ErrorImpl<E>>, Box<ErrorImpl<()>>>(inner),
            }

        let vtable = &ErrorVTable {
            object: object_raw::<E>,
            object_mut: object_mut_raw::<E>,
        };
        let inner = Box::new(ErrorImpl {
            vtable,
            type_id,
            backtrace,
            error,
        });
        Error {
            inner: mem::transmute::<Box<ErrorImpl<E>>, Box<ErrorImpl<()>>>(inner),