cleanup a bit, and formatting

Author: echohumm

Cargo.toml

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

build.rs

@@ -100,7 +100,9 @@ mod checks {
         // from the crate
 
         #[must_use]
-        fn nonnull_slice_len<T>(ptr: NonNull<[T]>) -> usize { unsafe { (&*ptr.as_ptr()).len() } }
+        fn nonnull_slice_len<T>(ptr: NonNull<[T]>) -> usize {
+            unsafe { (&*ptr.as_ptr()).len() }
+        }
 
         #[must_use]
         fn nonnull_slice_from_raw_parts<T>(p: NonNull<T>, len: usize) -> NonNull<[T]> {

src/data/marker.rs

@@ -22,8 +22,6 @@ unsafe impl UnsizedCopy for std::ffi::OsStr {}
 // SAFETY: `Path == OsStr == [u8]`
 unsafe impl UnsizedCopy for std::path::Path {}
 
-// TODO: better solution than making them all unsafe
-
 #[cfg(all(not(feature = "metadata"), not(feature = "sized_hierarchy")))]
 /// Trait indicating that a type has no metadata.
 ///

src/data/type_props.rs

@@ -1,6 +1,7 @@
 use {
-    crate::{Layout, helpers::dangling_nonnull},
+    crate::helpers::dangling_nonnull,
     core::{
+        alloc::Layout,
         mem::{align_of, align_of_val, size_of, size_of_val},
         ptr::NonNull
     }
@@ -19,7 +20,9 @@ pub const USIZE_HIGH_BIT: usize = usize::MAX ^ (usize::MAX >> 1);
 /// A small helper to generate a `usize` in which only the bit at the given index is set.
 #[must_use]
 #[inline]
-pub const fn usize_bit(bit: u8) -> usize { USIZE_HIGH_BIT >> bit }
+pub const fn usize_bit(bit: u8) -> usize {
+    USIZE_HIGH_BIT >> bit
+}
 
 /// A trait containing constants for sized types.
 pub trait SizedProps: Sized {
@@ -78,7 +81,9 @@ pub trait PtrProps<T: ?Sized> {
     ///
     /// References are always valid.
     #[inline]
-    unsafe fn layout(&self) -> Layout { Layout::from_size_align_unchecked(self.sz(), self.aln()) }
+    unsafe fn layout(&self) -> Layout {
+        Layout::from_size_align_unchecked(self.sz(), self.aln())
+    }
 
     #[cfg(feature = "metadata")]
     /// Gets the metadata of the value.
@@ -103,7 +108,9 @@ pub trait PtrProps<T: ?Sized> {
     /// - aligned
     ///
     /// References are always valid.
-    unsafe fn is_zst(&self) -> bool { self.sz() == 0 }
+    unsafe fn is_zst(&self) -> bool {
+        self.sz() == 0
+    }
 
     /// Gets the largest safe length for a slice containing copies of `self`.
     ///
@@ -196,10 +203,14 @@ impl_ptr_props_as_ref! {
 
 impl<T: ?Sized> PtrProps<T> for NonNull<T> {
     #[inline]
-    unsafe fn sz(&self) -> usize { size_of_val::<T>(&*self.as_ptr()) }
+    unsafe fn sz(&self) -> usize {
+        size_of_val::<T>(&*self.as_ptr())
+    }
 
     #[inline]
-    unsafe fn aln(&self) -> usize { align_of_val::<T>(&*self.as_ptr()) }
+    unsafe fn aln(&self) -> usize {
+        align_of_val::<T>(&*self.as_ptr())
+    }
 
     #[cfg(feature = "metadata")]
     unsafe fn metadata(&self) -> <T as core::ptr::Pointee>::Metadata {

src/error.rs

@@ -1,9 +1,7 @@
-use {
-    crate::Layout,
-    core::{
-        fmt::{Debug, Display, Formatter, Result as FmtResult},
-        ptr::NonNull
-    }
+use core::{
+    alloc::Layout,
+    fmt::{Debug, Display, Formatter, Result as FmtResult},
+    ptr::NonNull
 };
 
 /// Errors for allocator operations.

src/helpers.rs

@@ -1,18 +1,22 @@
 use {
     crate::{
-        Alloc, Layout,
+        Alloc,
+        Layout,
         data::type_props::{
-            PtrProps, SizedProps, USIZE_MAX_NO_HIGH_BIT, varsized_nonnull_from_raw_parts,
-            varsized_pointer_from_raw_parts,
+            PtrProps,
+            SizedProps,
+            USIZE_MAX_NO_HIGH_BIT,
+            varsized_nonnull_from_raw_parts,
+            varsized_pointer_from_raw_parts
         },
-        error::{AllocError, ArithOp, ArithOverflow, Cause, InvLayout, LayoutErr},
+        error::{AllocError, ArithOp, ArithOverflow, Cause, InvLayout, LayoutErr}
     },
     core::{
         mem::{forget, transmute},
         num::NonZeroUsize,
         ops::Deref,
-        ptr::{self, NonNull},
-    },
+        ptr::{self, NonNull}
+    }
 };
 
 /// Performs a checked arithmetic operation on two `usize`s.
@@ -26,12 +30,12 @@ pub const fn checked_op(l: usize, op: ArithOp, r: usize) -> Result<usize, ArithO
         ArithOp::Sub => l.checked_sub(r),
         ArithOp::Mul => l.checked_mul(r),
         ArithOp::Div => l.checked_div(r),
-        ArithOp::Rem => l.checked_rem(r),
+        ArithOp::Rem => l.checked_rem(r)
     };
 
     match res {
         Some(v) => Ok(v),
-        None => AllocError::arith_overflow(l, op, r),
+        None => AllocError::arith_overflow(l, op, r)
     }
 }
 
@@ -44,7 +48,7 @@ pub const fn checked_op(l: usize, op: ArithOp, r: usize) -> Result<usize, ArithO
 pub fn checked_op_panic(l: usize, op: ArithOp, r: usize) -> usize {
     match checked_op(l, op, r) {
         Ok(v) => v,
-        Err(e) => panic!("{}", e),
+        Err(e) => panic!("{}", e)
     }
 }
 
@@ -60,7 +64,7 @@ pub fn checked_op_panic(l: usize, op: ArithOp, r: usize) -> usize {
 pub const fn checked_op_panic_const(l: usize, op: ArithOp, r: usize) -> usize {
     match checked_op(l, op, r) {
         Ok(v) => v,
-        Err(_) => panic!("An arithmetic operation overflowed"),
+        Err(_) => panic!("An arithmetic operation overflowed")
     }
 }
 
@@ -77,7 +81,7 @@ pub const fn checked_op_panic_const(l: usize, op: ArithOp, r: usize) -> usize {
 pub fn checked_op_panic_const(l: usize, op: ArithOp, r: usize) -> usize {
     match checked_op(l, op, r) {
         Ok(v) => v,
-        Err(..) => panic!("An arithmetic operation overflowed"),
+        Err(..) => panic!("An arithmetic operation overflowed")
     }
 }
 
@@ -174,38 +178,6 @@ pub const fn layout_or_sz_align<T>(n: usize) -> Result<Layout, (usize, usize, La
     unsafe { Ok(Layout::from_size_align_unchecked(sz * n, align)) }
 }
 
-/// Preprocesses a [`Layout`] to get its `Malloc`-compatible form (rounds the alignment up to the
-/// nearest multiple of [`usize::SZ`], AKA `size_of::<*const c_void>()`).
-///
-/// If the layout is already compatible, does nothing.
-#[cfg_attr(not(feature = "dev"), doc(hidden))]
-#[allow(clippy::missing_errors_doc)]
-pub fn preproc_layout(layout: Layout) -> Result<Layout, InvLayout> {
-    let sz = layout.size();
-    let align = tri!(do round_to_ptr_align(sz, layout.align()));
-    match crate::unstable_util::lay_from_size_align(sz, align) {
-        Ok(l) => Ok(l),
-        Err(LayoutErr::ExceedsMax) => {
-            AllocError::inv_layout(sz, align, LayoutErr::MallocExceedsMax)
-        }
-        // SAFETY: the only other error which can occur is Align, but since the alignment came from
-        //  a valid layout and round_to_ptr_align cannot make it zero or a non-power-of-two, it will
-        //  still be valid, so that error cannot occur.
-        _ => unsafe { core::hint::unreachable_unchecked() },
-    }
-}
-
-pub(crate) const fn round_to_ptr_align(sz: usize, align: usize) -> Result<usize, InvLayout> {
-    let mask = usize::SZ - 1;
-    if align & mask == 0 {
-        return Ok(align);
-    }
-    match checked_op(align, ArithOp::Add, mask) {
-        Ok(v) => Ok(v & !mask),
-        Err(e) => AllocError::inv_layout(sz, align, LayoutErr::MallocOverflow(e)),
-    }
-}
-
 const_if! {
     "const_extras",
     "Creates a `NonNull<[T]>` from a pointer and a length.\n\nThis is a helper used in place of
@@ -246,7 +218,7 @@ const_if! {
 #[allow(clippy::missing_errors_doc)]
 pub fn zsl_check<Ret, F: Fn(Layout) -> Result<Ret, AllocError>>(
     layout: Layout,
-    f: F,
+    f: F
 ) -> Result<Ret, AllocError> {
     if layout.size() == 0 {
         Err(AllocError::ZeroSizedLayout(dangling_nonnull_for(layout)))
@@ -268,9 +240,9 @@ pub fn null_q_oserr<T>(ptr: *mut T, layout: Layout) -> Result<NonNull<u8>, Alloc
                 #[allow(clippy::option_if_let_else)]
                 match std::io::Error::last_os_error().raw_os_error() {
                     Some(e) => e,
-                    None => core::hint::unreachable_unchecked(),
+                    None => core::hint::unreachable_unchecked()
                 }
-            }),
+            })
         ))
     } else {
         // SAFETY: we just checked that the pointer is non-null
@@ -319,7 +291,7 @@ pub fn null_q_dyn<T>(ptr: *mut T, layout: Layout) -> Result<NonNull<u8>, AllocEr
 pub fn null_q_zsl_check<T, F: Fn(Layout) -> *mut T>(
     layout: Layout,
     f: F,
-    nq: fn(*mut T, Layout) -> Result<NonNull<u8>, AllocError>,
+    nq: fn(*mut T, Layout) -> Result<NonNull<u8>, AllocError>
 ) -> Result<NonNull<u8>, AllocError> {
     zsl_check(layout, |layout: Layout| nq(f(layout), layout))
 }
@@ -333,11 +305,11 @@ pub fn alloc_then<Ret, A: Alloc + ?Sized, E, F: Fn(NonNull<u8>, E) -> Ret>(
     a: &A,
     layout: Layout,
     e: E,
-    then: F,
+    then: F
 ) -> Result<Ret, AllocError> {
     match a.alloc(layout) {
         Ok(ptr) => Ok(then(ptr, e)),
-        Err(e) => Err(e),
+        Err(e) => Err(e)
     }
 }
 
@@ -373,7 +345,7 @@ pub fn alloc_then<Ret, A: Alloc + ?Sized, E, F: Fn(NonNull<u8>, E) -> Ret>(
 /// ```
 pub struct AllocGuard<'a, T: ?Sized, A: Alloc + ?Sized> {
     ptr: NonNull<T>,
-    alloc: &'a A,
+    alloc: &'a A
 }
 
 impl<'a, T: ?Sized, A: Alloc + ?Sized> AllocGuard<'a, T, A> {
@@ -482,7 +454,7 @@ pub struct SliceAllocGuard<'a, T, A: Alloc + ?Sized> {
     ptr: NonNull<T>,
     alloc: &'a A,
     pub(crate) init: usize,
-    full: usize,
+    full: usize
 }
 
 impl<'a, T, A: Alloc + ?Sized> SliceAllocGuard<'a, T, A> {
@@ -704,7 +676,7 @@ impl<'a, T, A: Alloc + ?Sized> SliceAllocGuard<'a, T, A> {
     /// `excess` if `slice.len() > remaining_capacity`.
     pub fn clone_from_slice(&mut self, slice: &[T]) -> Result<(), usize>
     where
-        T: Clone,
+        T: Clone
     {
         let lim = self.full - self.init;
         let to_clone = if slice.len() < lim { slice.len() } else { lim };
@@ -741,7 +713,7 @@ impl<'a, T, A: Alloc + ?Sized> SliceAllocGuard<'a, T, A> {
                     ptr::write(self.ptr.as_ptr().add(self.init), elem);
                     self.init += 1;
                 },
-                None => return Ok(()),
+                None => return Ok(())
             }
         }
     }
@@ -755,7 +727,7 @@ impl<T, A: Alloc + ?Sized> Drop for SliceAllocGuard<'_, T, A> {
             ptr::drop_in_place(slice_ptr_from_raw_parts(self.ptr.as_ptr(), self.init));
             self.alloc.dealloc(
                 self.ptr.cast(),
-                Layout::from_size_align_unchecked(T::SZ * self.full, T::ALN),
+                Layout::from_size_align_unchecked(T::SZ * self.full, T::ALN)
             );
         }
     }