let obj = mem::transmute::<&dyn StdError, TraitObject>(&error);

            let vtable = &ErrorVTable {
                source: source_raw::<E>,
                source_mut: source_mut_raw::<E>,
            };

                vtable: obj.vtable,

                vtable,

}
struct ErrorVTable {
    source: unsafe fn(*const ()) -> *const (dyn StdError + Send + Sync + 'static),
    source_mut: unsafe fn(*mut ()) -> *mut (dyn StdError + Send + Sync + 'static),
}
unsafe fn source_raw<E>(e: *const ()) -> *const (dyn StdError + Send + Sync + 'static)
where
    E: StdError + Send + Sync + 'static,
{
    e as *const E

unsafe fn source_mut_raw<E>(e: *mut ()) -> *mut (dyn StdError + Send + Sync + 'static)
where
    E: StdError + Send + Sync + 'static,
{
    e as *mut E
}

    vtable: *const (),

    vtable: &'static ErrorVTable,

// repr C to ensure that transmuting from trait objects is safe
#[repr(C)]
struct TraitObject {
    data: *const (),
    vtable: *const (),
}

        let object = TraitObject {
            data: &self.error,
            vtable: self.vtable,
        };
        unsafe { mem::transmute::<TraitObject, &(dyn StdError + Send + Sync + 'static)>(object) }

        unsafe { &*(self.vtable.source)(&self.error) }

        let object = TraitObject {
            data: &mut self.error,
            vtable: self.vtable,
        };
        unsafe {
            mem::transmute::<TraitObject, &mut (dyn StdError + Send + Sync + 'static)>(object)
        }

        unsafe { &mut *(self.vtable.source_mut)(&mut self.error) }