A few more tweaks

Author: slightlyoutofphase

src/heap/heap_helpers.rs

@@ -118,8 +118,10 @@ impl<'a, T> StaticHeapHole<'a, T> {
   pub(crate) unsafe fn move_to(&mut self, index: usize) {
     debug_assert!(index != self.position);
     debug_assert!(index < self.data.len());
-    let index_ptr = self.data.as_ptr().add(index);
-    let hole_ptr = self.data.as_mut_ptr().add(self.position);
+    // This avoids aliasing, per the most recent revision of BinaryHeap's code.
+    let ptr = self.data.as_mut_ptr();
+    let index_ptr: *const _ = ptr.add(index);
+    let hole_ptr = ptr.add(self.position);
     index_ptr.copy_to_nonoverlapping(hole_ptr, 1);
     self.position = index;
   }

src/lib.rs

@@ -462,7 +462,9 @@ impl<T, const N: usize> StaticVec<T, N> {
     // This is the same aliasing-avoidance / optimization-trick approach used by regular Vec.
     let res = self.data.as_ptr() as *const T;
     // A pointer to "element zero" of an array is never null.
-    unsafe { assume(!res.is_null()); }
+    unsafe {
+      assume(!res.is_null());
+    }
     res
   }
 
@@ -483,7 +485,9 @@ impl<T, const N: usize> StaticVec<T, N> {
   pub const fn as_mut_ptr(&mut self) -> *mut T {
     // See the comment above in `as_ptr()`.
     let res = self.data.as_mut_ptr() as *mut T;
-    unsafe { assume(!res.is_null()); }
+    unsafe {
+      assume(!res.is_null());
+    }
     res
   }
 
@@ -2615,7 +2619,9 @@ impl<T, const N: usize> StaticVec<T, N> {
   #[inline(always)]
   pub(crate) const fn first_ptr(this: &MaybeUninit<[T; N]>) -> *const T {
     let res = this.as_ptr() as *const T;
-    unsafe { assume(!res.is_null()); }
+    unsafe {
+      assume(!res.is_null());
+    }
     res
   }
 
@@ -2625,7 +2631,9 @@ impl<T, const N: usize> StaticVec<T, N> {
   #[inline(always)]
   pub(crate) const fn first_ptr_mut(this: &mut MaybeUninit<[T; N]>) -> *mut T {
     let res = this.as_mut_ptr() as *mut T;
-    unsafe { assume(!res.is_null()); }
+    unsafe {
+      assume(!res.is_null());
+    }
     res
   }
 }

src/utils.rs

@@ -96,7 +96,10 @@ pub(crate) const fn zst_ptr_add<T>(ptr: *const T, count: usize) -> *const T {
 /// An internal convenience function for incrementing mutable ZST pointers by usize offsets.
 #[inline(always)]
 pub(crate) const fn zst_ptr_add_mut<T>(ptr: *mut T, count: usize) -> *mut T {
-  debug_assert!(size_of::<T>() == 0, "`zst_ptr_add_mut` called on a non-ZST!");
+  debug_assert!(
+    size_of::<T>() == 0,
+    "`zst_ptr_add_mut` called on a non-ZST!"
+  );
   (ptr as *mut u8).wrapping_add(count) as *mut T
 }