Implement StaticReflect for AsmStr/AsmOption

Whoops! Can't believe I missed this :o
Add a SimpleNonZeroPointer trait.

Author: Techcable

src/builtins.rs

@@ -3,7 +3,7 @@
 //! These are mostly FFI-safe alternatives to the standard library
 //! types.
 use std::mem::MaybeUninit;
-use crate::StaticReflect;
+use crate::{StaticReflect, field_offset, TypeInfo};
 
 /// A FFi-safe slice type (`&[T]`)
 /// 
@@ -37,7 +37,21 @@ impl<T: StaticReflect> Clone for AsmSlice<T> {
     }
 }
 impl<T: StaticReflect> Copy for AsmSlice<T> {}
+impl<'a, T: 'a> From<&'a [T]> for AsmSlice<T> {
+    #[inline]
+    fn from(slice: &'a [T]) -> Self {
+        AsmSlice { ptr: slice.as_ptr() as *mut _, len: slice.len() }
+    }
+}
+unsafe impl<T: StaticReflect> StaticReflect for AsmSlice<T> {
+    const TYPE_INFO: TypeInfo<'static> = TypeInfo::Slice {
+        element_type: &T::TYPE_INFO
+    };
+}
 
+/// Assuming there is no mutation of the underlying memory,
+/// this is safe to send between threads
+unsafe impl<T: Sync> Send for AsmSlice<T> {}
 
 /// A FFI-safe UTF8 string.
 ///
@@ -65,6 +79,14 @@ impl AsmStr {
         self.bytes.len
     }
 }
+unsafe impl StaticReflect for AsmStr {
+    const TYPE_INFO: TypeInfo<'static> = TypeInfo::Str;
+}
+impl<'a> From<&'a str> for AsmStr {
+    fn from(s: &'a str) -> AsmStr {
+        AsmStr { bytes: s.as_bytes().into() }
+    }
+}
 
 /// A FFI-safe alternative to Rust's [std::optional::Option].
 ///
@@ -87,6 +109,23 @@ pub struct AsmOption<T> {
     present: bool,
     value: MaybeUninit<T>
 }
+impl AsmOption<()> {
+    /// The offset of the 'present' field
+    ///
+    /// This should be zero, regardless of the inner type
+    #[inline]
+    pub const fn present_field_offset() -> usize {
+        assert!(field_offset!(AsmOption::<()>, present) == 0);
+        0
+    }
+    /// The offset of the value field
+    ///
+    /// This should be equal to the type's alignment
+    #[inline]
+    pub const fn value_field_offset(element_type: TypeInfo<'static>) -> usize {
+        element_type.alignment()
+    }
+}
 impl<T> AsmOption<T> {
     /// An option with no value
     #[inline]
@@ -123,3 +162,17 @@ impl<T> AsmOption<T> {
         self.present
     }
 }
+impl<T> From<Option<T>> for AsmOption<T> {
+    fn from(o: Option<T>) -> AsmOption<T> {
+        match o {
+            None => AsmOption::none(),
+            Some(v) => AsmOption::some(v)
+        }
+    }
+}
+unsafe impl<T: StaticReflect> StaticReflect for AsmOption<T> {
+    const TYPE_INFO: TypeInfo<'static> = TypeInfo::Optional(&T::TYPE_INFO);
+}
+
+/// This is an owned value, so it's safe to send
+unsafe impl<T: Send> Send for AsmOption<T> {}

src/core.rs

@@ -1,6 +1,8 @@
 //! Implementations of [StaticReflect] for core types (for `#![no_std]`)
 use crate::StaticReflect;
 use crate::types::{TypeInfo};
+use std::mem::{self, ManuallyDrop};
+use core::ptr::NonNull;
 
 macro_rules! impl_primitive {
     ($target:ty => $info:expr) => {
@@ -31,6 +33,18 @@ impl_primitive!(bool => TypeInfo::Bool);
 impl_primitive!(f32 => TypeInfo::F32);
 impl_primitive!(f64 => TypeInfo::F64);
 
+// Builtin support for the never type
+impl_primitive!(! => TypeInfo::Never);
+
+
+/// Support [StaticReflect] for [ManuallyDrop] by just representing the inner type
+unsafe impl<T: StaticReflect> StaticReflect for ManuallyDrop<T> {
+    const TYPE_INFO: TypeInfo<'static> = {
+        assert!(mem::size_of::<Self>() == mem::size_of::<T>());
+        T::TYPE_INFO
+    };
+}
+
 /// A pointer
 ///
 /// NOTE: The pointed-to value can be anything,
@@ -49,3 +63,18 @@ unsafe impl <T> StaticReflect for *mut T {
 unsafe impl <T> StaticReflect for *const T {
     const TYPE_INFO: TypeInfo<'static> = TypeInfo::Pointer;
 }
+
+/// A non-zero pointer type, where optional types
+/// are guaranteed to use the nullable representation
+///
+/// If `T: SimpleNonZeroPointer` -> `sizeof(Option<T>) == sizeof(T) && repr(Option<T>) == repr(T)`
+pub unsafe trait SimpleNonZeroPointer: StaticReflect {}
+
+unsafe impl <T> SimpleNonZeroPointer for NonNull<T> {}
+unsafe impl <T> StaticReflect for NonNull<T> {
+    const TYPE_INFO: TypeInfo<'static> = TypeInfo::Pointer;
+}
+
+unsafe impl <T: SimpleNonZeroPointer> StaticReflect for Option<T> {
+    const TYPE_INFO: TypeInfo<'static> = TypeInfo::Pointer;
+}

src/lib.rs

@@ -13,9 +13,13 @@
 #![feature(
     const_fn, // We rely on const eval :(
     const_panic, const_option, // We use Option::unwrap
+    // Used for field_offset macro
+    const_raw_ptr_deref,
+    const_raw_ptr_to_usize_cast,
 )]
 #![cfg_attr(feature = "never", feature(never_type))]
 
+mod macros;
 #[cfg(feature = "builtins")]
 pub mod builtins;
 pub mod types;
@@ -25,21 +29,6 @@ mod core;
 
 use crate::types::TypeInfo;
 
-/// Get the integer offset of the specified field
-#[macro_export]
-macro_rules! field_offset {
-    ($target:path, $($field:ident),+) => {
-        unsafe {
-            /*
-             * I'm going to assume the dereference is safe,
-             * because of the presense of '(*uninit.as_mut_ptr()).field'
-             * in the documentation for std::ptr::addr_of_mut
-             */
-            (std::ptr::addr_of!((*(1 as *mut $target))$(.$field)*) as usize) - 1
-        }
-    }
-}
-
 /// The trait for types whose information can be accessed via static reflection.
 ///
 /// In order to proper access any fields,

src/macros.rs

@@ -0,0 +1,15 @@
+
+/// Get the integer offset of the specified field
+#[macro_export]
+macro_rules! field_offset {
+    ($target:path, $($field:ident),+) => {
+        unsafe {
+            /*
+             * I'm going to assume the dereference is safe,
+             * because of the presense of '(*uninit.as_mut_ptr()).field'
+             * in the documentation for std::ptr::addr_of_mut
+             */
+            (std::ptr::addr_of!((*(1 as *mut $target))$(.$field)*) as usize) - 1
+        }
+    }
+}