Add another niche to FixedArray

This is not currently usable, due to rust-lang/rust#119507, but may become useful in future compiler versions

Author: GnomedDev

src/array.rs

@@ -1,14 +1,14 @@
 use std::{borrow::Cow, fmt::Debug, hash::Hash, mem::ManuallyDrop, ptr::NonNull};
 
-use crate::length::{InvalidLength, SmallLen, ValidLength};
+use crate::length::{InvalidLength, NonZero, SmallLen, ValidLength};
 
 /// A fixed size array with length provided at creation denoted in a [`ValidLength`], by default [`u32`].
 ///
 /// See module level documentation for more information.
 #[repr(packed)]
 pub struct FixedArray<T, LenT: ValidLength = SmallLen> {
     ptr: NonNull<T>,
-    len: LenT,
+    len: LenT::NonZero,
 }
 
 impl<T, LenT: ValidLength> FixedArray<T, LenT> {
@@ -23,15 +23,24 @@ impl<T, LenT: ValidLength> FixedArray<T, LenT> {
     pub fn empty() -> Self {
         Self {
             ptr: NonNull::dangling(),
-            len: LenT::ZERO,
+            len: LenT::DANGLING,
         }
     }
 
     /// # Safety
-    /// The `ptr.len()` and `len`'s value must match.
+    /// If the slice is empty:
+    /// - `len` must be equal to `LenT::DANGLING`
+    ///
+    /// If the slice is not empty:
+    /// - `len` must be equal to `ptr.len()`
     #[must_use]
-    unsafe fn from_box(ptr: Box<[T]>, len: LenT) -> Self {
-        debug_assert_eq!(ptr.len(), len.to_usize());
+    unsafe fn from_box(ptr: Box<[T]>, len: LenT::NonZero) -> Self {
+        #[cfg(debug_assertions)]
+        if ptr.is_empty() {
+            assert_eq!(len, LenT::DANGLING);
+        } else {
+            assert_eq!(len.into().to_usize(), ptr.len());
+        }
 
         let array_ptr = Box::into_raw(ptr).cast::<T>();
         Self {
@@ -41,7 +50,11 @@ impl<T, LenT: ValidLength> FixedArray<T, LenT> {
     }
 
     pub(crate) fn small_len(&self) -> LenT {
-        self.len
+        if { self.ptr } == NonNull::dangling() {
+            LenT::ZERO
+        } else {
+            self.len.into()
+        }
     }
 
     /// Returns the length of the [`FixedArray`].
@@ -233,7 +246,11 @@ impl<T, LenT: ValidLength> TryFrom<Box<[T]>> for FixedArray<T, LenT> {
             ));
         };
 
-        // SAFETY: The length has been derived from the box's length.
+        let len = LenT::NonZero::new(len).unwrap_or(LenT::DANGLING);
+
+        // SAFETY:
+        // If the length was 0, the above `unwrap_or` has just set the value to `LenT::DANGLING`.
+        // If the length was not 0, the `len` was derived from the box length.
         Ok(unsafe { Self::from_box(boxed_array, len) })
     }
 }
@@ -259,7 +276,7 @@ impl<T, LenT: ValidLength> From<Vec<T>> for FixedArray<T, LenT> {
     fn from(value: Vec<T>) -> Self {
         match value.into_boxed_slice().try_into() {
             Ok(arr) => arr,
-            Err(err) => Self::from(truncate_vec(err, LenT::MAX)),
+            Err(err) => Self::from(truncate_vec(err, LenT::MAX.to_usize())),
         }
     }
 }

src/length.rs

@@ -1,11 +1,21 @@
+use std::num::{NonZeroU16, NonZeroU32, NonZeroU8};
+
 use crate::inline::get_heap_threshold;
 
 mod sealed {
-    pub trait Sealed {}
-    impl Sealed for u8 {}
-    impl Sealed for u16 {}
+    use std::num::{NonZeroU16, NonZeroU32, NonZeroU8};
+
+    pub trait LengthSealed {}
+    impl LengthSealed for u8 {}
+    impl LengthSealed for u16 {}
     #[cfg(any(target_pointer_width = "64", target_pointer_width = "32"))]
-    impl Sealed for u32 {}
+    impl LengthSealed for u32 {}
+
+    pub trait NonZeroSealed {}
+    impl NonZeroSealed for NonZeroU8 {}
+    impl NonZeroSealed for NonZeroU16 {}
+    #[cfg(any(target_pointer_width = "64", target_pointer_width = "32"))]
+    impl NonZeroSealed for NonZeroU32 {}
 }
 
 #[derive(Debug)]
@@ -88,14 +98,42 @@ impl TryFrom<InvalidLength<u8>> for InvalidStrLength {
     }
 }
 
+#[doc(hidden)]
+pub trait NonZero<Int: ValidLength>:
+    sealed::NonZeroSealed + Into<Int> + Sized + Copy + PartialEq + std::fmt::Debug
+{
+    fn new(val: Int) -> Option<Self>;
+}
+
+impl NonZero<u8> for NonZeroU8 {
+    fn new(val: u8) -> Option<Self> {
+        NonZeroU8::new(val)
+    }
+}
+
+impl NonZero<u16> for NonZeroU16 {
+    fn new(val: u16) -> Option<Self> {
+        NonZeroU16::new(val)
+    }
+}
+
+impl NonZero<u32> for NonZeroU32 {
+    fn new(val: u32) -> Option<Self> {
+        NonZeroU32::new(val)
+    }
+}
+
 /// A sealed trait to represent valid lengths for a [`FixedArray`].
 ///
 /// This is implemented on `u32` for non-16 bit platforms, and `u16` on all platforms.
 ///
 /// [`FixedArray`]: `crate::array::FixedArray`
-pub trait ValidLength: sealed::Sealed + Default + Copy + TryFrom<usize> + Into<u32> {
+pub trait ValidLength: sealed::LengthSealed + Copy + TryFrom<usize> + Into<u32> {
     const ZERO: Self;
-    const MAX: usize;
+    const MAX: Self;
+    const DANGLING: Self::NonZero;
+
+    type NonZero: NonZero<Self>;
     #[cfg(feature = "typesize")]
     type InlineStrRepr: Copy + AsRef<[u8]> + AsMut<[u8]> + Default + typesize::TypeSize;
     #[cfg(not(feature = "typesize"))]
@@ -112,8 +150,10 @@ pub trait ValidLength: sealed::Sealed + Default + Copy + TryFrom<usize> + Into<u
 
 impl ValidLength for u8 {
     const ZERO: Self = 0;
-    #[allow(clippy::as_conversions)] // Cannot use `.into()` in const.
-    const MAX: usize = u8::MAX as usize;
+    const MAX: Self = Self::MAX;
+    const DANGLING: Self::NonZero = Self::NonZero::MAX;
+
+    type NonZero = NonZeroU8;
     type InlineStrRepr = [u8; get_heap_threshold::<Self>()];
 
     fn to_usize(self) -> usize {
@@ -123,8 +163,10 @@ impl ValidLength for u8 {
 
 impl ValidLength for u16 {
     const ZERO: Self = 0;
-    #[allow(clippy::as_conversions)] // Cannot use `.into()` in const.
-    const MAX: usize = u16::MAX as usize;
+    const MAX: Self = Self::MAX;
+    const DANGLING: Self::NonZero = Self::NonZero::MAX;
+
+    type NonZero = NonZeroU16;
     type InlineStrRepr = [u8; get_heap_threshold::<Self>()];
 
     fn to_usize(self) -> usize {
@@ -135,8 +177,10 @@ impl ValidLength for u16 {
 #[cfg(any(target_pointer_width = "64", target_pointer_width = "32"))]
 impl ValidLength for u32 {
     const ZERO: Self = 0;
-    #[allow(clippy::as_conversions)] // Cannot use `.into()` in const.
-    const MAX: usize = u32::MAX as usize;
+    const MAX: Self = Self::MAX;
+    const DANGLING: Self::NonZero = Self::NonZero::MAX;
+
+    type NonZero = NonZeroU32;
     type InlineStrRepr = [u8; get_heap_threshold::<Self>()];
 
     fn to_usize(self) -> usize {

src/string.rs

@@ -269,9 +269,13 @@ mod test {
 
     #[test]
     fn check_sizes() {
+        type DoubleOpt<T> = Option<Option<T>>;
+
         assert_eq!(std::mem::size_of::<Option<InlineString<[u8; 11]>>>(), 12);
         assert_eq!(std::mem::align_of::<Option<InlineString<[u8; 11]>>>(), 1);
         assert_eq!(std::mem::size_of::<Option<FixedArray<u8, u32>>>(), 12);
+        // https://github.com/rust-lang/rust/issues/119507
+        assert_eq!(std::mem::size_of::<DoubleOpt<FixedArray<u8, u32>>>(), 13);
         assert_eq!(std::mem::align_of::<Option<FixedArray<u8, u32>>>(), 1);
         // This sucks!! I want to fix this, soon.... this should so niche somehow.
         assert_eq!(std::mem::size_of::<FixedStringRepr<u32>>(), 13);