Some additional refactoring and test adjustments.

Hopefully the weirdness with running Miri specifically on Mac is gone.

Author: slightlyoutofphase

src/iterators.rs

@@ -713,7 +713,7 @@ impl<'a, T: 'a, const N: usize> Iterator for StaticVecDrain<'a, T, N> {
   type Item = T;
 
   #[inline(always)]
-  fn next(&mut self) -> Option<T> {   
+  fn next(&mut self) -> Option<T> {
     self
       .iter
       .next()

src/utils.rs

@@ -5,13 +5,13 @@ use core::mem::{size_of, MaybeUninit};
 use crate::StaticVec;
 
 #[inline(always)]
-pub(crate) fn runtime_zst_handler<T>(dest: *const T, origin: *const T) -> usize {
+pub(crate) fn runtime_distance_between<T>(dest: *const T, origin: *const T) -> usize {
   // At runtime we can handle ZSTs with usize casts, as is done throughout the crate.
   (dest as usize).wrapping_sub(origin as usize)
 }
 
 #[inline(always)]
-pub(crate) const fn compiletime_zst_handler<T>(_dest: *const T, _origin: *const T) -> usize {
+pub(crate) const fn compiletime_distance_between<T>(_dest: *const T, _origin: *const T) -> usize {
   assert!(
     size_of::<T>() == 0,
     "`compiletime_zst_handler` called on a non-ZST!"
@@ -28,7 +28,13 @@ pub(crate) const fn distance_between<T>(dest: *const T, origin: *const T) -> usi
   match size_of::<T>() {
     // This function cannot safely be used on ZST pointers at compile time (which would not be
     // useful in any scenario I can currently think of anyways).
-    0 => unsafe { const_eval_select((dest, origin), compiletime_zst_handler, runtime_zst_handler) },
+    0 => unsafe {
+      const_eval_select(
+        (dest, origin),
+        compiletime_distance_between,
+        runtime_distance_between,
+      )
+    },
     // For all other sizes of `T` though, `offset_from` works just fine.
     _ => unsafe { dest.offset_from(origin) as usize },
   }
@@ -102,11 +108,31 @@ where T: Copy {
   }
 }
 
+#[inline(always)]
+pub(crate) const fn compiletime_zst_ptr_add<T>(ptr: *const T, count: usize) -> *const T {
+  (ptr as *const u8).wrapping_add(count) as *const T
+}
+
+#[inline(always)]
+pub(crate) const fn compiletime_zst_ptr_add_mut<T>(ptr: *mut T, count: usize) -> *mut T {
+  (ptr as *mut u8).wrapping_add(count) as *mut T
+}
+
+#[inline(always)]
+pub(crate) fn runtime_zst_ptr_add<T>(ptr: *const T, count: usize) -> *const T {
+  (ptr as usize + count) as *const T
+}
+
+#[inline(always)]
+pub(crate) fn runtime_zst_ptr_add_mut<T>(ptr: *mut T, count: usize) -> *mut T {
+  (ptr as usize + count) as *mut T
+}
+
 /// An internal convenience function for incrementing immutable ZST pointers by usize offsets.
 #[inline(always)]
 pub(crate) const fn zst_ptr_add<T>(ptr: *const T, count: usize) -> *const T {
   debug_assert!(size_of::<T>() == 0, "`zst_ptr_add` called on a non-ZST!");
-  (ptr as *const u8).wrapping_add(count) as *const T
+  unsafe { const_eval_select((ptr, count), compiletime_zst_ptr_add, runtime_zst_ptr_add) }
 }
 
 /// An internal convenience function for incrementing mutable ZST pointers by usize offsets.
@@ -116,7 +142,13 @@ pub(crate) const fn zst_ptr_add_mut<T>(ptr: *mut T, count: usize) -> *mut T {
     size_of::<T>() == 0,
     "`zst_ptr_add_mut` called on a non-ZST!"
   );
-  (ptr as *mut u8).wrapping_add(count) as *mut T
+  unsafe {
+    const_eval_select(
+      (ptr, count),
+      compiletime_zst_ptr_add_mut,
+      runtime_zst_ptr_add_mut,
+    )
+  }
 }
 
 /// A version of the default `partial_cmp` implementation with a more flexible function signature.

test/test_staticvec.rs

@@ -498,31 +498,14 @@ fn drain_iter() {
     ZST {},
     ZST {},
   ];
-  let mut v5_drain = v5.drain_iter(6..12);
-  assert_eq!(v5_drain.len(), 6);
-  while let Some(_x) = v5_drain.next() {}
-  drop(v5_drain);
+  assert_eq!(v5.drain_iter(6..12).len(), 6);
   assert_eq!(v5.len(), 10);
   let mut v6 = staticvec![
-    box 1,
-    box 2,
-    box 3,
-    box 4,
-    box 5,
-    box 6,
-    box 7,
-    box 8,
-    box 9,
-    box 10,
-    box 11,
-    box 12,
-    box 13,
-    box 14,
-    box 15,
-    box 16,
+    box 1, box 2, box 3, box 4, box 5, box 6, box 7, box 8, box 9, box 10, box 11, box 12, box 13,
+    box 14, box 15, box 16,
   ];
   assert_eq!(v6.drain_iter(6..12).len(), 6);
-  assert_eq!(v6.len(), 10);  
+  assert_eq!(v6.len(), 10);
   assert_eq!(
     staticvec![1, 2, 3, 4]
       .drain_iter(1..3)
@@ -1150,6 +1133,26 @@ fn iter_nth() {
   let o = it7.nth(5);
   assert_eq!(format!("{:?}", o), "Some([6, 6])");
   assert_eq!(format!("{:?}", it7), "StaticVecIterConst([])");
+  let vlast = staticvec![
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {}
+  ];
+  let mut itlast = vlast.iter();
+  assert_eq!(itlast.nth(13).unwrap(), &ZST {});
 }
 
 #[test]
@@ -1379,6 +1382,26 @@ fn iter_mut_nth() {
   let o = it7.nth(5);
   assert_eq!(format!("{:?}", o), "Some([6, 6])");
   assert_eq!(format!("{:?}", it7), "StaticVecIterMut([])");
+  let mut vlast = staticvec![
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {}
+  ];
+  let mut itlast = vlast.iter_mut();
+  assert_eq!(itlast.nth(13).unwrap(), &mut ZST {});
 }
 
 #[test]
@@ -1654,6 +1677,26 @@ fn into_iter_nth() {
   let o = it7.nth(5);
   assert_eq!(format!("{:?}", o), "Some([6, 6])");
   assert_eq!(format!("{:?}", it7), "StaticVecIntoIter([])");
+  let vlast = staticvec![
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {},
+    ZST {}
+  ];
+  let mut itlast = vlast.into_iter();
+  assert_eq!(itlast.nth(13).unwrap(), ZST {});
 }
 
 #[test]