CoAlloc: Removed/split CO_ALLOC_PREF. Fixed tests

Author: peter-lyons-kehl

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

@@ -1,5 +1,6 @@
 use super::*;
 use crate::boxed::Box;
+use crate::{CO_ALLOC_PREF_META_YES, CO_ALLOC_PREF_META_NO};
 use crate::testing::crash_test::{CrashTestDummy, Panic};
 use core::mem;
 use std::iter::TrustedLen;
@@ -448,7 +449,10 @@ fn test_extend_specialization() {
 
 #[allow(dead_code)]
 fn assert_covariance() {
-    fn drain<'new>(d: Drain<'static, &'static str>) -> Drain<'new, &'new str> {
+    fn drain<'new>(d: Drain<'static, &'static str, {CO_ALLOC_PREF_META_NO!()}>) -> Drain<'new, &'new str, {CO_ALLOC_PREF_META_NO!()}> {
+        d
+    }
+    fn drain_co<'new>(d: Drain<'static, &'static str, {CO_ALLOC_PREF_META_YES!()}>) -> Drain<'new, &'new str, {CO_ALLOC_PREF_META_YES!()}> {
         d
     }
 }

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

@@ -2844,11 +2844,21 @@ where
 
 #[stable(feature = "rust1", since = "1.0.0")]
 #[allow(unused_braces)]
-impl<T, const CO_ALLOC_PREF: CoAllocPref> FromIterator<T> for VecDeque<T, Global, CO_ALLOC_PREF>
+impl<T> FromIterator<T> for VecDeque<T>
+{
+    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> VecDeque<T> {
+        SpecFromIterCo::spec_from_iter_co(iter.into_iter())
+    }
+}
+
+#[unstable(feature = "global_co_alloc", issue = "none")]
+#[allow(unused_braces)]
+impl<T, const CO_ALLOC_PREF: CoAllocPref> VecDeque<T, Global, CO_ALLOC_PREF>
 where
     [(); { crate::meta_num_slots_global!(CO_ALLOC_PREF) }]:,
 {
-    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> VecDeque<T, Global, CO_ALLOC_PREF> {
+    /// Like [from_iter], but coallocation-aware.
+    pub fn from_iter_co<I: IntoIterator<Item = T>>(iter: I) -> VecDeque<T, Global, CO_ALLOC_PREF> {
         SpecFromIterCo::spec_from_iter_co(iter.into_iter())
     }
 }

library/alloc/src/raw_vec.rs

@@ -281,6 +281,11 @@ where
         &self.alloc
     }
 
+    #[inline]
+    const fn assert_alignment() {
+        assert!(mem::size_of::<T>() % mem::align_of::<T>() == 0);
+    }
+
     fn current_memory(&self) -> Option<(NonNull<u8>, Layout)> {
         if T::IS_ZST || self.cap == 0 {
             None
@@ -289,7 +294,8 @@ where
             // and could hypothetically handle differences between stride and size, but this memory
             // has already been allocated so we know it can't overflow and currently rust does not
             // support such types. So we can do better by skipping some checks and avoid an unwrap.
-            let _: () = const { assert!(mem::size_of::<T>() % mem::align_of::<T>() == 0) };
+            let _: () = Self::assert_alignment();
+            //let _: () = const { assert!(mem::size_of::<T>() % mem::align_of::<T>() == 0) };
             unsafe {
                 let align = mem::align_of::<T>();
                 let size = mem::size_of::<T>().unchecked_mul(self.cap);
@@ -483,7 +489,8 @@ where
 
         let (ptr, layout) = if let Some(mem) = self.current_memory() { mem } else { return Ok(()) };
         // See current_memory() why this assert is here
-        let _: () = const { assert!(mem::size_of::<T>() % mem::align_of::<T>() == 0) };
+        let _: () = Self::assert_alignment();
+        //let _: () = const { assert!(mem::size_of::<T>() % mem::align_of::<T>() == 0) };
         let ptr = unsafe {
             // `Layout::array` cannot overflow here because it would have
             // overflowed earlier when capacity was larger.

library/alloc/src/slice.rs

@@ -103,7 +103,17 @@ pub(crate) mod hack {
     // `vec!` macro mostly and causes perf regression. See #71204 for
     // discussion and perf results.
     #[allow(unused_braces)]
-    pub fn into_vec<T, A: Allocator, const CO_ALLOC_PREF: CoAllocPref>(
+    pub fn into_vec<T, A: Allocator>(
+        b: Box<[T], A>,
+    ) -> Vec<T, A>
+    where
+        [(); { crate::meta_num_slots_default!(A) }]:,
+    {
+        into_vec_co::<T, A, {crate::CO_ALLOC_PREF_META_DEFAULT!()}>(b)
+    }
+
+    #[allow(unused_braces)]
+    pub fn into_vec_co<T, A: Allocator, const CO_ALLOC_PREF: CoAllocPref>(
         b: Box<[T], A>,
     ) -> Vec<T, A, CO_ALLOC_PREF>
     where
@@ -648,7 +658,7 @@ impl<T> [T] {
         [(); { crate::meta_num_slots!(A, CO_ALLOC_PREF) }]:,
     {
         // N.B., see the `hack` module in this file for more details.
-        hack::into_vec(self)
+        hack::into_vec_co(self)
     }
 
     /// Creates a vector by copying a slice `n` times.

library/alloc/src/vec/into_iter.rs

@@ -465,7 +465,7 @@ where
     }
     #[cfg(test)]
     fn clone(&self) -> Self {
-        crate::slice::to_vec(self.as_slice(), self.alloc.deref().clone()).into_iter()
+        crate::slice::to_vec_co(self.as_slice(), self.alloc.deref().clone()).into_iter()
     }
 }
 

library/alloc/src/vec/mod.rs

@@ -2864,7 +2864,7 @@ where
     #[cfg(test)]
     fn clone(&self) -> Self {
         let alloc = self.allocator().clone();
-        crate::slice::to_vec(&**self, alloc)
+        crate::slice::to_vec_co(&**self, alloc)
     }
 
     fn clone_from(&mut self, other: &Self) {

library/alloc/tests/autotraits.rs

@@ -1,3 +1,5 @@
+use alloc::{CO_ALLOC_PREF_META_YES, CO_ALLOC_PREF_META_NO};
+
 fn require_sync<T: Sync>(_: T) {}
 fn require_send_sync<T: Send + Sync>(_: T) {}
 
@@ -192,7 +194,12 @@ fn test_binary_heap() {
     });
 
     require_send_sync(async {
-        let _v = None::<alloc::collections::binary_heap::Drain<'_, &u32>>;
+        let _v = None::<alloc::collections::binary_heap::Drain<'_, &u32, {CO_ALLOC_PREF_META_NO!()}>>;
+        async {}.await;
+    });
+
+    require_send_sync(async {
+        let _v = None::<alloc::collections::binary_heap::Drain<'_, &u32, {CO_ALLOC_PREF_META_YES!()}>>;
         async {}.await;
     });
 

library/alloc/tests/lib.rs

@@ -2,6 +2,7 @@
 #![feature(alloc_layout_extra)]
 #![feature(assert_matches)]
 #![feature(btree_drain_filter)]
+#![feature(global_co_alloc_meta)]
 #![feature(cow_is_borrowed)]
 #![feature(const_box)]
 #![feature(const_convert)]