//! This is adapted from the `erasable` crate, but actually allows one to pass an `?Sized` type that stores its length inline. For example types implementing the `SliceDst` trait.

use std::marker::PhantomData;

use std::ptr::NonNull;

/// A thin, type-erased pointer. This should mimic the interface of NonNull, but

/// with the ability to erase the type information.

pub struct Thin<T: ?Sized + Erasable> {

    ptr: ErasedPtr,

    marker: PhantomData<fn() -> T>,

}

// A `Thin` is just a type-erased pointer plus a `PhantomData`, so it is always

// `Copy`/`Clone` regardless of whether the pointee is.

impl<T: ?Sized + Erasable> Clone for Thin<T> {

}

impl<T: ?Sized + Erasable> Copy for Thin<T> {}

impl<T: ?Sized + Erasable> Thin<T> {

}

impl<T: ?Sized + Erasable> Thin<T> {

    /// # Safety

    ///

    /// The caller must ensure that the underlying pointer is valid for reads.

}

/// This is the trait that allows a type to be erased and unerased.

///

/// # Safety

///

/// See the documentation of the trait functions.

pub unsafe trait Erasable {

    /// Turn this erasable pointer into an erased pointer.

    ///

    /// To retrieve the original pointer, use `unerase`.

    ///

    /// # Safety

    ///

    /// The returned erased pointer must only be used with `unerase` for the same type.

    fn erase(this: NonNull<Self>) -> ErasedPtr;

    /// Unerase this erased pointer.

    ///

    /// # Safety

    ///

    /// The erased pointer must have been created by `erase`.

    unsafe fn unerase(this: ErasedPtr) -> NonNull<Self>;

}

unsafe impl<T: Sized> Erasable for T {

        // If the type is Sized, we can safely cast it to a pointer.

        // If the type is Sized, we can safely cast it back to a pointer.

}

/// A stand-in for an opaque pointee with size one and alignment one (a single

/// `u8`). Can be replaced by an `extern type` when that is stabilized.

pub struct Erased(#[allow(unused)] u8);

/// Static assertion to ensure that `ErasedPtr` is the same size as a `usize`.

const _: () = assert!(std::mem::size_of::<ErasedPtr>() == std::mem::size_of::<usize>());

/// A thin, type-erased pointer.

///

/// The `Erased` type is private, and should be treated as an opaque type.

/// When `extern type` is stabilized, `Erased` will be defined as one.

///

/// The current implementation uses a `struct Erased` of size 1 and align 1.

/// If you want to offset the pointer, make sure to cast to a `u8` or other known type pointer first.

/// When `Erased` becomes an extern type, it will properly have unknown size and align.

pub type ErasedPtr = NonNull<Erased>;