Fixing A and COOP_PREFERRED generics. WIP.

Author: peter-lyons-kehl

library/alloc/src/boxed.rs

@@ -778,7 +778,10 @@ where
     // #[unstable(feature = "new_uninit", issue = "63291")]
     #[must_use]
     #[allow(unused_braces)]
-    pub fn new_uninit_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit<T>], A> {
+    pub fn new_uninit_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit<T>], A>
+    where
+    [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(SHORT_TERM_VEC_PREFERS_COOP!())]:,
+    {
         unsafe {
             RawVec::<T, A, { SHORT_TERM_VEC_PREFERS_COOP!() }>::with_capacity_in(len, alloc)
                 .into_box(len)
@@ -810,7 +813,10 @@ where
     // #[unstable(feature = "new_uninit", issue = "63291")]
     #[must_use]
     #[allow(unused_braces)]
-    pub fn new_zeroed_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit<T>], A> {
+    pub fn new_zeroed_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit<T>], A>
+    where
+    [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(SHORT_TERM_VEC_PREFERS_COOP!())]:,
+    {
         unsafe {
             RawVec::<T, A, { SHORT_TERM_VEC_PREFERS_COOP!() }>::with_capacity_zeroed_in(
                 len, alloc,
@@ -1521,7 +1527,8 @@ impl<T: Copy> From<&[T]> for Box<[T]> {
     /// ```
     fn from(slice: &[T]) -> Box<[T]> {
         let len = slice.len();
-        let buf = RawVec::with_capacity(len);
+        // false = no need for co-alloc metadata, since it would get lost once converted to Box.
+        let buf = RawVec::<T, Global, false>::with_capacity(len);
         unsafe {
             ptr::copy_nonoverlapping(slice.as_ptr(), buf.ptr(), len);
             buf.into_box(slice.len()).assume_init()
@@ -2050,11 +2057,12 @@ impl<I> FromIterator<I> for Box<[I]> {
 #[stable(feature = "box_slice_clone", since = "1.3.0")]
 impl<T: Clone, A: Allocator + Clone> Clone for Box<[T], A>
 where
-    [(); core::alloc::co_alloc_metadata_num_slots::<A>()]:,
+    [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(false)]:,
 {
     fn clone(&self) -> Self {
         let alloc = Box::allocator(self).clone();
-        self.to_vec_in(alloc).into_boxed_slice()
+        // false = no need for co-alloc metadata, since it would get lost once converted to the boxed slice.
+        self.to_vec_in::<A, false>(alloc).into_boxed_slice()
     }
 
     fn clone_from(&mut self, other: &Self) {

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

@@ -18,7 +18,7 @@ where
         // anything where we can't do something extra-special for `VecDeque`,
         // especially as that could save us some monomorphiziation work
         // if one uses the same iterators (like slice ones) with both.
-        crate::vec::Vec::from_iter(iterator).into()
+        crate::vec::Vec::<T, A, COOP_PREFERRED>::from_iter(iterator).into()
     }
 }
 

library/alloc/src/vec/in_place_drop.rs

@@ -1,5 +1,6 @@
 use core::ptr::{self};
 use core::slice::{self};
+use crate::alloc::Global;
 
 // A helper struct for in-place iteration that drops the destination slice of iteration,
 // i.e. the head. The source slice (the tail) is dropped by IntoIter.

library/alloc/src/vec/mod.rs

@@ -54,6 +54,7 @@
 #![stable(feature = "rust1", since = "1.0.0")]
 
 #[cfg(not(no_global_oom_handling))]
+use core::alloc;
 use core::cmp;
 use core::cmp::Ordering;
 use core::convert::TryFrom;
@@ -2877,9 +2878,12 @@ where
 #[cfg(not(no_global_oom_handling))]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[allow(unused_braces)]
-impl<T> FromIterator<T> for Vec<T, Global, {DEFAULT_COOP_PREFERRED!()}> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> FromIterator<T> for Vec<T, A, COOP_PREFERRED>
+where
+    [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+ {
     #[inline]
-    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Vec<T> {
+    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Vec<T, A, COOP_PREFERRED> {
         <Self as SpecFromIter<T, I::IntoIter>>::from_iter(iter.into_iter())
     }
 }