dungeon_cell/vtable/

lifetime_vtable.rs

use core::fmt;

use crate::bound::{Dynamic, Subset};
use crate::lifetime_type_id::{LifetimeTypeId, StaticForm};
use crate::marker_traits::IsBound;

use super::{
    BoundsImpl, ConstVTableOf, Descriptor, Inspect, VTable, VTableOf,
    VTableSubset,
};

/// Implementation of [`VTable`] for types with zero or one lifetime.
///
/// This vtable is powered by the [`lifetime_type_id`][crate::lifetime_type_id] module.
///
/// # Examples
///
/// ```
/// use dungeon_cell::vtable::{LifetimeVTable, VTableOf, VTable};
/// use dungeon_cell::bound::bounds;
///
/// // get for i32
/// let vtable = LifetimeVTable::<'static, bounds::Normal>::new::<i32>();
///
/// assert_eq!(vtable.descriptor().type_name(), "i32");
/// assert_eq!(vtable.descriptor().size(), 4);
/// assert_eq!(vtable.descriptor().alignment(), 4);
///
/// // get vtable for f64
/// let vtable = <&'static LifetimeVTable<'static, bounds::Normal> as VTableOf<f64>>::instance();
///
/// assert_eq!(vtable.descriptor().type_name(), "f64");
/// assert_eq!(vtable.descriptor().size(), 8);
/// assert_eq!(vtable.descriptor().alignment(), 8);
/// ```
#[derive(Clone)]
#[repr(C)]
pub struct LifetimeVTable<'a, B> {
    bounds_impl: BoundsImpl<B>,
    descriptor: Descriptor<Lifetime<'a>>,
}

impl<'a, B> fmt::Debug for LifetimeVTable<'a, B> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_struct("LifetimeVTable")
            .field("type_name", &self.descriptor.type_name())
            .field("size", &self.descriptor.size)
            .field("alignment", &self.descriptor.alignment)
            .finish()
    }
}

impl<'a, B: IsBound> LifetimeVTable<'a, B> {
    /// Return the const instance of the vtable for `T`.
    ///
    /// `T` needs to implement [`StaticForm`].
    pub const fn new<T>() -> Self
    where
        T: Dynamic<B> + StaticForm<'a>,
    {
        <Self as ConstVTableOf<T>>::INSTANCE
    }
}

/// Single lifetime type ID.
///
/// Available for all types implementing [`StaticForm`].
///
/// # Examples
/// ```
/// use dungeon_cell::vtable::{Lifetime, Inspect};
///
/// assert_ne!(
///     <i32 as Inspect<Lifetime<'static>>>::inspect(),
///     <f32 as Inspect<Lifetime<'static>>>::inspect()
/// );
/// ```
#[derive(Copy, Clone, PartialEq, PartialOrd, Eq, Ord, Hash, Debug)]
pub struct Lifetime<'a>(LifetimeTypeId<'a>);

// SAFETY: LifetimeTypeId is well behaved (see the lifetime_type_id module)
// and we always return the one for T.
unsafe impl<'a, T: StaticForm<'a>> Inspect<Lifetime<'a>> for T {
    fn inspect() -> Lifetime<'a> {
        Lifetime(LifetimeTypeId::of::<T>())
    }
}

// SAFETY:
// The descriptor and bounds impl are always in sync.
// The Static Id type is well behaved because its built on LifetimeTypeId.
unsafe impl<'a, B: IsBound> VTable for LifetimeVTable<'a, B> {
    type Bounds = B;

    type Id = Lifetime<'a>;

    fn descriptor(&self) -> &super::Descriptor<Self::Id> {
        &self.descriptor
    }

    fn bound_impl(&self) -> &super::BoundsImpl<Self::Bounds> {
        &self.bounds_impl
    }
}

// SAFETY: The type we describe doesnt change.
unsafe impl<'a, B: IsBound, Bnew: IsBound> VTableSubset<Bnew> for LifetimeVTable<'a, B>
where
    Bnew: Subset<B>,
{
    type Subset = LifetimeVTable<'a, Bnew>;

    fn into_subset(self) -> Self::Subset {
        LifetimeVTable {
            bounds_impl: self.bounds_impl.into_subset::<Bnew>(),
            descriptor: self.descriptor,
        }
    }
}

// SAFETY: The type we describe doesnt change.
unsafe impl<'a, 'b, B: IsBound, Bnew: IsBound> VTableSubset<Bnew>
    for &'a LifetimeVTable<'b, B>
where
    Bnew: Subset<B>,
{
    type Subset = &'a LifetimeVTable<'b, Bnew>;

    fn into_subset(self) -> Self::Subset {
        // SAFETY: LifetimeVTable is repr(C) and BoundsImpl says its safe to transmute it
        // if we follow the Subset rule which we do.
        // Descriptor doesnt need to be repr(C) because it has the same type.
        unsafe {
            &*(self as *const LifetimeVTable<'b, B>
                as *const LifetimeVTable<'b, Bnew>)
        }
    }
}

// SAFETY: The returned vtable is for type T and the function doesn't ever panic.
unsafe impl<'a, T, B: IsBound> VTableOf<T> for LifetimeVTable<'a, B>
where
    T: Dynamic<B> + StaticForm<'a>,
{
    fn instance() -> Self {
        Self::new::<T>()
    }
}

// SAFETY: The type we describe doesnt change.
unsafe impl<'a, T, B: IsBound> ConstVTableOf<T> for LifetimeVTable<'a, B>
where
    T: Dynamic<B> + StaticForm<'a>,
{
    const INSTANCE: Self = Self {
        bounds_impl: BoundsImpl::new::<T>(),
        descriptor: Descriptor::new::<T>(),
    };
}

// SAFETY: The returned vtable is for type T and the function doesn't ever panic.
unsafe impl<'a, 'b, T, B: IsBound> VTableOf<T> for &'b LifetimeVTable<'a, B>
where
    T: Dynamic<B> + StaticForm<'a>,
{
    fn instance() -> Self {
        &ConstVTableOf::<T>::INSTANCE
    }
}

// SAFETY: The type we describe doesnt change.
unsafe impl<'a, 'b, T, B: IsBound> ConstVTableOf<T>
    for &'b LifetimeVTable<'a, B>
where
    T: Dynamic<B> + StaticForm<'a>,
{
    const INSTANCE: Self = &ConstVTableOf::<T>::INSTANCE;
}

#[cfg(test)]
mod test {
    use core::sync::atomic::AtomicBool;

    use crate::bound::bounds;

    use super::*;

    #[test]
    fn has_debug() {
        let _ = format!("{:?}", LifetimeVTable::<bounds::Normal>::new::<i32>());
    }

    #[test]
    fn can_drop_a_t() {
        static Y: AtomicBool = AtomicBool::new(false);

        struct X {
            a: i32,
        }

        impl Drop for X {
            fn drop(&mut self) {
                assert_eq!(self.a, 123);

                Y.store(true, core::sync::atomic::Ordering::Relaxed);
            }
        }

        // let v = LifetimeVTable::new::<X, bounds::Empty>();
        //
        // let mut x = MaybeUninit::new(X { a: 123 });
        //
        // unsafe { v.drop_in_place(x.as_mut_ptr() as _) };
        //
        // assert!(Y.load(core::sync::atomic::Ordering::Relaxed));
    }

    #[test]
    fn vtable_interface() {
        fn assert_for<T: 'static>() {
            // let v = LifetimeVTable::new::<T, bounds::Empty>();
            //
            // assert_eq!(v.size(), core::mem::size_of::<T>());
            // assert_eq!(v.alignment(), core::mem::align_of::<T>());
            // assert_eq!(v.is_type::<T>());
            // let _ = v.type_name();

            // let _ = <LifetimeVTable as VTableOf<T, bounds::Empty>>::instance();
            // let _ = <&LifetimeVTable as VTableOf<T, bounds::Empty>>::instance();
            //
            // let _ = <LifetimeVTable as ConstVTableOf<T, bounds::Empty>>::INSTANCE;
            // let _ = <&LifetimeVTable as ConstVTableOf<T, bounds::Empty>>::INSTANCE;
        }

        assert_for::<i32>();
        assert_for::<String>();
        assert_for::<()>();
        assert_for::<u8>();
        assert_for::<[i32; 100]>();
    }
}