CoAlloc: tidy

Author: peter-lyons-kehl

library/alloc/src/macros.rs

@@ -129,18 +129,19 @@ macro_rules! __rust_force_expr {
 /// This "validates" type of a given `const` expression, and it casts it. That helps to prevent mix ups with macros/integer constant values.
 #[doc(hidden)]
 #[macro_export]
-#[unstable(feature = "global_co_alloc_meta", issue = "none")]macro_rules! check_type_and_cast {
+#[unstable(feature = "global_co_alloc_meta", issue = "none")]
+macro_rules! check_type_and_cast {
     // Use the following for compile-time/build check only. And use it
     // with a hard-coded `0` version of `meta_num_slots` - otherwise you get an ICE.
-    // 
+    //
     /*($e:expr, $t_check:ty, $t_cast:ty) => {
         ($e + 0 as $t_check) as $t_cast
     }*/
     // Use the following to build for testing/using, while rustc causes an ICE with the above and
     // with a full version of `meta_num_slots`.
     ($e:expr, $t_check:ty, $t_cast:ty) => {
         $e
-    }
+    };
 }
 
 // ----- CoAlloc constant-like macros:
@@ -265,8 +266,11 @@ macro_rules! co_alloc_pref {
     // report the incorrect type of $meta_pref (if $meta_pref were some other integer, casting would
     // compile, and we would not be notified).
     ($meta_pref:expr) => {
-        $crate::check_type_and_cast!($meta_pref,$crate::co_alloc::CoAllocMetaNumSlotsPref,
-            $crate::co_alloc::CoAllocPref)
+        $crate::check_type_and_cast!(
+            $meta_pref,
+            $crate::co_alloc::CoAllocMetaNumSlotsPref,
+            $crate::co_alloc::CoAllocPref
+        )
     };
 }
 
@@ -363,17 +367,3 @@ macro_rules! meta_num_slots_global {
         //<$crate::alloc::Global as ::core::alloc::Allocator>::CO_ALLOC_META_NUM_SLOTS
     };
 }
-/*
-/// Like `meta_num_slots`, but for `Global allocator and default coallocation preference
-/// (`CO_ALLOC_PREF_DEFAULT`).
-///
-// @FIXME once generic_const_exprs is stable, replace this with a `const` function. Then consider
-// moving the function to a submodule, for example alloc::co_alloc. See above.
-#[unstable(feature = "global_co_alloc", issue = "none")]
-#[macro_export]
-macro_rules! meta_num_slots_default_global {
-    () => {
-        $crate::meta_num_slots!($crate::alloc::Global, $crate::CO_ALLOC_PREF_DEFAULT!())
-    };
-}
-*/

library/alloc/src/slice.rs

@@ -629,7 +629,8 @@ impl<T> [T] {
     #[inline]
     #[allow(unused_braces)]
     pub fn into_vec<A: Allocator>(self: Box<Self, A>) -> Vec<T, A>
-    where [(); { crate::meta_num_slots_default!(A) }]:
+    where
+        [(); { crate::meta_num_slots_default!(A) }]:,
     {
         // N.B., see the `hack` module in this file for more details.
         hack::into_vec(self)
@@ -986,15 +987,17 @@ where
 #[cfg(not(no_global_oom_handling))]
 #[allow(unused_braces)]
 pub(crate) trait SpecCloneIntoVec<T, A: Allocator>
-where [(); { crate::meta_num_slots_default!(A) }]:
+where
+    [(); { crate::meta_num_slots_default!(A) }]:,
 {
     fn clone_into(&self, target: &mut Vec<T, A>);
 }
 
 #[cfg(not(no_global_oom_handling))]
 #[allow(unused_braces)]
 impl<T: Clone, A: Allocator> SpecCloneIntoVec<T, A> for [T]
-where [(); { crate::meta_num_slots_default!(A) }]:
+where
+    [(); { crate::meta_num_slots_default!(A) }]:,
 {
     default fn clone_into(&self, target: &mut Vec<T, A>) {
         // drop anything in target that will not be overwritten
@@ -1013,7 +1016,8 @@ where [(); { crate::meta_num_slots_default!(A) }]:
 #[cfg(not(no_global_oom_handling))]
 #[allow(unused_braces)]
 impl<T: Copy, A: Allocator> SpecCloneIntoVec<T, A> for [T]
-where [(); { crate::meta_num_slots_default!(A) }]:
+where
+    [(); { crate::meta_num_slots_default!(A) }]:,
 {
     fn clone_into(&self, target: &mut Vec<T, A>) {
         target.clear();

library/alloc/src/vec/mod.rs

@@ -1880,6 +1880,8 @@ where
         where
             [(); { crate::meta_num_slots!(A, CO_ALLOC_PREF) }]:,
         {
+            crate::meta_num_slots!(A, CO_ALLOC_PREF) }]:,
+            {
             /* Offset of the element we want to check if it is duplicate */
             read: usize,
 
@@ -3494,7 +3496,7 @@ where
 // @FIXME unsure about test
 #[cfg(not(test))]
 #[allow(ineffective_unstable_trait_impl)] //@FIXME What/why is #[unstable(...)] ignored here?
-#[unstable(feature = "global_co_alloc", issue="none")]
+#[unstable(feature = "global_co_alloc", issue = "none")]
 #[allow(unused_braces)]
 impl<T, A: Allocator, const CO_ALLOC_PREF: CoAllocPref> From<Box<[T], A>>
     for Vec<T, A, CO_ALLOC_PREF>
@@ -3509,8 +3511,7 @@ where
 #[cfg(not(test))]
 #[stable(feature = "vec_from_box", since = "1.18.0")]
 #[allow(unused_braces)]
-impl<T, A: Allocator> From<Box<[T], A>>
-    for Vec<T, A, {CO_ALLOC_PREF_DEFAULT!()}>
+impl<T, A: Allocator> From<Box<[T], A>> for Vec<T, A, { CO_ALLOC_PREF_DEFAULT!() }>
 where
     [(); { crate::meta_num_slots_default!(A) }]:,
 {
@@ -3532,7 +3533,7 @@ where
 // @FIXME Can this apply to test?
 #[cfg(not(test))]
 #[allow(ineffective_unstable_trait_impl)] //@FIXME What/why is #[unstable(...)] ignored here?
-#[unstable(feature = "global_co_alloc", issue="none")]
+#[unstable(feature = "global_co_alloc", issue = "none")]
 #[allow(unused_braces)]
 impl<T, A: Allocator, const CO_ALLOC_PREF: CoAllocPref> From<Vec<T, A, CO_ALLOC_PREF>>
     for Box<[T], A>
@@ -3548,8 +3549,7 @@ where
 #[cfg(not(test))]
 #[stable(feature = "box_from_vec", since = "1.20.0")]
 #[allow(unused_braces)]
-impl<T, A: Allocator> From<Vec<T, A>>
-    for Box<[T], A>
+impl<T, A: Allocator> From<Vec<T, A>> for Box<[T], A>
 where
     [(); { crate::meta_num_slots_default!(A) }]:,
 {