CoAlloc: Separated Vec::from_raw_parts_co and similar (and also in VecDeque). Mostly compiling.

Author: peter-lyons-kehl

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

@@ -57,7 +57,7 @@ use self::spec_extend::SpecExtend;
 
 mod spec_extend;
 
-use self::spec_from_iter::SpecFromIter;
+use self::spec_from_iter::SpecFromIterCo;
 
 mod spec_from_iter;
 
@@ -2809,7 +2809,7 @@ where
     [(); {crate::meta_num_slots_global!(CO_ALLOC_PREF)}]:,
 {
     fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> VecDeque<T, Global, CO_ALLOC_PREF> {
-        SpecFromIter::spec_from_iter(iter.into_iter())
+        SpecFromIterCo::spec_from_iter_co(iter.into_iter())
     }
 }
 
@@ -2911,6 +2911,33 @@ where
     }
 }
 
+#[stable(feature = "vecdeque_vec_conversions", since = "1.10.0")]
+#[allow(unused_braces)]
+impl<T, A: Allocator, /*const CO_ALLOC_PREF: CoAllocPref,*/ const OTHER_CO_ALLOC_PREF: CoAllocPref>
+    From<Vec<T, A, OTHER_CO_ALLOC_PREF>> for VecDeque<T, A>//, CO_ALLOC_PREF>
+where
+    //[(); {crate::meta_num_slots!(A, CO_ALLOC_PREF)}]:,
+    [(); {crate::meta_num_slots!(A, OTHER_CO_ALLOC_PREF)}]:,
+{
+    /// Turn a [`Vec<T>`] into a [`VecDeque<T>`].
+    ///
+    /// [`Vec<T>`]: crate::vec::Vec
+    /// [`VecDeque<T>`]: crate::collections::VecDeque
+    ///
+    /// This conversion is guaranteed to run in *O*(1) time
+    /// and to not re-allocate the `Vec`'s buffer or allocate
+    /// any additional memory.
+    #[inline]
+    default fn from(other: Vec<T, A, OTHER_CO_ALLOC_PREF>) -> Self {
+        let (ptr, len, cap, alloc) = other.into_raw_parts_with_alloc();
+        Self {
+            head: 0,
+            len,
+            buf: unsafe { RawVec::<T, A/*, CO_ALLOC_PREF*/>::from_raw_parts_in(ptr, cap, alloc) },
+        }
+    }
+}
+
 #[stable(feature = "vecdeque_vec_conversions", since = "1.10.0")]
 #[allow(unused_braces)]
 impl<T, A: Allocator, const CO_ALLOC_PREF: CoAllocPref, const OTHER_CO_ALLOC_PREF: CoAllocPref>
@@ -2928,7 +2955,7 @@ where
     /// and to not re-allocate the `Vec`'s buffer or allocate
     /// any additional memory.
     #[inline]
-    fn from(other: Vec<T, A, OTHER_CO_ALLOC_PREF>) -> Self {
+    default fn from(other: Vec<T, A, OTHER_CO_ALLOC_PREF>) -> Self {
         let (ptr, len, cap, alloc) = other.into_raw_parts_with_alloc();
         Self {
             head: 0,

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

@@ -7,41 +7,81 @@ pub(super) trait SpecFromIter<T, I> {
     fn spec_from_iter(iter: I) -> Self;
 }
 
+/// Specialization trait used for `VecDeque::from_iter_co`
+pub(super) trait SpecFromIterCo<T, I> {
+    fn spec_from_iter_co(iter: I) -> Self;
+}
+
 #[allow(unused_braces)]
-impl<T, I, const CO_ALLOC_PREF: CoAllocPref> SpecFromIter<T, I> for VecDeque<T, Global, CO_ALLOC_PREF>
+impl<T, I> SpecFromIter<T, I> for VecDeque<T>
 where
     I: Iterator<Item = T>,
-    [(); {crate::meta_num_slots_global!(CO_ALLOC_PREF)}]:,
 {
     default fn spec_from_iter(iterator: I) -> Self {
         // Since converting is O(1) now, just re-use the `Vec` logic for
         // 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::<T, Global, CO_ALLOC_PREF>::from_iter(iterator).into()
+        crate::vec::Vec::from_iter(iterator).into()
+    }
+}
+
+#[allow(unused_braces)]
+impl<T> SpecFromIter<T, crate::vec::IntoIter<T>>
+    for VecDeque<T>
+{
+    #[inline]
+    fn spec_from_iter(iterator: crate::vec::IntoIter<T>) -> Self {
+        iterator.into_vecdeque()
+    }
+}
+
+#[allow(unused_braces)]
+impl<T> SpecFromIter<T, IntoIter<T>>
+    for VecDeque<T>
+{
+    #[inline]
+    fn spec_from_iter(iterator: IntoIter<T>) -> Self {
+        iterator.into_vecdeque()
+    }
+}
+// ----
+
+#[allow(unused_braces)]
+impl<T, I, const CO_ALLOC_PREF: CoAllocPref> SpecFromIterCo<T, I> for VecDeque<T, Global, CO_ALLOC_PREF>
+where
+    I: Iterator<Item = T>,
+    [(); {crate::meta_num_slots_global!(CO_ALLOC_PREF)}]:,
+{
+    default fn spec_from_iter_co(iterator: I) -> Self {
+        // Since converting is O(1) now, just re-use the `Vec` logic for
+        // 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::<T, Global, CO_ALLOC_PREF>::from_iter_co(iterator).into()
     }
 }
 
 #[allow(unused_braces)]
-impl<T, const CO_ALLOC_PREF: CoAllocPref> SpecFromIter<T, crate::vec::IntoIter<T, Global, CO_ALLOC_PREF>>
+impl<T, const CO_ALLOC_PREF: CoAllocPref> SpecFromIterCo<T, crate::vec::IntoIter<T, Global, CO_ALLOC_PREF>>
     for VecDeque<T, Global, CO_ALLOC_PREF>
 where
     [(); {crate::meta_num_slots_global!(CO_ALLOC_PREF)}]:,
 {
     #[inline]
-    fn spec_from_iter(iterator: crate::vec::IntoIter<T, Global, CO_ALLOC_PREF>) -> Self {
+    fn spec_from_iter_co(iterator: crate::vec::IntoIter<T, Global, CO_ALLOC_PREF>) -> Self {
         iterator.into_vecdeque()
     }
 }
 
 #[allow(unused_braces)]
-impl<T, const CO_ALLOC_PREF: CoAllocPref> SpecFromIter<T, IntoIter<T, Global, CO_ALLOC_PREF>>
+impl<T, const CO_ALLOC_PREF: CoAllocPref> SpecFromIterCo<T, IntoIter<T, Global, CO_ALLOC_PREF>>
     for VecDeque<T, Global, CO_ALLOC_PREF>
 where
     [(); {crate::meta_num_slots_global!(CO_ALLOC_PREF)}]:,
 {
     #[inline]
-    fn spec_from_iter(iterator: IntoIter<T, Global, CO_ALLOC_PREF>) -> Self {
+    fn spec_from_iter_co(iterator: IntoIter<T, Global, CO_ALLOC_PREF>) -> Self {
         iterator.into_vecdeque()
     }
-}
+}

library/alloc/src/vec/in_place_collect.rs

@@ -210,7 +210,7 @@ where
         src.forget_allocation_drop_remaining();
         mem::forget(dst_guard);
 
-        let vec = unsafe { Vec::from_raw_parts(dst_buf, len, cap) };
+        let vec = unsafe { Vec::from_raw_parts_co(dst_buf, len, cap) };
 
         vec
     }

library/alloc/src/vec/mod.rs

@@ -588,6 +588,17 @@ where
         Self::with_capacity_in(capacity, Global)
     }
 
+    /// Coallocation-aware alternative to `from_row_parts`.
+    #[inline]
+    #[unstable(feature = "global_co_alloc", issue = "none")]
+    pub unsafe fn from_raw_parts_co(ptr: *mut T, length: usize, capacity: usize) -> Self {
+        unsafe { Self::from_raw_parts_in(ptr, length, capacity, Global) }
+    }
+
+}
+
+impl<T> Vec<T>
+{
     /// Creates a `Vec<T>` directly from a pointer, a capacity, and a length.
     ///
     /// # Safety
@@ -2906,12 +2917,24 @@ where
 #[cfg(not(no_global_oom_handling))]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[allow(unused_braces)]
-impl<T, const CO_ALLOC_PREF: CoAllocPref> FromIterator<T> for Vec<T, Global, CO_ALLOC_PREF>
+impl<T> FromIterator<T> for Vec<T>
+{
+    #[inline]
+    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Vec<T> {
+        <Self as SpecFromIter<T, I::IntoIter>>::from_iter(iter.into_iter())
+    }
+}
+
+#[cfg(not(no_global_oom_handling))]
+#[unstable(feature = "global_co_alloc", issue="none")]
+#[allow(unused_braces)]
+impl<T, const CO_ALLOC_PREF: CoAllocPref> Vec<T, Global, CO_ALLOC_PREF>
 where
     [(); {crate::meta_num_slots_global!(CO_ALLOC_PREF)}]:,
 {
+    /// Coallocation-aware alternative to `from_iter`.
     #[inline]
-    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Vec<T, Global, CO_ALLOC_PREF> {
+    pub fn from_iter_co<I: IntoIterator<Item = T>>(iter: I) -> Vec<T, Global, CO_ALLOC_PREF> {
         <Self as SpecFromIter<T, I::IntoIter>>::from_iter(iter.into_iter())
     }
 }

library/alloc/src/vec/spec_from_iter.rs

@@ -59,7 +59,7 @@ where
                 if has_advanced {
                     ptr::copy(it.ptr, it.buf.as_ptr(), it.len());
                 }
-                return Vec::from_raw_parts(it.buf.as_ptr(), it.len(), it.cap);
+                return Vec::from_raw_parts_co(it.buf.as_ptr(), it.len(), it.cap);
             }
         }