CoAlloc: Vec, related + vec! macro: Separated co-alloc-aware functions to have unique names, so we have no conflicts, but source code backward-compatibility.

Author: peter-lyons-kehl

library/alloc/src/macros.rs

@@ -41,7 +41,7 @@
 #[allow_internal_unstable(rustc_attrs, liballoc_internals)]
 macro_rules! vec {
     () => (
-        $crate::__rust_force_expr!($crate::vec::Vec::new_co())
+        $crate::__rust_force_expr!($crate::vec::Vec::new())
     );
     ($elem:expr; $n:expr) => (
         $crate::__rust_force_expr!($crate::vec::from_elem($elem, $n))

library/alloc/src/str.rs

@@ -144,7 +144,7 @@ where
     // the first slice is the only one without a separator preceding it
     let first = match iter.next() {
         Some(first) => first,
-        None => return vec![],
+        None => return Vec::new_co(),
     };
 
     // compute the exact total length of the joined Vec
@@ -159,7 +159,7 @@ where
         .expect("attempt to join into collection with len > usize::MAX");
 
     // prepare an uninitialized buffer
-    let mut result = Vec::with_capacity(reserved_len);
+    let mut result = Vec::with_capacity_co(reserved_len);
     debug_assert!(result.capacity() >= reserved_len);
 
     result.extend_from_slice(first.borrow().as_ref());

library/alloc/src/vec/mod.rs

@@ -444,6 +444,10 @@ pub type DefVec<T, A = Global> = Vec<T, A, { DEFAULT_COOP_PREFERRED!() }>;
 pub type WeVec<T, const WEIGHT: u8> = Vec<T, Global, { WEIGHT > 127 }>;
 
 impl<T> Vec<T> {
+/*impl<T, const COOP_PREFERRED: bool> Vec<T, Global, COOP_PREFERRED>
+where
+    [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{*/
     /// Constructs a new, empty `Vec<T>`.
     ///
     /// The vector will not allocate until elements are pushed onto it.
@@ -461,13 +465,73 @@ impl<T> Vec<T> {
     pub const fn new() -> Self {
         #[allow(unused_braces)]
         Vec::<T, Global, { DEFAULT_COOP_PREFERRED!() }>::new_co()
+        //Self::new_co()
+    }
+
+    /// Constructs a new, empty `Vec<T>` with at least the specified capacity.
+    ///
+    /// The vector will be able to hold at least `capacity` elements without
+    /// reallocating. This method is allowed to allocate for more elements than
+    /// `capacity`. If `capacity` is 0, the vector will not allocate.
+    ///
+    /// It is important to note that although the returned vector has the
+    /// minimum *capacity* specified, the vector will have a zero *length*. For
+    /// an explanation of the difference between length and capacity, see
+    /// *[Capacity and reallocation]*.
+    ///
+    /// If it is important to know the exact allocated capacity of a `Vec`,
+    /// always use the [`capacity`] method after construction.
+    ///
+    /// For `Vec<T>` where `T` is a zero-sized type, there will be no allocation
+    /// and the capacity will always be `usize::MAX`.
+    ///
+    /// [Capacity and reallocation]: #capacity-and-reallocation
+    /// [`capacity`]: Vec::capacity
+    ///
+    /// # Panics
+    ///
+    /// Panics if the new capacity exceeds `isize::MAX` bytes.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// let mut vec = Vec::with_capacity(10);
+    ///
+    /// // The vector contains no items, even though it has capacity for more
+    /// assert_eq!(vec.len(), 0);
+    /// assert!(vec.capacity() >= 10);
+    ///
+    /// // These are all done without reallocating...
+    /// for i in 0..10 {
+    ///     vec.push(i);
+    /// }
+    /// assert_eq!(vec.len(), 10);
+    /// assert!(vec.capacity() >= 10);
+    ///
+    /// // ...but this may make the vector reallocate
+    /// vec.push(11);
+    /// assert_eq!(vec.len(), 11);
+    /// assert!(vec.capacity() >= 11);
+    ///
+    /// // A vector of a zero-sized type will always over-allocate, since no
+    /// // allocation is necessary
+    /// let vec_units = Vec::<()>::with_capacity(10);
+    /// assert_eq!(vec_units.capacity(), usize::MAX);
+    /// ```    #[cfg(not(no_global_oom_handling))]
+    #[inline]
+    #[stable(feature = "rust1", since = "1.0.0")]
+    #[must_use]
+    pub fn with_capacity(capacity: usize) -> Self {
+        Self::with_capacity_in(capacity, Global)
     }
+
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Inherent methods
 ////////////////////////////////////////////////////////////////////////////////
 
+/**/
 impl<T, const COOP_PREFERRED: bool> Vec<T, Global, COOP_PREFERRED>
 where
     [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
@@ -481,6 +545,7 @@ where
         Vec { buf: RawVec::NEW, len: 0 }
     }
 
+    // TODO @FIXME document co-allocation
     /// Constructs a new, empty `Vec<T>` with at least the specified capacity.
     ///
     /// The vector will be able to hold at least `capacity` elements without
@@ -533,9 +598,9 @@ where
     /// ```
     #[cfg(not(no_global_oom_handling))]
     #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
+    #[unstable(feature = "vec_new_co", reason = "confirm_or_fix_the_function_name", issue = "none")]
     #[must_use]
-    pub fn with_capacity(capacity: usize) -> Self {
+    pub fn with_capacity_co(capacity: usize) -> Self {
         Self::with_capacity_in(capacity, Global)
     }
 

library/alloc/src/vec/spec_from_iter_nested.rs

@@ -34,7 +34,7 @@ where
                 let (lower, _) = iterator.size_hint();
                 let initial_capacity =
                     cmp::max(RawVec::<T>::MIN_NON_ZERO_CAP, lower.saturating_add(1));
-                let mut vector = Vec::with_capacity(initial_capacity);
+                let mut vector = Vec::with_capacity_co(initial_capacity);
                 unsafe {
                     // SAFETY: We requested capacity at least 1
                     ptr::write(vector.as_mut_ptr(), element);

library/std/src/lib.rs

@@ -329,6 +329,7 @@
 #![feature(try_reserve_kind)]
 #![feature(vec_into_raw_parts)]
 #![feature(slice_concat_trait)]
+#![feature(vec_new_co)]
 //
 // Library features (unwind):
 #![feature(panic_unwind)]

library/std/src/sys_common/thread_local_dtor.rs

@@ -31,7 +31,7 @@ pub unsafe fn register_dtor_fallback(t: *mut u8, dtor: unsafe extern "C" fn(*mut
     static DTORS: StaticKey = StaticKey::new(Some(run_dtors));
     type List = PlVec<(*mut u8, unsafe extern "C" fn(*mut u8))>;
     if DTORS.get().is_null() {
-        let v: Box<List> = Box::new(Vec::new());
+        let v: Box<List> = Box::new(Vec::new_co());
         DTORS.set(Box::into_raw(v) as *mut u8);
     }
     let list: &mut List = &mut *(DTORS.get() as *mut List);