dungeon_cell/core/inner/

cleanup.rs

//! Trait for cleanup of a [`Inner`].

use crate::align::Aligned;
use crate::bound::{traits, Bound};
use crate::buffer::Buffer;
use crate::compile_time::const_transmute;
use crate::marker_traits::{IsBound, IsLayout};
use crate::vtable::VTable;

use super::Inner;

/// Trait implemented on layouts that can be cleaned up be a vtable.
///
/// The trait bound `L: Cleanup<V>` signifies that the vtable `V` can cleanup a value
/// with layout `L`.
///
/// This trait is implemented for all `V: VTable` and [`Layout`][crate::layout::Layout].
///
/// The associated type [`Self::Storage`] will be cleaned up automatically when dropped.
/// This type is based on the vtable and the layout.
///
/// For dynamic bounds on the vtable that indicate the value is `Copy` then the associated type
/// will perform no cleanup operation. For all other cases the type will run the
/// drop impl from the vtable.
///
/// This trait is [sealed](https://rust-lang.github.io/api-guidelines/future-proofing.html#sealed-traits-protect-against-downstream-implementations-c-sealed)
/// and cannot be implemented by external types.
///
/// # Safety
/// [`Self::Storage`] must only be `InnerNoDrop` or `InnerDrop`.
pub unsafe trait Cleanup<V>: IsLayout {
    /// Storage for [`DungeonCore`][super::super::DungeonCore].
    type Storage;
}

// SAFETY: CleanupHelper follows the requirements of Cleanup.
unsafe impl<V: VTable, L: IsLayout> Cleanup<V> for L
where
    L: CleanupHelper<V, V::Bounds>,
{
    type Storage = <L as CleanupHelper<V, V::Bounds>>::Inner;
}

pub trait CleanupHelper<V, B> {
    type Inner;
}

// /// Inner storage bounded by dynamic bound.
// ///
// /// This is the same as a [`Inner`] but with a stored dynamic trait bound.
// /// This type doesn't force the data stored in `inner` to be actually bounded
// /// by this dynamic trait bound.
// ///
// /// This type will implement/not implement [`Send`], [`Sync`], and [`Unpin`] if
// /// the dynamic bound implies the value in `inner` does.
// #[repr(transparent)]
// struct BoundedInner<L: IsLayout, B: DynamicBound, V> {
//     /// The aligned buffer and vtable.
//     inner: Inner<L, V>,
//
//     /// Marker to cause the auto impl of `Send` to be enabled/disabled.
//     _bound_marker: PhantomData<B::Marker>,
// }
//
// impl<L: IsLayout, B: DynamicBound, V: Copy> Copy for BoundedInner<L, B, V> {}
// impl<L: IsLayout, B: DynamicBound, V: Clone> Clone for BoundedInner<L, B, V> {
//     fn clone(&self) -> Self {
//         Self {
//             inner: self.inner.clone(),
//             _bound_marker: PhantomData,
//         }
//     }
// }

/// Inner storage that may be [`Copy`] and without a [`Drop`].
#[repr(transparent)]
pub struct InnerNoDrop<L: IsLayout, V> {
    /// Dynamically bounded storage.
    bounded: Inner<L, V>,
}

impl<L: IsLayout, V: Copy> Copy for InnerNoDrop<L, V> {}
impl<L: IsLayout, V: Clone> Clone for InnerNoDrop<L, V> {
    fn clone(&self) -> Self {
        Self {
            bounded: self.bounded.clone(),
        }
    }
}

/// Inner storage with a [`Drop`].
#[repr(transparent)]
pub struct InnerDrop<L: IsLayout, V: VTable> {
    /// Dynamically bounded storage.
    bounded: Inner<L, V>,
}

impl<L: IsLayout, V: VTable + Clone> Clone for InnerDrop<L, V>
where
    <V::Bounds as IsBound>::CloneMarker: Clone,
{
    fn clone(&self) -> Self {
        // SAFETY: The vtable isn't changed.
        let (buffer, vtable) = unsafe { self.bounded.parts() };

        let mut temp_buffer = Aligned::<_, L::Alignment>::new(Buffer::uninit());

        // SAFETY: We bounded on the CloneMarker implementing Clone.
        // And the buffer has a value for the vtable by the inveriants of Inner.
        // The temp_buffer is aligned properly by Aligned.
        unsafe {
            vtable
                .bound_impl()
                .clone_value(buffer.as_ptr(), temp_buffer.as_mut_ptr())
        };

        Self {
            // SAFETY: the vtable is for the buffer because it was before.
            bounded: unsafe {
                Inner::new(temp_buffer.value, self.bounded.vtable().clone())
            },
        }
    }
}

impl<L: IsLayout, V: VTable> Drop for InnerDrop<L, V> {
    fn drop(&mut self) {
        // SAFETY: We will drop the value in the buffer and then nothing else will be able
        // to access the `Inner`.
        let (buffer, vtable) = unsafe { self.bounded.parts_mut() };

        // SAFETY: Because of the requirement on `Inner` we know that `buffer` must contain a valid value
        // of the type the vtable represents.
        unsafe { vtable.bound_impl().drop_value(buffer.as_mut_ptr()) }
    }
}

/// Get the [`Inner<L, V>`] that the associated type contains.
pub const fn as_inner<L: IsLayout + Cleanup<V>, V>(
    inner: &<L as Cleanup<V>>::Storage,
) -> &Inner<L, V> {
    // SAFETY: Cleanup is only implemented for 2 Inner types: `InnerNoDrop` and `InnerDrop`.
    // Both of these are transparent repr to `BoundedInner<L, B, V>` which is transparent repr to
    // `Inner<L, V>`. As such, `<V as Cleanup<L, B>>::Inner` and `Inner<L, V>` have the same layout
    // and can be transmuted between.
    unsafe {
        &*(inner as *const <L as Cleanup<V>>::Storage as *const Inner<L, V>)
    }
}

/// Get the [`Inner<L, V>`] that the associated type contains mutably.
pub fn as_inner_mut<L: IsLayout + Cleanup<V>, V>(
    inner: &mut <L as Cleanup<V>>::Storage,
) -> &mut Inner<L, V> {
    // SAFETY: Cleanup is only implemented for 2 Inner types: `InnerNoDrop` and `InnerDrop`.
    // Both of these are transparent repr to `BoundedInner<L, B, V>` which is transparent repr to
    // `Inner<L, V>`. As such, `<V as Cleanup<L, B>>::Inner` and `Inner<L, V>` have the same layout
    // and can be transmuted between.
    unsafe {
        &mut *(inner as *mut <L as Cleanup<V>>::Storage as *mut Inner<L, V>)
    }
}

/// Convert the associated type into the [`Inner<L, V>`] it contains.
pub const fn into_inner<L: IsLayout + Cleanup<V>, V>(
    inner: <L as Cleanup<V>>::Storage,
) -> Inner<L, V> {
    // SAFETY: Cleanup is only implemented for 2 Inner types: `InnerNoDrop` and `InnerDrop`.
    // Both of these are transparent repr to `BoundedInner<L, B, V>` which is transparent repr to
    // `Inner<L, V>`. As such, `<V as Cleanup<L, B>>::Inner` and `Inner<L, V>` have the same layout
    // and can be transmuted between.
    unsafe { const_transmute(inner) }
}

/// Convert a [`Inner<L, V>`] to the associated type.
pub const fn from_inner<L: IsLayout + Cleanup<V>, V>(
    inner: Inner<L, V>,
) -> <L as Cleanup<V>>::Storage {
    // SAFETY: Cleanup is only implemented for 2 Inner types: `InnerNoDrop` and `InnerDrop`.
    // Both of these are transparent repr to `BoundedInner<L, B, V>` which is transparent repr to
    // `Inner<L, V>`. As such, `<V as Cleanup<L, B>>::Inner` and `Inner<L, V>` have the same layout
    // and can be transmuted between.
    unsafe { const_transmute(inner) }
}

// Make the associated type for a dynamic bound with `Copy` the `InnerNoDrop` storage.
//
// SAFETY: This gives out `InnerNoDrop`, but it makes sure the bound has `Copy`.
// Other code must bound any value it stores in the buffer by the bound given.
impl<L: IsLayout, V: VTable, Send, Sync, Clone, Unpin, Debug>
    CleanupHelper<V, Bound<Send, Sync, traits::Copy, Clone, Unpin, Debug>> for L
where
    V: VTable<Bounds = Bound<Send, Sync, traits::Copy, Clone, Unpin, Debug>>,
{
    /// The inner storage will not run `Drop` code and can be `Copy` if the vtable is.
    type Inner = InnerNoDrop<L, V>;
}

// Make the associated type for a dynamic bound without `Copy` the `InnerDrop` storage.
// This storage will drop the value using the vtable.
//
// SAFETY: This gives out `InnerDrop` which has no special rules.
// Because `InnerDrop` doesn't expose the `Inner` impl of `Copy` we don't
// have to worry about aliasing the drop unless other code breaks a safety rule.
impl<L: IsLayout, V: VTable, Send, Sync, Clone, Unpin, Debug>
    CleanupHelper<V, Bound<Send, Sync, traits::__, Clone, Unpin, Debug>> for L
where
    V: VTable<Bounds = Bound<Send, Sync, traits::__, Clone, Unpin, Debug>>,
{
    /// The inner stoage will run `Drop` code from the vtable.
    type Inner = InnerDrop<L, V>;
}

#[cfg(test)]
mod test {
    use crate::bound::bounds;
    use crate::buffer::Buffer;
    use crate::layout::{self, Alignment, Size};
    use crate::vtable::{StaticVTable, VTableOf};

    use super::*;

    #[test]
    fn inner_with_bound_without_copy_does_drop_stored_value() {
        use std::sync::atomic::{AtomicBool, Ordering};

        static FLAG: AtomicBool = AtomicBool::new(false);

        struct MyType {
            value: i32,
        }

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

                FLAG.store(true, Ordering::Relaxed);
            }
        }

        type Bound = bounds::Empty;
        type Layout = layout::Layout<Size<4>, Alignment<4>>;

        let value = MyType { value: 123 };

        let buffer = Buffer::new(value);

        // SAFETY: The vtable is for the value in the buffer.
        let inner = unsafe {
            Inner::<Layout, _>::new(
                buffer,
                <&'static StaticVTable<Bound> as VTableOf<MyType>>::instance(),
            )
        };

        let stored = from_inner::<_, _>(inner);

        // The drop hasn't happened yet.
        assert!(!FLAG.load(Ordering::Relaxed));

        drop(stored);

        // Now the drop has happened because we dropped `stored`.
        assert!(FLAG.load(Ordering::Relaxed));
    }

    #[test]
    fn inner_with_bound_with_copy_implements_copy() {
        #[derive(Clone, Copy, PartialEq, Debug)]
        struct MyType {
            value: i32,
        }

        type VTable = &'static StaticVTable<Bound>;
        type Bound = bounds::Copy;
        type Layout = layout::Layout<Size<4>, Alignment<4>>;

        let value = MyType { value: 123 };

        let buffer = Buffer::new(value);

        // SAFETY: The vtable is for the value in the buffer.
        let inner = unsafe {
            Inner::<Layout, _>::new(
                buffer,
                <VTable as VTableOf<MyType>>::instance(),
            )
        };

        let stored = from_inner::<_, _>(inner);

        // We implicitly invoke Copy here.
        let stored_copy = stored;

        let inner_original = into_inner::<Layout, VTable>(stored);
        let inner_copy = into_inner::<Layout, VTable>(stored_copy);

        // SAFETY: We know the type in the buffer is `MyType`.
        let original: MyType =
            unsafe { Buffer::into_value(inner_original.into_parts().0) };

        // SAFETY: We know the type in the buffer is `MyType`.
        let copy: MyType =
            unsafe { Buffer::into_value(inner_copy.into_parts().0) };

        assert_eq!(copy, original);
    }
}