Diffstat (limited to 'src/any.rs')
| -rw-r--r-- | src/any.rs | 290 |
1 files changed, 230 insertions, 60 deletions
@@ -1,19 +1,85 @@ -//! Heapless type erasure. -//! -//! [`Any`] is generic over the type of indirection (`&T`, `&mut T`, `Box<T>`) -//! and allows erasing the `T` of the indirection. This is similar to replacing the `T` with -//! [`core::any::Any`]. The main difference to [`core::any::Any`] is +use core::{ + marker::{PhantomData, PhantomPinned}, + mem::{ManuallyDrop, MaybeUninit}, +}; -use core::marker::PhantomData; +pub trait TypeNameable<'a, 'lt>: 'a { + type Name: ?Sized + TypeName<'a, 'lt, Nameable = Self>; +} + +pub trait TypeName<'a, 'lt>: 'static { + type Nameable: ?Sized + TypeNameable<'a, 'lt, Name = Self>; +} + +#[doc(hidden)] +#[macro_export] +macro_rules! nameable { + { + $vis:vis [$a:lifetime, $lt:lifetime $(, $($generic:ident)*)?] + + $type:ty + where {$($bound:tt)*} + } => { + $crate::any::nameable! { + $vis [$a, $lt $(, $($generic)*)?] + + $type + where {$($bound)*} -pub trait TypeNameable<'lt> { - type Name: TypeName<'lt, Nameable = Self>; + $type + where {$($bound)*} + } + }; + { + $vis:vis [$a:lifetime, $lt:lifetime $(, $($generic:ident)*)?] + + $type:ty + where {$($bound:tt)*} + + $type2:ty + where {$($bound2:tt)*} + } => { + const _: () = { + impl<$a, $lt $(, $($generic: $crate::any::TypeNameable<$a, $lt>)*)?> + $crate::any::TypeNameable<$a, $lt> for $type + where + $($bound)* + { + type Name = Name$(<$($generic::Name),*>)?; + } + + $vis struct Name$(< $($generic: ?Sized),* >)?( + ::core::marker::PhantomData<fn() -> ($( $(*const $generic,)* )?)> + ); + + impl<$a, $lt $(, $($generic: $crate::any::TypeName<$a, $lt>)*)?> + $crate::any::TypeName<$a, $lt> for Name$(<$($generic),*>)? + where + $($bound2)* + { + type Nameable = $type2; + } + }; + }; } +#[doc(inline)] +pub use nameable; -pub trait TypeName<'lt>: 'static { - type Nameable: ?Sized + TypeNameable<'lt, Name = Self>; +pub struct Owned<T: ?Sized>(pub T); +nameable! { + pub ['a, 'lt, T] + Owned<T> where {T: ?Sized} + Owned<T::Nameable> where {T: ?Sized} } +// pub struct Borrowed<'lt, T: ?Sized>(pub &'lt T); +// nameable!(['a, 'lt: 'a, T: ?Sized + 'static]: Borrowed<'lt, T> => Borrowed<'static, T>); +// +// pub struct MutBorrowed<'lt, T: ?Sized>(pub &'lt mut T); +// nameable!(['a, 'lt: 'a, T: ?Sized + 'static]: MutBorrowed<'lt, T> => MutBorrowed<'static, T>); + +// box here + #[derive(PartialEq, Eq, PartialOrd, Ord, Hash, Copy, Clone, Debug)] pub struct LtTypeId<'lt> { _marker: PhantomData<fn(&'lt ()) -> &'lt ()>, @@ -21,7 +87,7 @@ pub struct LtTypeId<'lt> { } impl<'lt> LtTypeId<'lt> { - pub fn of<T: ?Sized + TypeNameable<'lt>>() -> Self { + pub fn of<'a, T: ?Sized + TypeNameable<'a, 'lt>>() -> Self { LtTypeId { _marker: PhantomData, name_id: core::any::TypeId::of::<T::Name>(), @@ -33,18 +99,18 @@ pub unsafe trait LtAny<'lt> { fn type_id(&self) -> LtTypeId<'lt>; } -unsafe impl<'lt, T: ?Sized + TypeNameable<'lt>> LtAny<'lt> for T { +unsafe impl<'a, 'lt, T: ?Sized + TypeNameable<'a, 'lt>> LtAny<'lt> for T { fn type_id(&self) -> LtTypeId<'lt> { LtTypeId::of::<T>() } } impl<'a, 'lt> dyn LtAny<'lt> + 'a { - pub fn is<T: ?Sized + TypeNameable<'lt>>(&self) -> bool { + pub fn is<T: ?Sized + TypeNameable<'a, 'lt>>(&self) -> bool { LtTypeId::of::<T>() == self.type_id() } - - pub fn downcast_ref<T: ?Sized + TypeNameable<'lt>>(&self) -> Option<&T> { + + pub fn downcast_ref<T: TypeNameable<'a, 'lt>>(&self) -> Option<&T> { if self.is::<T>() { Some(unsafe { &*(self as *const dyn LtAny<'lt> as *const T) }) } else { @@ -52,7 +118,7 @@ impl<'a, 'lt> dyn LtAny<'lt> + 'a { } } - pub fn downcast_mut<T: ?Sized + TypeNameable<'lt>>(&mut self) -> Option<&mut T> { + pub fn downcast_mut<T: TypeNameable<'a, 'lt>>(&mut self) -> Option<&mut T> { if self.is::<T>() { Some(unsafe { &mut *(self as *mut dyn LtAny<'lt> as *mut T) }) } else { @@ -61,7 +127,7 @@ impl<'a, 'lt> dyn LtAny<'lt> + 'a { } #[cfg(feature = "alloc")] - pub fn downcast_box<T: TypeNameable<'lt>>(self: Box<Self>) -> Result<Box<T>, Box<Self>> { + pub fn downcast_box<T: TypeNameable<'a, 'lt>>(self: Box<Self>) -> Result<Box<T>, Box<Self>> { if self.is::<T>() { Ok(unsafe { let raw: *mut dyn LtAny<'lt> = Box::into_raw(self); @@ -73,73 +139,177 @@ impl<'a, 'lt> dyn LtAny<'lt> + 'a { } } -#[doc(hidden)] -#[macro_export] -macro_rules! nameable { - {$lt:lifetime: $type:ty => $name:ty} => { - impl<$lt> $crate::any::TypeNameable<$lt> for $type { - type Name = $name; +#[must_use] +pub struct IndirectLtAny<'a, 'lt: 'a, I: Indirect<'a>> { + info: fn() -> (LtTypeId<'lt>, unsafe fn(RawIndirect)), + indirect: RawIndirect, + _marker: PhantomData<(I::ForT<fn(&'lt ()) -> &'lt ()>, PhantomPinned)>, +} + +impl<'a, 'lt, I: Indirect<'a>> Drop for IndirectLtAny<'a, 'lt, I> { + fn drop(&mut self) { + // We need to drop the stored value. + + // Lookup drop function. + let (_, drop_fn) = (self.info)(); + + // SAFETY: self.indirect is never touched again. + // Additionally, we know that drop_fn is for this self.indirect because it was + // made by Self::new. + unsafe { drop_fn(self.indirect) }; + } +} + +impl<'a, 'lt, I: Indirect<'a>> IndirectLtAny<'a, 'lt, I> { + /// Wrap an indirection. + /// + /// The inner type `T` of the indirection is erased. + pub fn new<T: ?Sized + TypeNameable<'a, 'lt>>(indirect: I::ForT<T>) -> Self { + Self { + info: || { + (LtTypeId::of::<T>(), |raw| { + // SAFETY: This is only called in the drop impl. + unsafe { drop(I::from_raw::<T>(raw)) } + }) + }, + indirect: I::into_raw(indirect), + _marker: PhantomData, } + } + + /// Downcast to an indirection with a given `T` type. + /// + /// If the type of the stored value is different, then `self` is + /// returned as is. + pub fn downcast<T: ?Sized + TypeNameable<'a, 'lt>>(self) -> Result<I::ForT<T>, Self> { + let (id, _) = (self.info)(); - impl<$lt> TypeName<$lt> for $name { - type Nameable = $type; + if id == LtTypeId::of::<T>() { + Ok(unsafe { I::from_raw::<T>(self.indirect) }) + } else { + Err(self) } } + + /// Type ID of the stored value's `T`. + pub fn id(&self) -> LtTypeId<'lt> { + (self.info)().0 + } } -#[doc(inline)] -pub use nameable; -#[cfg(test)] -mod test { - use super::*; +pub unsafe trait Indirect<'a> { + type ForT<T: ?Sized + 'a>: 'a; - #[derive(Debug, PartialEq)] - struct X<'a>(&'a mut i32); + fn into_raw<T: ?Sized + 'a>(value: Self::ForT<T>) -> RawIndirect; + + unsafe fn from_raw<T: ?Sized + 'a>(any: RawIndirect) -> Self::ForT<T>; +} - nameable!('a: X<'a> => X<'static>); +#[derive(Clone, Copy)] +#[repr(transparent)] +pub struct RawIndirect(MaybeUninit<[u8; INDIRECT_SIZE]>); - #[test] - fn any() { - let mut x = 42; - let x = X(&mut x); +const INDIRECT_SIZE: usize = core::mem::size_of::<usize>() * 2; - let any: &dyn LtAny = &x; +trait Helper {} - let y = any.downcast_ref().unwrap(); +pub enum Ref {} - assert_eq!(x, *y); +const _: () = assert!(core::mem::size_of::<&dyn Helper>() <= core::mem::size_of::<RawIndirect>()); + +unsafe impl<'a> Indirect<'a> for Ref { + type ForT<T: ?Sized + 'a> = &'a T; + + fn into_raw<T: ?Sized + 'a>(value: Self::ForT<T>) -> RawIndirect { + unsafe { transmute::<&'a T, RawIndirect>(value) } } - #[test] - #[cfg(feature = "alloc")] - fn any_box() { - let mut x = 42; - let x = X(&mut x); + unsafe fn from_raw<T: ?Sized + 'a>(any: RawIndirect) -> Self::ForT<T> { + unsafe { transmute::<RawIndirect, &'a T>(any) } + } +} - let any: Box<dyn LtAny> = Box::new(x); +pub enum Mut {} - let Ok(y) = any.downcast_box::<X>() else { panic!() }; +const _: () = + assert!(core::mem::size_of::<&mut dyn Helper>() <= core::mem::size_of::<RawIndirect>()); - assert_eq!(*y.0, 42); +unsafe impl<'a> Indirect<'a> for Mut { + type ForT<T: ?Sized + 'a> = &'a mut T; + + fn into_raw<T: ?Sized + 'a>(value: Self::ForT<T>) -> RawIndirect { + unsafe { transmute::<&'a mut T, RawIndirect>(value) } + } + + unsafe fn from_raw<T: ?Sized + 'a>(any: RawIndirect) -> Self::ForT<T> { + unsafe { transmute::<RawIndirect, &'a mut T>(any) } } +} - #[test] - fn equal() { - let mut x = 42; - let x = X(&mut x); +#[cfg(feature = "alloc")] +pub use boxed::*; +#[cfg(feature = "alloc")] +mod boxed { + use super::*; + + #[cfg(not(feature = "std"))] + use alloc::boxed::Box; - let any: &dyn LtAny = &x; + /// A `Box<T>` indirection. + pub enum Boxed {} - { - let mut x2 = 42; - let x2 = X(&mut x2); + const _: () = + assert!(core::mem::size_of::<Box<dyn Helper>>() <= core::mem::size_of::<RawIndirect>()); - let any2: &dyn LtAny = &x2; + unsafe impl<'a> Indirect<'a> for Boxed { + type ForT<T: ?Sized + 'a> = Box<T>; - assert_eq!(any.type_id(), any2.type_id()); + fn into_raw<T: ?Sized + 'a>(value: Box<T>) -> RawIndirect { + unsafe { transmute::<Box<T>, RawIndirect>(value) } } - // Forcing any to live until here will make it fail. - // drop(any); + unsafe fn from_raw<T: ?Sized + 'a>(any: RawIndirect) -> Box<T> { + unsafe { transmute::<RawIndirect, Box<T>>(any) } + } + } +} + +/// # Safety +/// Same rules as [`core::mem::transmute()`]. +unsafe fn transmute<T, U>(value: T) -> U { + // Create union type that can store a `T` or a `U`. + // We can then use this to convert between them. + // + // The repr(C) layout forces no offset between `t` and `u` as talked about here + // https://rust-lang.github.io/unsafe-code-guidelines/layout/unions.html#c-compatible-layout-repr-c + #[repr(C)] + union Transmute<T, U> { + t: ManuallyDrop<T>, + u: ManuallyDrop<U>, + } + + // Create the union in the `T` state. + let value = Transmute { + t: ManuallyDrop::new(value), + }; + + // Read from the union in the `U` state. + // SAFETY: This is safe because the caller has promised that `T` can be transmuted to `U`. + // The following reference link talks about repr(C) unions being used this way. + // https://doc.rust-lang.org/reference/items/unions.html#reading-and-writing-union-fields + ManuallyDrop::into_inner(unsafe { value.u }) +} + +#[cfg(test)] +mod test { + use super::*; + + #[derive(Debug, PartialEq)] + struct X<'a>(&'a mut i32); + + nameable! { + ['a, 'lt] + X<'lt> where {'lt: 'a} + X<'lt> where {'lt: 'a} } } |