Vec & VecDeque use cases have COOP_PREFERRED. NOT COMPILABLE.

Author: peter-lyons-kehl

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

@@ -8,7 +8,7 @@
 #![feature(global_co_alloc)]
 
 #![stable(feature = "rust1", since = "1.0.0")]
-use core::alloc;
+use core::alloc::{self, GlobalAlloc};
 use core::cmp::{self, Ordering};
 use core::fmt;
 use core::hash::{Hash, Hasher};
@@ -2756,8 +2756,9 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRE
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> FromIterator<T> for VecDeque<T> {
-    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> VecDeque<T> {
+impl<T, const COOP_PREFERRED: bool> FromIterator<T> for VecDeque<T, GlobalAlloc, COOP_PREFERRED>
+where [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]: {
+    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> VecDeque<T, Global, COOP_PREFERRED> {
         SpecFromIter::spec_from_iter(iter.into_iter())
     }
 }
@@ -2853,7 +2854,8 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRE
     /// conversion. This isn't yet a guarantee though, and
     /// shouldn't be relied on.
     #[inline]
-    fn from(other: Vec<T, A>) -> Self {
+    fn from<const OTHER_COOP_PREFERRED: bool>(other: Vec<T, A, OTHER_COOP_PREFERRED>) -> Self
+    where [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(OTHER_COOP_PREFERRED)]: {
         let (ptr, len, cap, alloc) = other.into_raw_parts_with_alloc();
         Self { head: 0, len, buf: unsafe { RawVec::from_raw_parts_in(ptr, cap, alloc) } }
     }
@@ -2911,7 +2913,8 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRE
 }
 
 #[stable(feature = "std_collections_from_array", since = "1.56.0")]
-impl<T, const N: usize> From<[T; N]> for VecDeque<T> {
+impl<T, const N: usize, const COOP_PREFERRED: bool> From<[T; N]> for VecDeque<T, Global, COOP_PREFERRED>
+where [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]: {
     /// Converts a `[T; N]` into a `VecDeque<T>`.
     ///
     /// ```

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

@@ -1,13 +1,16 @@
 use super::{IntoIter, VecDeque};
+use crate::alloc::Allocator;
+use core::alloc;
 
 /// Specialization trait used for `VecDeque::from_iter`
 pub(super) trait SpecFromIter<T, I> {
     fn spec_from_iter(iter: I) -> Self;
 }
 
-impl<T, I> SpecFromIter<T, I> for VecDeque<T>
+impl<T, I, A: Allocator, const COOP_PREFERRED: bool> SpecFromIter<T, I> for VecDeque<T, A, COOP_PREFERRED>
 where
     I: Iterator<Item = T>,
+    [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:
 {
     default fn spec_from_iter(iterator: I) -> Self {
         // Since converting is O(1) now, just re-use the `Vec` logic for
@@ -18,14 +21,16 @@ where
     }
 }
 
-impl<T> SpecFromIter<T, crate::vec::IntoIter<T>> for VecDeque<T> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> SpecFromIter<T, crate::vec::IntoIter<T>> for VecDeque<T, A, COOP_PREFERRED>
+where [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]: {
     #[inline]
     fn spec_from_iter(iterator: crate::vec::IntoIter<T>) -> Self {
         iterator.into_vecdeque()
     }
 }
 
-impl<T> SpecFromIter<T, IntoIter<T>> for VecDeque<T> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> SpecFromIter<T, IntoIter<T>> for VecDeque<T, A, COOP_PREFERRED>
+where [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]: {
     #[inline]
     fn spec_from_iter(iterator: IntoIter<T>) -> Self {
         iterator.into_vecdeque()

library/alloc/src/raw_vec.rs

@@ -62,7 +62,8 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRE
     pub(crate) metas: [GlobalCoAllocMeta; alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)],
 }
 
-impl<T> RawVec<T, Global> {
+impl<T, const COOP_PREFERRED: bool> RawVec<T, Global, COOP_PREFERRED>
+where [(); alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]: {
     /// HACK(Centril): This exists because stable `const fn` can only call stable `const fn`, so
     /// they cannot call `Self::new()`.
     ///

library/alloc/src/slice.rs

@@ -92,8 +92,8 @@ pub(crate) mod hack {
     // We shouldn't add inline attribute to this since this is used in
     // `vec!` macro mostly and causes perf regression. See #71204 for
     // discussion and perf results.
-    pub fn into_vec<T, A: Allocator>(b: Box<[T], A>) -> Vec<T, A>
-    where [(); core::alloc::co_alloc_metadata_num_slots::<A>()]: {
+    pub fn into_vec<T, A: Allocator, const COOP_PREFERRED: bool>(b: Box<[T], A>) -> Vec<T, A, COOP_PREFERRED>
+    where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]: {
         unsafe {
             let len = b.len();
             let (b, alloc) = Box::into_raw_with_allocator(b);
@@ -103,31 +103,31 @@ pub(crate) mod hack {
 
     #[cfg(not(no_global_oom_handling))]
     #[inline]
-    pub fn to_vec<T: ConvertVec, A: Allocator>(s: &[T], alloc: A) -> Vec<T, A>
-    where [(); core::alloc::co_alloc_metadata_num_slots::<A>()]: {
+    pub fn to_vec<T: ConvertVec, A: Allocator, const COOP_PREFERRED: bool>(s: &[T], alloc: A) -> Vec<T, A, COOP_PREFERRED>
+    where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]: {
         T::to_vec(s, alloc)
     }
 
     #[cfg(not(no_global_oom_handling))]
     pub trait ConvertVec {
-        fn to_vec<A: Allocator>(s: &[Self], alloc: A) -> Vec<Self, A>
+        fn to_vec<A: Allocator, const COOP_PREFERRED: bool>(s: &[Self], alloc: A) -> Vec<Self, A, COOP_PREFERRED>
         where
             Self: Sized,
-            [(); core::alloc::co_alloc_metadata_num_slots::<A>()]:;
+            [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:;
     }
 
     #[cfg(not(no_global_oom_handling))]
     impl<T: Clone> ConvertVec for T {
         #[inline]
-        default fn to_vec<A: Allocator>(s: &[Self], alloc: A) -> Vec<Self, A>
-        where [(); core::alloc::co_alloc_metadata_num_slots::<A>()]: {
-            struct DropGuard<'a, T, A: Allocator>
-            where [(); core::alloc::co_alloc_metadata_num_slots::<A>()]: {
-                vec: &'a mut Vec<T, A>,
+        default fn to_vec<A: Allocator, const COOP_PREFERRED: bool>(s: &[Self], alloc: A) -> Vec<Self, A, COOP_PREFERRED>
+        where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]: {
+            struct DropGuard<'a, T, A: Allocator, const COOP_PREFERRED: bool>
+            where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]: {
+                vec: &'a mut Vec<T, A, COOP_PREFERRED>,
                 num_init: usize,
             }
-            impl<'a, T, A: Allocator> Drop for DropGuard<'a, T, A>
-            where [(); core::alloc::co_alloc_metadata_num_slots::<A>()]: {
+            impl<'a, T, A: Allocator, const COOP_PREFERRED: bool> Drop for DropGuard<'a, T, A, COOP_PREFERRED>
+            where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]: {
                 #[inline]
                 fn drop(&mut self) {
                     // SAFETY:
@@ -159,8 +159,8 @@ pub(crate) mod hack {
     #[cfg(not(no_global_oom_handling))]
     impl<T: Copy> ConvertVec for T {
         #[inline]
-        fn to_vec<A: Allocator>(s: &[Self], alloc: A) -> Vec<Self, A>
-        where [(); core::alloc::co_alloc_metadata_num_slots::<A>()]: {
+        fn to_vec<A: Allocator, const COOP_PREFERRED: bool>(s: &[Self], alloc: A) -> Vec<Self, A, COOP_PREFERRED>
+        where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]: {
             let mut v = Vec::with_capacity_in(s.len(), alloc);
             // SAFETY:
             // allocated above with the capacity of `s`, and initialize to `s.len()` in

library/alloc/src/vec/drain.rs

@@ -32,7 +32,7 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRE
     pub(super) tail_len: usize,
     /// Current remaining range to remove
     pub(super) iter: slice::Iter<'a, T>,
-    pub(super) vec: NonNull<Vec<T, A>>,
+    pub(super) vec: NonNull<Vec<T, A, COOP_PREFERRED>>,
 }
 
 #[stable(feature = "collection_debug", since = "1.17.0")]

library/alloc/src/vec/into_iter.rs

@@ -144,7 +144,7 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRE
 
     #[cfg(not(no_global_oom_handling))]
     #[inline]
-    pub(crate) fn into_vecdeque(self) -> VecDeque<T, A> {
+    pub(crate) fn into_vecdeque(self) -> VecDeque<T, A, COOP_PREFERRED> {
         // Keep our `Drop` impl from dropping the elements and the allocator
         let mut this = ManuallyDrop::new(self);
 

library/alloc/src/vec/mod.rs

@@ -2478,7 +2478,7 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PR
     /// assert_eq!(flattened.pop(), Some(6));
     /// ```
     #[unstable(feature = "slice_flatten", issue = "95629")]
-    pub fn into_flattened(self) -> Vec<T, A> {
+    pub fn into_flattened(self) -> Vec<T, A, COOP_PREFERRED> {
         let (ptr, len, cap, alloc) = self.into_raw_parts_with_alloc();
         let (new_len, new_cap) = if T::IS_ZST {
             (len.checked_mul(N).expect("vec len overflow"), usize::MAX)
@@ -3124,17 +3124,17 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PR
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, A: Allocator, const COOP_PREFERRED: bool> AsRef<Vec<T, A>> for Vec<T, A, COOP_PREFERRED>
+impl<T, A: Allocator, const COOP_PREFERRED: bool> AsRef<Vec<T, A, COOP_PREFERRED>> for Vec<T, A, COOP_PREFERRED>
 where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]: {
-    fn as_ref(&self) -> &Vec<T, A> {
+    fn as_ref(&self) -> &Vec<T, A, COOP_PREFERRED> {
         self
     }
 }
 
 #[stable(feature = "vec_as_mut", since = "1.5.0")]
-impl<T, A: Allocator, const COOP_PREFERRED: bool> AsMut<Vec<T, A>> for Vec<T, A, COOP_PREFERRED>
+impl<T, A: Allocator, const COOP_PREFERRED: bool> AsMut<Vec<T, A, COOP_PREFERRED>> for Vec<T, A, COOP_PREFERRED>
 where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]: {
-    fn as_mut(&mut self) -> &mut Vec<T, A> {
+    fn as_mut(&mut self) -> &mut Vec<T, A, COOP_PREFERRED> {
         self
     }
 }
@@ -3286,7 +3286,7 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PR
     ///
     /// assert_eq!(Box::from(vec), vec![1, 2, 3].into_boxed_slice());
     /// ```
-    fn from(v: Vec<T, A>) -> Self {
+    fn from(v: Vec<T, A, COOP_PREFERRED>) -> Self {
         v.into_boxed_slice()
     }
 }
@@ -3309,7 +3309,7 @@ impl From<&str> for Vec<u8> {
 #[stable(feature = "array_try_from_vec", since = "1.48.0")]
 impl<T, A: Allocator, const N: usize, const COOP_PREFERRED: bool> TryFrom<Vec<T, A, COOP_PREFERRED>> for [T; N]
 where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]: {
-    type Error = Vec<T, A>;
+    type Error = Vec<T, A, COOP_PREFERRED>;
 
     /// Gets the entire contents of the `Vec<T>` as an array,
     /// if its size exactly matches that of the requested array.
@@ -3337,7 +3337,7 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PR
     /// assert_eq!(a, b' ');
     /// assert_eq!(b, b'd');
     /// ```
-    fn try_from(mut vec: Vec<T, A>) -> Result<[T; N], Vec<T, A>> {
+    fn try_from(mut vec: Vec<T, A, COOP_PREFERRED>) -> Result<[T; N], Vec<T, A, COOP_PREFERRED>> {
         if vec.len() != N {
             return Err(vec);
         }

library/alloc/src/vec/spec_extend.rs

@@ -10,28 +10,28 @@ pub(super) trait SpecExtend<T, I> {
     fn spec_extend(&mut self, iter: I);
 }
 
-impl<T, I, A: Allocator> SpecExtend<T, I> for Vec<T, A>
+impl<T, I, A: Allocator, const COOP_PREFERRED: bool> SpecExtend<T, I> for Vec<T, A, COOP_PREFERRED>
 where
     I: Iterator<Item = T>,
-    [(); alloc::co_alloc_metadata_num_slots::<A>()]:
+    [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:
 {
     default fn spec_extend(&mut self, iter: I) {
         self.extend_desugared(iter)
     }
 }
 
-impl<T, I, A: Allocator> SpecExtend<T, I> for Vec<T, A>
+impl<T, I, A: Allocator, const COOP_PREFERRED: bool> SpecExtend<T, I> for Vec<T, A, COOP_PREFERRED>
 where
     I: TrustedLen<Item = T>,
-    [(); alloc::co_alloc_metadata_num_slots::<A>()]:
+    [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:
 {
     default fn spec_extend(&mut self, iterator: I) {
         self.extend_trusted(iterator)
     }
 }
 
-impl<T, A: Allocator> SpecExtend<T, IntoIter<T>> for Vec<T, A>
-where [(); alloc::co_alloc_metadata_num_slots::<A>()]: {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> SpecExtend<T, IntoIter<T>> for Vec<T, A, COOP_PREFERRED>
+where [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]: {
     fn spec_extend(&mut self, mut iterator: IntoIter<T>) {
         unsafe {
             self.append_elements(iterator.as_slice() as _);
@@ -40,21 +40,21 @@ where [(); alloc::co_alloc_metadata_num_slots::<A>()]: {
     }
 }
 
-impl<'a, T: 'a, I, A: Allocator + 'a> SpecExtend<&'a T, I> for Vec<T, A>
+impl<'a, T: 'a, I, A: Allocator + 'a, const COOP_PREFERRED: bool> SpecExtend<&'a T, I> for Vec<T, A, COOP_PREFERRED>
 where
     I: Iterator<Item = &'a T>,
     T: Clone,
-    [(); alloc::co_alloc_metadata_num_slots::<A>()]:
+    [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:
 {
     default fn spec_extend(&mut self, iterator: I) {
         self.spec_extend(iterator.cloned())
     }
 }
 
-impl<'a, T: 'a, A: Allocator + 'a> SpecExtend<&'a T, slice::Iter<'a, T>> for Vec<T, A>
+impl<'a, T: 'a, A: Allocator + 'a, const COOP_PREFERRED: bool> SpecExtend<&'a T, slice::Iter<'a, T>> for Vec<T, A, COOP_PREFERRED>
 where
     T: Copy,
-    [(); alloc::co_alloc_metadata_num_slots::<A>()]:
+    [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:
 {
     fn spec_extend(&mut self, iterator: slice::Iter<'a, T>) {
         let slice = iterator.as_slice();

library/alloc/src/vec/spec_from_elem.rs

@@ -8,13 +8,13 @@ use super::{ExtendElement, IsZero, Vec};
 
 // Specialization trait used for Vec::from_elem
 pub(super) trait SpecFromElem: Sized {
-    fn from_elem<A: Allocator>(elem: Self, n: usize, alloc: A) -> Vec<Self, A>
-    where [(); alloc::co_alloc_metadata_num_slots::<A>()]: ;
+    fn from_elem<A: Allocator, const COOP_PREFERRED: bool>(elem: Self, n: usize, alloc: A) -> Vec<Self, A, COOP_PREFERRED>
+    where [(); alloc::co_alloc_metadata_num_slots::<A>(COOP_PREFERRED)]: ;
 }
 
 impl<T: Clone> SpecFromElem for T {
-    default fn from_elem<A: Allocator>(elem: Self, n: usize, alloc: A) -> Vec<Self, A>
-    where [(); alloc::co_alloc_metadata_num_slots::<A>()]: {
+    default fn from_elem<A: Allocator, const COOP_PREFERRED: bool>(elem: Self, n: usize, alloc: A) -> Vec<Self, A, COOP_PREFERRED>
+    where [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]: {
         let mut v = Vec::with_capacity_in(n, alloc);
         v.extend_with(n, ExtendElement(elem));
         v
@@ -23,8 +23,8 @@ impl<T: Clone> SpecFromElem for T {
 
 impl<T: Clone + IsZero> SpecFromElem for T {
     #[inline]
-    default fn from_elem<A: Allocator>(elem: T, n: usize, alloc: A) -> Vec<T, A>
-    where [(); alloc::co_alloc_metadata_num_slots::<A>()]: {
+    default fn from_elem<A: Allocator, const COOP_PREFERRED: bool>(elem: T, n: usize, alloc: A) -> Vec<T, A, COOP_PREFERRED>
+    where [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]: {
         if elem.is_zero() {
             return Vec { buf: RawVec::with_capacity_zeroed_in(n, alloc), len: n };
         }
@@ -36,8 +36,8 @@ impl<T: Clone + IsZero> SpecFromElem for T {
 
 impl SpecFromElem for i8 {
     #[inline]
-    fn from_elem<A: Allocator>(elem: i8, n: usize, alloc: A) -> Vec<i8, A>
-    where [(); alloc::co_alloc_metadata_num_slots::<A>()]: {
+    fn from_elem<A: Allocator, const COOP_PREFERRED: bool>(elem: i8, n: usize, alloc: A) -> Vec<i8, A, COOP_PREFERRED>
+    where [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]: {
         if elem == 0 {
             return Vec { buf: RawVec::with_capacity_zeroed_in(n, alloc), len: n };
         }
@@ -52,8 +52,8 @@ impl SpecFromElem for i8 {
 
 impl SpecFromElem for u8 {
     #[inline]
-    fn from_elem<A: Allocator>(elem: u8, n: usize, alloc: A) -> Vec<u8, A>
-    where [(); alloc::co_alloc_metadata_num_slots::<A>()]: {
+    fn from_elem<A: Allocator, const COOP_PREFERRED: bool>(elem: u8, n: usize, alloc: A) -> Vec<u8, A, COOP_PREFERRED>
+    where [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]: {
         if elem == 0 {
             return Vec { buf: RawVec::with_capacity_zeroed_in(n, alloc), len: n };
         }