Adapt code to the removal of const_compare_raw_pointers

Author: slightlyoutofphase

Cargo.toml

@@ -5,7 +5,7 @@ repository = "https://github.com/slightlyoutofphase/staticvec"
 documentation = "https://docs.rs/staticvec/"
 license = "MIT OR Apache-2.0"
 readme = "README.md"
-version = "0.10.0"
+version = "0.10.1"
 authors = ["SlightlyOutOfPhase <[email protected]>"]
 keywords = ["vec", "array", "no_std", "vector", "stack"]
 categories = ["data-structures", "no-std"]

src/iterators.rs

@@ -5,9 +5,7 @@ use core::marker::{PhantomData, Send, Sync};
 use core::mem::MaybeUninit;
 use core::ptr;
 
-use crate::utils::{
-  distance_between, is_null_const, is_null_mut, slice_from_raw_parts, slice_from_raw_parts_mut,
-};
+use crate::utils::{distance_between, slice_from_raw_parts, slice_from_raw_parts_mut};
 use crate::StaticVec;
 
 #[cfg(feature = "std")]
@@ -92,9 +90,9 @@ impl<'a, T: 'a, const N: usize> Iterator for StaticVecIterConst<'a, T, N> {
       // Safety: `self.start` and `self.end` are never null if `T` is not a ZST,
       // and the possibility that `self.end` specifically is null if `T` *is* a ZST
       // is accounted for.
-      intrinsics::assume(!is_null_const(self.start));
+      intrinsics::assume(!self.start.is_null());
       if intrinsics::size_of::<T>() != 0 {
-        intrinsics::assume(!is_null_const(self.end));
+        intrinsics::assume(!self.end.is_null());
       }
       match distance_between(self.end, self.start) {
         0 => None,
@@ -156,9 +154,9 @@ impl<'a, T: 'a, const N: usize> DoubleEndedIterator for StaticVecIterConst<'a, T
       // Safety: `self.start` and `self.end` are never null if `T` is not a ZST,
       // and the possibility that `self.end` specifically is null if `T` *is* a ZST
       // is accounted for.
-      intrinsics::assume(!is_null_const(self.start));
+      intrinsics::assume(!self.start.is_null());
       if intrinsics::size_of::<T>() != 0 {
-        intrinsics::assume(!is_null_const(self.end));
+        intrinsics::assume(!self.end.is_null());
       }
       match distance_between(self.end, self.start) {
         0 => None,
@@ -268,9 +266,9 @@ impl<'a, T: 'a, const N: usize> Iterator for StaticVecIterMut<'a, T, N> {
       // Safety: `self.start` and `self.end` are never null if `T` is not a ZST,
       // and the possibility that `self.end` specifically is null if `T` *is* a ZST
       // is accounted for.
-      intrinsics::assume(!is_null_mut(self.start));
+      intrinsics::assume(!self.start.is_null());
       if intrinsics::size_of::<T>() != 0 {
-        intrinsics::assume(!is_null_mut(self.end));
+        intrinsics::assume(!self.end.is_null());
       }
       match distance_between(self.end, self.start) {
         0 => None,
@@ -332,9 +330,9 @@ impl<'a, T: 'a, const N: usize> DoubleEndedIterator for StaticVecIterMut<'a, T,
       // Safety: `self.start` and `self.end` are never null if `T` is not a ZST,
       // and the possibility that `self.end` specifically is null if `T` *is* a ZST
       // is accounted for.
-      intrinsics::assume(!is_null_mut(self.start));
+      intrinsics::assume(!self.start.is_null());
       if intrinsics::size_of::<T>() != 0 {
-        intrinsics::assume(!is_null_mut(self.end));
+        intrinsics::assume(!self.end.is_null());
       }
       match distance_between(self.end, self.start) {
         0 => None,

src/lib.rs

@@ -28,7 +28,6 @@
   incomplete_features
 )]
 #![feature(
-  const_compare_raw_pointers,
   const_fn,
   const_fn_union,
   const_generics,
@@ -74,8 +73,7 @@ pub use crate::iterators::{
 };
 pub use crate::string::{string_utils, StaticString, StringError};
 use crate::utils::{
-  is_null_const, is_null_mut, quicksort_internal, reverse_copy, slice_from_raw_parts,
-  slice_from_raw_parts_mut,
+  quicksort_internal, reverse_copy, slice_from_raw_parts, slice_from_raw_parts_mut,
 };
 
 #[cfg(any(feature = "std", rustdoc))]
@@ -1109,7 +1107,7 @@ impl<T, const N: usize> StaticVec<T, N> {
     let start_ptr = self.as_ptr();
     unsafe {
       // `start_ptr` will never be null, so this is a safe assumption to give the optimizer.
-      intrinsics::assume(!is_null_const(start_ptr));
+      intrinsics::assume(!start_ptr.is_null());
       StaticVecIterConst {
         start: start_ptr,
         end: match intrinsics::size_of::<T>() {
@@ -1138,7 +1136,7 @@ impl<T, const N: usize> StaticVec<T, N> {
     let start_ptr = self.as_mut_ptr();
     unsafe {
       // `start_ptr` will never be null, so this is a safe assumption to give the optimizer.
-      intrinsics::assume(!is_null_mut(start_ptr));
+      intrinsics::assume(!start_ptr.is_null());
       StaticVecIterMut {
         start: start_ptr,
         end: match intrinsics::size_of::<T>() {
@@ -1267,7 +1265,7 @@ impl<T, const N: usize> StaticVec<T, N> {
     }
     let self_ptr = self.as_mut_ptr();
     // We know self_ptr will never be null, so this is a safe hint to give the optimizer.
-    unsafe { intrinsics::assume(!is_null_mut(self_ptr)) };
+    unsafe { intrinsics::assume(!self_ptr.is_null()) };
     quicksort_internal(self_ptr, 0, (length - 1) as isize);
   }
 
@@ -1778,7 +1776,7 @@ impl<T, const N: usize> StaticVec<T, N> {
       let start_ptr = self.ptr_at_unchecked(start);
       // `start_ptr` will never be null, so this is a safe assumption to give to
       // the optimizer.
-      intrinsics::assume(!is_null_const(start_ptr));
+      intrinsics::assume(!start_ptr.is_null());
       // Create the StaticVecDrain from the specified range.
       StaticVecDrain {
         start: end,

src/utils.rs

@@ -1,7 +1,6 @@
 use core::cmp::{Ordering, PartialOrd};
 use core::intrinsics;
 use core::mem::MaybeUninit;
-use core::ptr;
 
 use crate::StaticVec;
 
@@ -35,8 +34,11 @@ where
   // function is called from, so these are safe hints to give to the
   // optimizer.
   unsafe {
-    intrinsics::assume(!is_null_const(src));
-    intrinsics::assume(!is_null_mut(dest));
+    intrinsics::assume(!src.is_null());
+    // Curiously, the explicit typecast to `*mut T` on the next line
+    // is necessary to get it to compile. Without the typecast, `rustc` can't figure out
+    // what the type is supposed to be for some reason.
+    intrinsics::assume(!(dest as *mut T).is_null());
   }
   while i > 0 {
     unsafe {
@@ -103,7 +105,7 @@ pub(crate) fn quicksort_internal<T: Copy + PartialOrd>(
   // We call this function from exactly one place where `low` and `high` are known to be within an
   // appropriate range before getting passed into it, so there's no need to check them again here.
   // We also know that `values` will never be null, so we can safely give an optimizer hint here.
-  unsafe { intrinsics::assume(!is_null_mut(values)) };
+  unsafe { intrinsics::assume(!values.is_null()) };
   loop {
     let mut i = low;
     let mut j = high;
@@ -164,65 +166,9 @@ pub(crate) union Repr<T> {
   pub(crate) raw: FatPtr<T>,
 }
 
-/// A local `const fn` version of `ptr.is_null()`.
-#[allow(clippy::cmp_null)]
-#[inline(always)]
-pub(crate) const fn is_null_const<T>(p: *const T) -> bool {
-  // Same code as in the original.
-  unsafe { (p as *const u8) == ptr::null() }
-}
-
-/// A local `const fn` version of `ptr.is_null()`.
-#[allow(clippy::cmp_null)]
-#[inline(always)]
-pub(crate) const fn is_null_mut<T>(p: *mut T) -> bool {
-  // Same code as in the original.
-  unsafe { (p as *mut u8) == ptr::null_mut() }
-}
-
-/// A local `const fn` version of the (private) `core::intrinsics::is_aligned_and_not_null` utility
-/// function, recreated here for the sake of wanting to be able to do exactly the same debug
-/// assertions in the slice methods below.
-#[inline(always)]
-pub(crate) const fn is_aligned_and_not_null_const<T>(_ptr: *const T) -> bool {
-  // Same code as in the original, just using our local `const` function to do the null check.
-  // unsafe { !is_null_const(ptr) && ptr as usize % core::mem::align_of::<T>() == 0 }
-
-  // Currently, the above code is not allowed in const contexts by the compiler even though we
-  // have the appropriate feature flags set, so for the time being this function is a pass-through.
-  //
-  // IMO, this is perfectly justifiable as we only actually call the below slice methods internally
-  // with pointers we already know are valid, and as such keeping the general-purpose debug
-  // assertions from the original source at all is arguably completely unnecessary in the first
-  // place.
-  true
-}
-
-/// A `mut` version of the above. Of course, you can pass `mut` pointers to functions taking `const`
-/// ones, but what the heck, it feels more symmetrical this way.
-#[inline(always)]
-pub(crate) const fn is_aligned_and_not_null_mut<T>(_ptr: *mut T) -> bool {
-  // Same code as in the original, just using our local `const` function to do the null check.
-  // unsafe { !is_null_mut(ptr) && ptr as usize % core::mem::align_of::<T>() == 0 }
-
-  // Currently, the above code is not allowed in const contexts by the compiler even though we
-  // have the appropriate feature flags set, so for the time being this function is a pass-through.
-  //
-  // IMO, this is perfectly justifiable as we only actually call the below slice methods internally
-  // with pointers we already know are valid, and as such keeping the general-purpose debug
-  // assertions from the original source at all is arguably completely unnecessary in the first
-  // place.
-  true
-}
-
 /// A local `const fn` version of `ptr::slice_from_raw_parts`.
 #[inline(always)]
 pub(crate) const fn ptr_slice_from_raw_parts<T>(data: *const T, len: usize) -> *const [T] {
-  // Same code as in the original, just using our local `const` functions where necessary.
-  debug_assert!(
-    is_aligned_and_not_null_const(data),
-    "A null or unaligned pointer was passed to `staticvec::utils::ptr_slice_from_raw_parts`!"
-  );
   debug_assert!(
     core::mem::size_of::<T>().saturating_mul(len) <= isize::MAX as usize,
     "Attempted to create a slice covering at least half the address space!"
@@ -238,11 +184,6 @@ pub(crate) const fn ptr_slice_from_raw_parts<T>(data: *const T, len: usize) -> *
 /// A local `const fn` version of `ptr::slice_from_raw_parts_mut`.
 #[inline(always)]
 pub(crate) const fn ptr_slice_from_raw_parts_mut<T>(data: *mut T, len: usize) -> *mut [T] {
-  // Same code as in the original, just using our local `const` functions where necessary.
-  debug_assert!(
-    is_aligned_and_not_null_mut(data),
-    "A null or unaligned pointer was passed to `staticvec::utils::ptr_slice_from_raw_parts_mut`!"
-  );
   debug_assert!(
     core::mem::size_of::<T>().saturating_mul(len) <= isize::MAX as usize,
     "Attempted to create a slice covering at least half the address space!"