// Erase the concrete type of E from the compile-time type system. This
        // is equivalent to the safe unsize coersion from Box<ErrorImpl<E>> to
        // Box<ErrorImpl<dyn StdError + Send + Sync + 'static>> except that the
        // result is a thin pointer. The necessary behavior for manipulating the
        // underlying ErrorImpl<E> is preserved in the vtable provided by the
        // caller rather than a builtin fat pointer vtable.

            // Use vtable to find NonNull<()> which points to a value of type E
            // somewhere inside the data structure.

            // Prepare to read E out of the data structure. We'll drop the rest
            // of the data structure separately so that E is not dropped.

            // Read E from where the vtable found it.

            // Read Box<ErrorImpl<()>> from self. Can't move it out because
            // Error has a Drop impl which we want to not run.

            // Drop rest of the data structure outside of E.

            // Use vtable to find NonNull<()> which points to a value of type E
            // somewhere inside the data structure.

            // Use vtable to find NonNull<()> which points to a value of type E
            // somewhere inside the data structure.

            // Read Box<ErrorImpl<()>> from self.

            // Invoke the vtable's drop behavior.

// Safety: requires layout of *e to match ErrorImpl<E>.

// Safety: requires layout of *e to match ErrorImpl<E>.

// Safety: requires layout of *e to match ErrorImpl<E>.

    // Attach E's native StdError vtable onto a pointer to self._object.

// Safety: requires layout of *e to match ErrorImpl<E>.

    // Attach E's native StdError vtable onto a pointer to self._object.

// Safety: requires layout of *e to match ErrorImpl<E>.

    // Attach ErrorImpl<E>'s native StdError vtable. The StdError impl is below.

// Safety: requires layout of *e to match ErrorImpl<E>.

        // Caller is looking for an E pointer and e is ErrorImpl<E>, take a
        // pointer to its E field.

// Safety: requires layout of *e to match ErrorImpl<ContextError<C, E>>.

// Safety: requires layout of *e to match ErrorImpl<ContextError<C, E>>.

// Safety: requires layout of *e to match ErrorImpl<ContextError<C, Error>>.

        // Recurse down the context chain per the inner error's vtable.

// Safety: requires layout of *e to match ErrorImpl<ContextError<C, Error>>.

        // Drop the entire rest of the data structure rooted in the next Error.

        // Read out a ManuallyDrop<Box<ErrorImpl<()>>> from the next error.

        // Recursively drop the next error using the same target typeid.

        // Erase the concrete type of E but preserve the vtable in self.vtable
        // for manipulating the resulting thin pointer. This is analogous to an
        // unsize coersion.

        // Use vtable to attach E's native StdError vtable for the right
        // original type E.

        // Use vtable to attach E's native StdError vtable for the right
        // original type E.

            // Read Box<ErrorImpl<()>> from error. Can't move it out because
            // Error has a Drop impl which we want to not run.

            // Use vtable to attach ErrorImpl<E>'s native StdError vtable for
            // the right original type E.