Vec to use COOP_PREFERRED

Author: peter-lyons-kehl

library/alloc/src/boxed.rs

@@ -1683,8 +1683,12 @@ 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")]
-impl<T, const N: usize> TryFrom<Vec<T>> for Box<[T; N]> {
-    type Error = Vec<T>;
+impl<T, const N: usize, const COOP_PREFERRED: bool> TryFrom<Vec<T, Global, COOP_PREFERRED>>
+    for Box<[T; N]>
+where
+    [(); alloc::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:,
+{
+    type Error = Vec<T, Global, COOP_PREFERRED>;
 
     /// Attempts to convert a `Vec<T>` into a `Box<[T; N]>`.
     ///
@@ -1704,7 +1708,7 @@ impl<T, const N: usize> TryFrom<Vec<T>> for Box<[T; N]> {
     /// let state: Box<[f32; 100]> = vec![1.0; 100].try_into().unwrap();
     /// assert_eq!(state.len(), 100);
     /// ```
-    fn try_from(vec: Vec<T>) -> Result<Self, Self::Error> {
+    fn try_from(vec: Vec<T, Global, COOP_PREFERRED>) -> Result<Self, Self::Error> {
         if vec.len() == N {
             let boxed_slice = vec.into_boxed_slice();
             Ok(unsafe { boxed_slice_as_array_unchecked(boxed_slice) })

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

@@ -1525,15 +1525,15 @@ unsafe impl<T: Ord> TrustedLen for IntoIterSorted<T> {}
 #[derive(Debug)]
 pub struct Drain<'a, T: 'a, const COOP_PREFERRED: bool>
 where
-    [(); alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+    [(); alloc::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:,
 {
     iter: vec::Drain<'a, T, Global, COOP_PREFERRED>,
 }
 
 #[stable(feature = "drain", since = "1.6.0")]
 impl<T, const COOP_PREFERRED: bool> Iterator for Drain<'_, T, COOP_PREFERRED>
 where
-    [(); alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+    [(); alloc::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:,
 {
     type Item = T;
 

library/alloc/src/raw_vec.rs

@@ -69,7 +69,7 @@ pub(crate) struct RawVec<
 
 impl<T, const COOP_PREFERRED: bool> RawVec<T, Global, COOP_PREFERRED>
 where
-    [(); alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+    [(); 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()`.
@@ -527,20 +527,6 @@ where
     }
 }
 
-// @FIXME Custom
-unsafe impl<#[may_dangle] T, const COOP_PREFERRED: bool> Drop for RawVec<T, Global, COOP_PREFERRED>
-where
-    [(); alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
-{
-    /// Frees the memory owned by the `RawVec` *without* trying to drop its contents.
-    fn drop(&mut self) {
-        // @TOFIXMEDO
-        if let Some((ptr, layout)) = self.current_memory() {
-            unsafe { self.alloc.deallocate(ptr, layout) }
-        }
-    }
-}
-
 // Central function for reserve error handling.
 #[cfg(not(no_global_oom_handling))]
 #[inline]

library/alloc/src/rc.rs

@@ -247,6 +247,7 @@ use crate::boxed::Box;
 #[cfg(test)]
 use std::boxed::Box;
 
+use crate::alloc;
 use core::any::Any;
 use core::borrow;
 use core::cell::Cell;
@@ -1987,7 +1988,10 @@ impl<T: ?Sized> From<Box<T>> for Rc<T> {
 
 #[cfg(not(no_global_oom_handling))]
 #[stable(feature = "shared_from_slice", since = "1.21.0")]
-impl<T> From<Vec<T>> for Rc<[T]> {
+impl<T, const COOP_PREFERRED: bool> From<Vec<T, Global, COOP_PREFERRED>> for Rc<[T]>
+where
+    [(); alloc::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:,
+{
     /// Allocate a reference-counted slice and move `v`'s items into it.
     ///
     /// # Example
@@ -1999,7 +2003,10 @@ impl<T> From<Vec<T>> for Rc<[T]> {
     /// assert_eq!(vec![1, 2, 3], *shared);
     /// ```
     #[inline]
-    fn from(mut v: Vec<T>) -> Rc<[T]> {
+    fn from(mut v: Vec<T, Global, COOP_PREFERRED>) -> Rc<[T]>
+    where
+        [(); alloc::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:,
+    {
         unsafe {
             let rc = Rc::copy_from_slice(&v);
             // Allow the Vec to free its memory, but not destroy its contents
@@ -2120,6 +2127,7 @@ trait ToRcSlice<T>: Iterator<Item = T> + Sized {
     fn to_rc_slice(self) -> Rc<[T]>;
 }
 
+// COOP_NOT_POSSIBLE
 #[cfg(not(no_global_oom_handling))]
 impl<T, I: Iterator<Item = T>> ToRcSlice<T> for I {
     default fn to_rc_slice(self) -> Rc<[T]> {

library/alloc/src/slice.rs

@@ -464,10 +464,13 @@ impl<T> [T] {
     #[rustc_allow_incoherent_impl]
     #[inline]
     #[unstable(feature = "allocator_api", issue = "32838")]
-    pub fn to_vec_in<A: Allocator>(&self, alloc: A) -> Vec<T, A>
+    pub fn to_vec_in<A: Allocator, const COOP_PREFERRED: bool>(
+        &self,
+        alloc: A,
+    ) -> Vec<T, A, COOP_PREFERRED>
     where
         T: Clone,
-        [(); core::alloc::co_alloc_metadata_num_slots::<A>()]:,
+        [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
     {
         // N.B., see the `hack` module in this file for more details.
         hack::to_vec(self, alloc)
@@ -490,9 +493,11 @@ impl<T> [T] {
     #[rustc_allow_incoherent_impl]
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
-    pub fn into_vec<A: Allocator>(self: Box<Self, A>) -> Vec<T, A>
+    pub fn into_vec<A: Allocator, const COOP_PREFERRED: bool>(
+        self: Box<Self, A>,
+    ) -> Vec<T, A, COOP_PREFERRED>
     where
-        [(); core::alloc::co_alloc_metadata_num_slots::<A>()]:,
+        [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
     {
         // N.B., see the `hack` module in this file for more details.
         hack::into_vec(self)
@@ -737,6 +742,7 @@ pub trait Join<Separator> {
     fn join(slice: &Self, sep: Separator) -> Self::Output;
 }
 
+// COOP_NOT_POSSIBLE
 #[cfg(not(no_global_oom_handling))]
 #[unstable(feature = "slice_concat_ext", issue = "27747")]
 impl<T: Clone, V: Borrow<[T]>> Concat<T> for [V] {
@@ -752,6 +758,7 @@ impl<T: Clone, V: Borrow<[T]>> Concat<T> for [V] {
     }
 }
 
+// COOP_NOT_POSSIBLE
 #[cfg(not(no_global_oom_handling))]
 #[unstable(feature = "slice_concat_ext", issue = "27747")]
 impl<T: Clone, V: Borrow<[T]>> Join<&T> for [V] {
@@ -775,10 +782,11 @@ impl<T: Clone, V: Borrow<[T]>> Join<&T> for [V] {
     }
 }
 
+// COOP_NOT_POSSIBLE
 #[cfg(not(no_global_oom_handling))]
 #[unstable(feature = "slice_concat_ext", issue = "27747")]
 impl<T: Clone, V: Borrow<[T]>> Join<&[T]> for [V] {
-    type Output = Vec<T>;
+    type Output = Vec<T, Global>;
 
     fn join(slice: &Self, sep: &[T]) -> Vec<T> {
         let mut iter = slice.iter();
@@ -823,6 +831,7 @@ where
     }
 }
 
+// COOP_NOT_POSSIBLE
 #[cfg(not(no_global_oom_handling))]
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: Clone> ToOwned for [T] {

library/alloc/src/str.rs

@@ -14,6 +14,8 @@ use core::ptr;
 use core::str::pattern::{DoubleEndedSearcher, Pattern, ReverseSearcher, Searcher};
 use core::unicode::conversions;
 
+use crate::alloc;
+use crate::alloc::Global;
 use crate::borrow::ToOwned;
 use crate::boxed::Box;
 use crate::slice::{Concat, Join, SliceIndex};
@@ -126,11 +128,15 @@ macro_rules! copy_slice_and_advance {
 // [T] and str both impl AsRef<[T]> for some T
 // => s.borrow().as_ref() and we always have slices
 #[cfg(not(no_global_oom_handling))]
-fn join_generic_copy<B, T, S>(slice: &[S], sep: &[T]) -> Vec<T>
+fn join_generic_copy<B, T, S, const COOP_PREFERRED: bool>(
+    slice: &[S],
+    sep: &[T],
+) -> Vec<T, Global, COOP_PREFERRED>
 where
     T: Copy,
     B: AsRef<[T]> + ?Sized,
     S: Borrow<B>,
+    [(); alloc::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:,
 {
     let sep_len = sep.len();
     let mut iter = slice.iter();

library/alloc/src/vec/mod.rs

@@ -408,6 +408,10 @@ pub struct Vec<
     len: usize,
 }
 
+/// Default `Vec`, `DefVec`, `DecVeque`, `DefDecVeq` "cooperation" (`COOP_PREFERRED`) generic parameter.
+#[unstable(feature = "global_co_alloc_def", issue = "none")]
+pub const DEFAULT_COOP_PREFERRED: bool = true;
+
 #[unstable(feature = "global_co_alloc_covec", issue = "none")]
 pub type CoVec<T, #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global> =
     Vec<T, A, true>;
@@ -417,10 +421,6 @@ pub type CoVec<T, #[unstable(feature = "allocator_api", issue = "32838")] A: All
 pub type PlVec<T, #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global> =
     Vec<T, A, false>;
 
-/// Default `Vec`, `DefVec`, `DecVeque`, `DefDecVeq` "cooperation" (`COOP_PREFERRED`) generic parameter.
-#[unstable(feature = "global_co_alloc_def", issue = "none")]
-pub const DEFAULT_COOP_PREFERRED: bool = true;
-
 /// "Default" Vec. Either "cooperative" or not - as specified by `DEFAULT_COOP_PREFERRED`. The
 /// difference to `Vec` (used without specifying `COOP_PREFERRED`): `DefVec` indicates that the
 /// author considered using `CoVec` or `PlVec`, but left it to default instead.

library/core/src/alloc/mod.rs

@@ -105,6 +105,19 @@ pub const fn co_alloc_metadata_num_slots_with_preference<A: Allocator>(
     if A::IS_CO_ALLOCATOR && coop_preferred { 1 } else { 0 }
 }
 
+#[unstable(feature = "global_co_alloc", issue = "none")]
+/// Param `coop_preferred` - if false, then this returns `0`, regardless of
+/// whether allocator `A` is cooperative.
+pub const fn co_alloc_metadata_num_slots_with_preference_global(_coop_preferred: bool) -> usize {
+    if true {
+        panic!("FIXME");
+    }
+    // @FIXME Move these functions to :alloc instead.
+    // Then:
+    0
+    //if Global::IS_CO_ALLOCATOR && coop_preferred { 1 } else { 0 }
+}
+
 /// An implementation of `Allocator` can allocate, grow, shrink, and deallocate arbitrary blocks of
 /// data described via [`Layout`][].
 ///

library/std/src/sys_common/thread_local_dtor.rs

@@ -12,9 +12,11 @@
 
 #![unstable(feature = "thread_local_internals", issue = "none")]
 #![allow(dead_code)]
+#![feature(global_co_alloc_plvec)]
 
 use crate::ptr;
 use crate::sys_common::thread_local_key::StaticKey;
+use alloc::vec::PlVec;
 
 pub unsafe fn register_dtor_fallback(t: *mut u8, dtor: unsafe extern "C" fn(*mut u8)) {
     // The fallback implementation uses a vanilla OS-based TLS key to track
@@ -28,7 +30,7 @@ pub unsafe fn register_dtor_fallback(t: *mut u8, dtor: unsafe extern "C" fn(*mut
     // flagged for destruction.
 
     static DTORS: StaticKey = StaticKey::new(Some(run_dtors));
-    type List = Vec<(*mut u8, unsafe extern "C" fn(*mut u8))>;
+    type List = PlVec<(*mut u8, unsafe extern "C" fn(*mut u8))>;
     if DTORS.get().is_null() {
         let v: Box<List> = box Vec::new();
         DTORS.set(Box::into_raw(v) as *mut u8);