CoAlloc: tidy

Author: peter-lyons-kehl

library/alloc/src/boxed.rs

@@ -146,6 +146,7 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
+use crate::co_alloc::CoAllocPref;
 use core::any::Any;
 use core::async_iter::AsyncIterator;
 use core::borrow;
@@ -167,7 +168,6 @@ use core::ops::{
 use core::pin::Pin;
 use core::ptr::{self, Unique};
 use core::task::{Context, Poll};
-use crate::co_alloc::CoAllocPref;
 
 #[cfg(not(no_global_oom_handling))]
 use crate::alloc::{handle_alloc_error, WriteCloneIntoRaw};
@@ -643,7 +643,9 @@ impl<T> Box<[T]> {
     #[must_use]
     pub fn new_uninit_slice(len: usize) -> Box<[mem::MaybeUninit<T>]> {
         // false = no need for co-alloc metadata, since it would get lost once converted to Box.
-        unsafe { RawVec::<T, Global, {CO_ALLOC_PREF_META_NO!()}>::with_capacity(len).into_box(len) }
+        unsafe {
+            RawVec::<T, Global, { CO_ALLOC_PREF_META_NO!() }>::with_capacity(len).into_box(len)
+        }
     }
 
     /// Constructs a new boxed slice with uninitialized contents, with the memory
@@ -669,7 +671,10 @@ impl<T> Box<[T]> {
     #[must_use]
     pub fn new_zeroed_slice(len: usize) -> Box<[mem::MaybeUninit<T>]> {
         // false = no need for co-alloc metadata, since it would get lost once converted to Box.
-        unsafe { RawVec::<T, Global, {CO_ALLOC_PREF_META_NO!()}>::with_capacity_zeroed(len).into_box(len) }
+        unsafe {
+            RawVec::<T, Global, { CO_ALLOC_PREF_META_NO!() }>::with_capacity_zeroed(len)
+                .into_box(len)
+        }
     }
 
     /// Constructs a new boxed slice with uninitialized contents. Returns an error if
@@ -701,7 +706,7 @@ impl<T> Box<[T]> {
                 Err(_) => return Err(AllocError),
             };
             let ptr = Global.allocate(layout)?;
-            Ok(RawVec::<T, Global, {CO_ALLOC_PREF_META_NO!()}>::from_raw_parts_in(
+            Ok(RawVec::<T, Global, { CO_ALLOC_PREF_META_NO!() }>::from_raw_parts_in(
                 ptr.as_mut_ptr() as *mut _,
                 len,
                 Global,
@@ -738,7 +743,7 @@ impl<T> Box<[T]> {
                 Err(_) => return Err(AllocError),
             };
             let ptr = Global.allocate_zeroed(layout)?;
-            Ok(RawVec::<T, Global, {CO_ALLOC_PREF_META_NO!()}>::from_raw_parts_in(
+            Ok(RawVec::<T, Global, { CO_ALLOC_PREF_META_NO!() }>::from_raw_parts_in(
                 ptr.as_mut_ptr() as *mut _,
                 len,
                 Global,
@@ -751,7 +756,7 @@ impl<T> Box<[T]> {
 #[allow(unused_braces)]
 impl<T, A: Allocator> Box<[T], A>
 where
-    [(); {crate::meta_num_slots!(A, crate::CO_ALLOC_PREF_META_NO!())}]:,
+    [(); { crate::meta_num_slots!(A, crate::CO_ALLOC_PREF_META_NO!()) }]:,
 {
     /// Constructs a new boxed slice with uninitialized contents in the provided allocator.
     ///
@@ -781,7 +786,9 @@ where
     #[must_use]
     #[allow(unused_braces)]
     pub fn new_uninit_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit<T>], A> {
-        unsafe { RawVec::<T, A, {CO_ALLOC_PREF_META_NO!()}>::with_capacity_in(len, alloc).into_box(len) }
+        unsafe {
+            RawVec::<T, A, { CO_ALLOC_PREF_META_NO!() }>::with_capacity_in(len, alloc).into_box(len)
+        }
     }
 
     /// Constructs a new boxed slice with uninitialized contents in the provided allocator,
@@ -810,7 +817,10 @@ where
     #[must_use]
     #[allow(unused_braces)]
     pub fn new_zeroed_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit<T>], A> {
-        unsafe { RawVec::<T, A, {CO_ALLOC_PREF_META_NO!()}>::with_capacity_zeroed_in(len, alloc).into_box(len) }
+        unsafe {
+            RawVec::<T, A, { CO_ALLOC_PREF_META_NO!() }>::with_capacity_zeroed_in(len, alloc)
+                .into_box(len)
+        }
     }
 }
 
@@ -1516,7 +1526,7 @@ impl<T: Copy> From<&[T]> for Box<[T]> {
     fn from(slice: &[T]) -> Box<[T]> {
         let len = slice.len();
         // false = no need for co-alloc metadata, since it would get lost once converted to Box.
-        let buf = RawVec::<T, Global, {CO_ALLOC_PREF_META_NO!()}>::with_capacity(len);
+        let buf = RawVec::<T, Global, { CO_ALLOC_PREF_META_NO!() }>::with_capacity(len);
         unsafe {
             ptr::copy_nonoverlapping(slice.as_ptr(), buf.ptr(), len);
             buf.into_box(slice.len()).assume_init()
@@ -1682,9 +1692,10 @@ impl<T, const N: usize> TryFrom<Box<[T]>> for Box<[T; N]> {
 #[cfg(not(no_global_oom_handling))]
 #[stable(feature = "boxed_array_try_from_vec", since = "1.66.0")]
 #[allow(unused_braces)]
-impl<T, const N: usize, const CO_ALLOC_PREF: CoAllocPref> TryFrom<Vec<T, Global, CO_ALLOC_PREF>> for Box<[T; N]>
+impl<T, const N: usize, const CO_ALLOC_PREF: CoAllocPref> TryFrom<Vec<T, Global, CO_ALLOC_PREF>>
+    for Box<[T; N]>
 where
-    [(); {meta_num_slots_global!(CO_ALLOC_PREF)}]:,
+    [(); { meta_num_slots_global!(CO_ALLOC_PREF) }]:,
 {
     type Error = Vec<T, Global, CO_ALLOC_PREF>;
 
@@ -2046,12 +2057,12 @@ impl<I> FromIterator<I> for Box<[I]> {
 #[allow(unused_braces)]
 impl<T: Clone, A: Allocator + Clone> Clone for Box<[T], A>
 where
-    [(); {crate::meta_num_slots!(A, crate::CO_ALLOC_PREF_META_NO!())}]:,
+    [(); { crate::meta_num_slots!(A, crate::CO_ALLOC_PREF_META_NO!()) }]:,
 {
     fn clone(&self) -> Self {
         let alloc = Box::allocator(self).clone();
         // false = no need for co-alloc metadata, since it would get lost once converted to the boxed slice.
-        self.to_vec_in_co::<A, {CO_ALLOC_PREF_META_NO!()}>(alloc).into_boxed_slice()
+        self.to_vec_in_co::<A, { CO_ALLOC_PREF_META_NO!() }>(alloc).into_boxed_slice()
     }
 
     fn clone_from(&mut self, other: &Self) {

library/alloc/src/co_alloc.rs

@@ -1,9 +1,9 @@
 //! CoAlloction-specific types that only apply in heap-based applications (hence not a part of
 //!  [::core]).
-//! 
+//!
 //! Types here have names with `CoAlloc` prefix. Yes, when using a q ualified path (like
 //! ::alloc::co_alloc::CoAllocPref), that involves "stuttering", which is not recommended.
-//! 
+//!
 //! However, as per Rust Book the common practice is to import type names fully and access them just
 //! with their name (except for cases of conflict). And we don't want the type names any shorter
 //! (such `Pref`), because thoe would be vague/confusing.
@@ -44,4 +44,4 @@ pub type CoAllocPref = u8;
 /// vales, or in place of a result of `meta_num_slots` macro. That also prevents mixing up with
 /// [core::alloc::CoAllocatorMetaNumSlots].
 #[unstable(feature = "global_co_alloc_meta", issue = "none")]
-pub type CoAllocMetaNumSlotsPref = u16;
+pub type CoAllocMetaNumSlotsPref = u16;

library/alloc/src/collections/binary_heap/mod.rs

@@ -143,9 +143,9 @@
 #![allow(missing_docs)]
 #![stable(feature = "rust1", since = "1.0.0")]
 
+use crate::co_alloc::CoAllocPref;
 use core::fmt;
 use core::iter::{FromIterator, FusedIterator, InPlaceIterable, SourceIter, TrustedLen};
-use crate::co_alloc::CoAllocPref;
 use core::mem::{self, swap, ManuallyDrop};
 use core::num::NonZeroUsize;
 use core::ops::{Deref, DerefMut};
@@ -1529,7 +1529,7 @@ unsafe impl<T: Ord> TrustedLen for IntoIterSorted<T> {}
 #[allow(unused_braces)]
 pub struct Drain<'a, T: 'a, const CO_ALLOC_PREF: CoAllocPref>
 where
-    [(); {meta_num_slots_global!(CO_ALLOC_PREF)}]:,
+    [(); { meta_num_slots_global!(CO_ALLOC_PREF) }]:,
 {
     iter: vec::Drain<'a, T, Global, CO_ALLOC_PREF>,
 }
@@ -1538,7 +1538,7 @@ where
 #[allow(unused_braces)]
 impl<T, const CO_ALLOC_PREF: CoAllocPref> Iterator for Drain<'_, T, CO_ALLOC_PREF>
 where
-    [(); {meta_num_slots_global!(CO_ALLOC_PREF)}]:,
+    [(); { meta_num_slots_global!(CO_ALLOC_PREF) }]:,
 {
     type Item = T;
 
@@ -1557,7 +1557,7 @@ where
 #[allow(unused_braces)]
 impl<T, const CO_ALLOC_PREF: CoAllocPref> DoubleEndedIterator for Drain<'_, T, CO_ALLOC_PREF>
 where
-    [(); {meta_num_slots_global!(CO_ALLOC_PREF)}]:,
+    [(); { meta_num_slots_global!(CO_ALLOC_PREF) }]:,
 {
     #[inline]
     fn next_back(&mut self) -> Option<T> {
@@ -1569,7 +1569,7 @@ where
 #[allow(unused_braces)]
 impl<T, const CO_ALLOC_PREF: CoAllocPref> ExactSizeIterator for Drain<'_, T, CO_ALLOC_PREF>
 where
-    [(); {meta_num_slots_global!(CO_ALLOC_PREF)}]:,
+    [(); { meta_num_slots_global!(CO_ALLOC_PREF) }]:,
 {
     fn is_empty(&self) -> bool {
         self.iter.is_empty()
@@ -1579,7 +1579,7 @@ where
 #[stable(feature = "fused", since = "1.26.0")]
 #[allow(unused_braces)]
 impl<T, const CO_ALLOC_PREF: CoAllocPref> FusedIterator for Drain<'_, T, CO_ALLOC_PREF> where
-    [(); {meta_num_slots_global!(CO_ALLOC_PREF)}]:
+    [(); { meta_num_slots_global!(CO_ALLOC_PREF) }]:
 {
 }
 

library/alloc/src/collections/vec_deque/drain.rs

@@ -1,5 +1,5 @@
-use core::iter::FusedIterator;
 use crate::co_alloc::CoAllocPref;
+use core::iter::FusedIterator;
 use core::marker::PhantomData;
 use core::mem::{self, SizedTypeProperties};
 use core::ptr::NonNull;
@@ -23,10 +23,8 @@ pub struct Drain<
     #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
     const CO_ALLOC_PREF: CoAllocPref = { SHORT_TERM_VEC_CO_ALLOC_PREF!() },
 > where
-    [(); {crate::meta_num_slots!(A, CO_ALLOC_PREF)}]:,
+    [(); { crate::meta_num_slots!(A, CO_ALLOC_PREF) }]:,
 {
-    // We can't just use a &mut VecDeque<T, A>, as that would make Drain invariant over T
-    // and we want it to be covariant instead
     deque: NonNull<VecDeque<T, A, CO_ALLOC_PREF>>,
     // drain_start is stored in deque.len
     drain_len: usize,
@@ -42,7 +40,7 @@ pub struct Drain<
 #[allow(unused_braces)]
 impl<'a, T, A: Allocator, const CO_ALLOC_PREF: CoAllocPref> Drain<'a, T, A, CO_ALLOC_PREF>
 where
-    [(); {crate::meta_num_slots!(A, CO_ALLOC_PREF)}]:,
+    [(); { crate::meta_num_slots!(A, CO_ALLOC_PREF) }]:,
 {
     pub(super) unsafe fn new(
         deque: &'a mut VecDeque<T, A, CO_ALLOC_PREF>,
@@ -98,9 +96,10 @@ where
 
 #[stable(feature = "collection_debug", since = "1.17.0")]
 #[allow(unused_braces)]
-impl<T: fmt::Debug, A: Allocator, const CO_ALLOC_PREF: CoAllocPref> fmt::Debug for Drain<'_, T, A, CO_ALLOC_PREF>
+impl<T: fmt::Debug, A: Allocator, const CO_ALLOC_PREF: CoAllocPref> fmt::Debug
+    for Drain<'_, T, A, CO_ALLOC_PREF>
 where
-    [(); {crate::meta_num_slots!(A, CO_ALLOC_PREF)}]:,
+    [(); { crate::meta_num_slots!(A, CO_ALLOC_PREF) }]:,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_tuple("Drain")
@@ -114,33 +113,38 @@ where
 
 #[stable(feature = "drain", since = "1.6.0")]
 #[allow(unused_braces)]
-unsafe impl<T: Sync, A: Allocator + Sync, const CO_ALLOC_PREF: CoAllocPref> Sync for Drain<'_, T, A, CO_ALLOC_PREF> where
-    [(); {crate::meta_num_slots!(A, CO_ALLOC_PREF)}]:
+unsafe impl<T: Sync, A: Allocator + Sync, const CO_ALLOC_PREF: CoAllocPref> Sync
+    for Drain<'_, T, A, CO_ALLOC_PREF>
+where
+    [(); { crate::meta_num_slots!(A, CO_ALLOC_PREF) }]:,
 {
 }
 #[stable(feature = "drain", since = "1.6.0")]
 #[allow(unused_braces)]
-unsafe impl<T: Send, A: Allocator + Send, const CO_ALLOC_PREF: CoAllocPref> Send for Drain<'_, T, A, CO_ALLOC_PREF> where
-    [(); {crate::meta_num_slots!(A, CO_ALLOC_PREF)}]:
+unsafe impl<T: Send, A: Allocator + Send, const CO_ALLOC_PREF: CoAllocPref> Send
+    for Drain<'_, T, A, CO_ALLOC_PREF>
+where
+    [(); { crate::meta_num_slots!(A, CO_ALLOC_PREF) }]:,
 {
 }
 
 #[stable(feature = "drain", since = "1.6.0")]
 #[allow(unused_braces)]
 impl<T, A: Allocator, const CO_ALLOC_PREF: CoAllocPref> Drop for Drain<'_, T, A, CO_ALLOC_PREF>
 where
-    [(); {crate::meta_num_slots!(A, CO_ALLOC_PREF)}]:,
+    [(); { crate::meta_num_slots!(A, CO_ALLOC_PREF) }]:,
 {
     fn drop(&mut self) {
         struct DropGuard<'r, 'a, T, A: Allocator, const CO_ALLOC_PREF: CoAllocPref>(
             &'r mut Drain<'a, T, A, CO_ALLOC_PREF>,
         )
         where
-            [(); {crate::meta_num_slots!(A, CO_ALLOC_PREF)}]:;
+            [(); { crate::meta_num_slots!(A, CO_ALLOC_PREF) }]:;
 
-        impl<'r, 'a, T, A: Allocator, const CO_ALLOC_PREF: CoAllocPref> Drop for DropGuard<'r, 'a, T, A, CO_ALLOC_PREF>
+        impl<'r, 'a, T, A: Allocator, const CO_ALLOC_PREF: CoAllocPref> Drop
+            for DropGuard<'r, 'a, T, A, CO_ALLOC_PREF>
         where
-            [(); {crate::meta_num_slots!(A, CO_ALLOC_PREF)}]:,
+            [(); { crate::meta_num_slots!(A, CO_ALLOC_PREF) }]:,
         {
             fn drop(&mut self) {
                 if self.0.remaining != 0 {
@@ -225,7 +229,7 @@ where
 #[allow(unused_braces)]
 impl<T, A: Allocator, const CO_ALLOC_PREF: CoAllocPref> Iterator for Drain<'_, T, A, CO_ALLOC_PREF>
 where
-    [(); {crate::meta_num_slots!(A, CO_ALLOC_PREF)}]:,
+    [(); { crate::meta_num_slots!(A, CO_ALLOC_PREF) }]:,
 {
     type Item = T;
 
@@ -249,9 +253,10 @@ where
 
 #[stable(feature = "drain", since = "1.6.0")]
 #[allow(unused_braces)]
-impl<T, A: Allocator, const CO_ALLOC_PREF: CoAllocPref> DoubleEndedIterator for Drain<'_, T, A, CO_ALLOC_PREF>
+impl<T, A: Allocator, const CO_ALLOC_PREF: CoAllocPref> DoubleEndedIterator
+    for Drain<'_, T, A, CO_ALLOC_PREF>
 where
-    [(); {crate::meta_num_slots!(A, CO_ALLOC_PREF)}]:,
+    [(); { crate::meta_num_slots!(A, CO_ALLOC_PREF) }]:,
 {
     #[inline]
     fn next_back(&mut self) -> Option<T> {
@@ -266,14 +271,18 @@ where
 
 #[stable(feature = "drain", since = "1.6.0")]
 #[allow(unused_braces)]
-impl<T, A: Allocator, const CO_ALLOC_PREF: CoAllocPref> ExactSizeIterator for Drain<'_, T, A, CO_ALLOC_PREF> where
-    [(); {crate::meta_num_slots!(A, CO_ALLOC_PREF)}]:
+impl<T, A: Allocator, const CO_ALLOC_PREF: CoAllocPref> ExactSizeIterator
+    for Drain<'_, T, A, CO_ALLOC_PREF>
+where
+    [(); { crate::meta_num_slots!(A, CO_ALLOC_PREF) }]:,
 {
 }
 
 #[stable(feature = "fused", since = "1.26.0")]
 #[allow(unused_braces)]
-impl<T, A: Allocator, const CO_ALLOC_PREF: CoAllocPref> FusedIterator for Drain<'_, T, A, CO_ALLOC_PREF> where
-    [(); {crate::meta_num_slots!(A, CO_ALLOC_PREF)}]:
+impl<T, A: Allocator, const CO_ALLOC_PREF: CoAllocPref> FusedIterator
+    for Drain<'_, T, A, CO_ALLOC_PREF>
+where
+    [(); { crate::meta_num_slots!(A, CO_ALLOC_PREF) }]:,
 {
 }