naming consistency

Author: echohumm

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "memapi2"
-version = "0.5.0"
+version = "0.5.1"
 edition = "2018"
 rust-version = "1.56.0"
 authors = ["echohumm"]

build.rs

@@ -50,7 +50,7 @@ mod checks {
             let ptr = slice.as_mut_ptr();
             let len = slice.len();
 
-            let slice_ptr = slice_ptr_from_raw_parts(ptr, len);
+            let slice_ptr = slice_ptr_from_parts(ptr, len);
 
             // check that they dereference to the same thing
             if unsafe { &*slice_ptr } != slice {
@@ -78,7 +78,7 @@ mod checks {
 
             unsafe {
                 if len
-                    != nonnull_slice_len(nonnull_slice_from_raw_parts(
+                    != nonnull_slice_len(nonnull_slice_from_parts(
                         NonNull::new_unchecked(ptr),
                         len
                     ))
@@ -123,12 +123,12 @@ mod checks {
         }
 
         #[must_use]
-        fn nonnull_slice_from_raw_parts<T>(p: NonNull<T>, len: usize) -> NonNull<[T]> {
-            unsafe { NonNull::new_unchecked(slice_ptr_from_raw_parts(p.as_ptr(), len)) }
+        fn nonnull_slice_from_parts<T>(p: NonNull<T>, len: usize) -> NonNull<[T]> {
+            unsafe { NonNull::new_unchecked(slice_ptr_from_parts(p.as_ptr(), len)) }
         }
 
         #[must_use]
-        fn slice_ptr_from_raw_parts<T>(p: *mut T, len: usize) -> *mut [T] {
+        fn slice_ptr_from_parts<T>(p: *mut T, len: usize) -> *mut [T] {
             unsafe {
                 // i hate this so much
                 *((&(p, len)) as *const (*mut T, usize)).cast::<*mut [T]>()

src/data/type_props.rs

@@ -307,7 +307,7 @@ const_if! {
     #[must_use]
     pub const fn varsized_dangling_pointer<T: ?Sized + VarSized>() -> *mut T {
         // SAFETY: the implementor of VarSized guarantees the ALN is valid.
-        varsized_pointer_from_raw_parts(unsafe { dangling_nonnull(T::ALN).as_ptr() }, 0)
+        varsized_pointer_from_parts(unsafe { dangling_nonnull(T::ALN).as_ptr() }, 0)
     }
 }
 
@@ -321,7 +321,7 @@ const_if! {
         meta: usize,
     ) -> NonNull<T> {
         // SAFETY: `p` was already non-null, so it with different meta must also be nn.
-        unsafe { NonNull::new_unchecked(varsized_pointer_from_raw_parts(p.as_ptr(), meta)) }
+        unsafe { NonNull::new_unchecked(varsized_pointer_from_parts(p.as_ptr(), meta)) }
     }
 }
 
@@ -331,7 +331,7 @@ const_if! {
     #[must_use]
     #[inline]
     #[allow(clippy::not_unsafe_ptr_arg_deref)]
-    pub const fn varsized_pointer_from_raw_parts<T: ?Sized + VarSized>(
+    pub const fn varsized_pointer_from_parts<T: ?Sized + VarSized>(
         p: *mut u8,
         meta: usize,
     ) -> *mut T {

src/helpers.rs

@@ -7,7 +7,7 @@ use {
             SizedProps,
             USIZE_MAX_NO_HIGH_BIT,
             varsized_nonnull_from_parts,
-            varsized_pointer_from_raw_parts
+            varsized_pointer_from_parts
         },
         error::{AlignErr, AllocError, ArithErr, ArithOp, Cause, InvLayout, LayoutErr}
     },
@@ -206,7 +206,7 @@ const_if! {
     "Creates a `NonNull<[T]>` from a pointer and a length.\n\nThis is a helper used in place of
     [`NonNull::slice_from_raw_parts`], which was stabilized after this crate's MSRV.",
     #[must_use]
-    pub const fn nonnull_slice_from_raw_parts<T>(p: NonNull<T>, len: usize) -> NonNull<[T]> {
+    pub const fn nonnull_slice_from_parts<T>(p: NonNull<T>, len: usize) -> NonNull<[T]> {
         varsized_nonnull_from_parts(p.cast(), len)
     }
 }
@@ -216,8 +216,8 @@ const_if! {
     "Creates a `*mut [T]` from a pointer and a length.\n\nThis is a helper used in place of \
     [`ptr::slice_from_raw_parts_mut`], which was const-stabilized after this crate's MSRV.",
     #[must_use]
-    pub const fn slice_ptr_from_raw_parts<T>(p: *mut T, len: usize) -> *mut [T] {
-        varsized_pointer_from_raw_parts(p.cast(), len)
+    pub const fn slice_ptr_from_parts<T>(p: *mut T, len: usize) -> *mut [T] {
+        varsized_pointer_from_parts(p.cast(), len)
     }
 }
 
@@ -553,7 +553,7 @@ impl<'a, T, A: Alloc + ?Sized> SliceAllocGuard<'a, T, A> {
         #[cfg_attr(miri, track_caller)]
         #[must_use]
         pub const fn get_init_part(&self) -> NonNull<[T]> {
-            nonnull_slice_from_raw_parts(self.ptr, self.init)
+            nonnull_slice_from_parts(self.ptr, self.init)
         }
     }
 
@@ -562,7 +562,7 @@ impl<'a, T, A: Alloc + ?Sized> SliceAllocGuard<'a, T, A> {
         "Gets a `NonNull<[T]>` pointer to the uninitialized elements of the slice.",
         #[must_use]
         pub const fn get_uninit_part(&self) -> NonNull<[T]> {
-            nonnull_slice_from_raw_parts(
+            nonnull_slice_from_parts(
                 // SAFETY: the pointer was a valid NonNull to begin with, adding cannot invalidate
                 //  it. `self.init` will be in bounds unless an init-setting method was used
                 //  incorrectly.
@@ -578,7 +578,7 @@ impl<'a, T, A: Alloc + ?Sized> SliceAllocGuard<'a, T, A> {
         #[cfg_attr(miri, track_caller)]
         #[must_use]
         pub const fn get_full(&self) -> NonNull<[T]> {
-            nonnull_slice_from_raw_parts(self.ptr, self.full)
+            nonnull_slice_from_parts(self.ptr, self.full)
         }
     }
 
@@ -755,7 +755,7 @@ impl<T, A: Alloc + ?Sized> Drop for SliceAllocGuard<'_, T, A> {
         // SAFETY: `self.init` will be correct without improper usage of methods which set it. new()
         //  requires that the pointer was allocated using the provided allocator.
         unsafe {
-            ptr::drop_in_place(slice_ptr_from_raw_parts(self.ptr.as_ptr(), self.init));
+            ptr::drop_in_place(slice_ptr_from_parts(self.ptr.as_ptr(), self.init));
             self.alloc.dealloc(
                 self.ptr.cast(),
                 Layout::from_size_align_unchecked(T::SZ * self.full, T::ALN)