RawVec includes GlobalCoAllocMeta based on allocator; related bounds

Author: peter-lyons-kehl

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

@@ -4,6 +4,7 @@ macro_rules! __impl_slice_eq1 {
         impl<T, U, A: Allocator, $($vars)*> PartialEq<$rhs> for $lhs
         where
             T: PartialEq<U>,
+            [(); core::alloc::co_alloc_metadata_num_slots::<A>()]:,
             $($constraints)*
         {
             fn eq(&self, other: &$rhs) -> bool {

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

@@ -5,8 +5,10 @@
 //! are not required to be copyable, and the queue will be sendable if the
 //! contained type is sendable.
 
-#![stable(feature = "rust1", since = "1.0.0")]
+#![feature(global_co_alloc)]
 
+#![stable(feature = "rust1", since = "1.0.0")]
+use core::alloc;
 use core::cmp::{self, Ordering};
 use core::fmt;
 use core::hash::{Hash, Hasher};
@@ -91,10 +93,13 @@ mod tests;
 #[cfg_attr(not(test), rustc_diagnostic_item = "VecDeque")]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_insignificant_dtor]
+// @TODO
 pub struct VecDeque<
     T,
     #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
-> {
+>
+where [(); alloc::co_alloc_metadata_num_slots::<A>()]:
+{
     // `self[0]`, if it exists, is `buf[head]`.
     // `head < buf.capacity()`, unless `buf.capacity() == 0` when `head == 0`.
     head: usize,
@@ -106,7 +111,8 @@ pub struct VecDeque<
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Clone, A: Allocator + Clone> Clone for VecDeque<T, A> {
+impl<T: Clone, A: Allocator + Clone> Clone for VecDeque<T, A>
+where [(); alloc::co_alloc_metadata_num_slots::<A>()]: {
     fn clone(&self) -> Self {
         let mut deq = Self::with_capacity_in(self.len(), self.allocator().clone());
         deq.extend(self.iter().cloned());
@@ -120,7 +126,8 @@ impl<T: Clone, A: Allocator + Clone> Clone for VecDeque<T, A> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-unsafe impl<#[may_dangle] T, A: Allocator> Drop for VecDeque<T, A> {
+unsafe impl<#[may_dangle] T, A: Allocator> Drop for VecDeque<T, A>
+where [(); alloc::co_alloc_metadata_num_slots::<A>()]: {
     fn drop(&mut self) {
         /// Runs the destructor for all items in the slice when it gets dropped (normally or
         /// during unwinding).
@@ -153,7 +160,8 @@ impl<T> Default for VecDeque<T> {
     }
 }
 
-impl<T, A: Allocator> VecDeque<T, A> {
+impl<T, A: Allocator> VecDeque<T, A>
+where [(); alloc::co_alloc_metadata_num_slots::<A>()]: {
     /// Marginally more convenient
     #[inline]
     fn ptr(&self) -> *mut T {
@@ -442,7 +450,8 @@ impl<T, A: Allocator> VecDeque<T, A> {
         mut iter: impl Iterator<Item = T>,
         len: usize,
     ) -> usize {
-        struct Guard<'a, T, A: Allocator> {
+        struct Guard<'a, T, A: Allocator>
+        where [(); alloc::co_alloc_metadata_num_slots::<A>()]: {
             deque: &'a mut VecDeque<T, A>,
             written: usize,
         }
@@ -560,7 +569,8 @@ impl<T> VecDeque<T> {
     }
 }
 
-impl<T, A: Allocator> VecDeque<T, A> {
+impl<T, A: Allocator> VecDeque<T, A>
+where [(); alloc::co_alloc_metadata_num_slots::<A>()]: {
     /// Creates an empty deque.
     ///
     /// # Examples
@@ -2593,7 +2603,8 @@ impl<T, A: Allocator> VecDeque<T, A> {
     }
 }
 
-impl<T: Clone, A: Allocator> VecDeque<T, A> {
+impl<T: Clone, A: Allocator> VecDeque<T, A>
+where [(); alloc::co_alloc_metadata_num_slots::<A>()]: {
     /// Modifies the deque in-place so that `len()` is equal to new_len,
     /// either by removing excess elements from the back or by appending clones of `value`
     /// to the back.
@@ -2638,7 +2649,8 @@ fn wrap_index(logical_index: usize, capacity: usize) -> usize {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: PartialEq, A: Allocator> PartialEq for VecDeque<T, A> {
+impl<T: PartialEq, A: Allocator> PartialEq for VecDeque<T, A>
+where [(); alloc::co_alloc_metadata_num_slots::<A>()]: {
     fn eq(&self, other: &Self) -> bool {
         if self.len != other.len() {
             return false;
@@ -2677,7 +2689,8 @@ impl<T: PartialEq, A: Allocator> PartialEq for VecDeque<T, A> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Eq, A: Allocator> Eq for VecDeque<T, A> {}
+impl<T: Eq, A: Allocator> Eq for VecDeque<T, A>
+where [(); alloc::co_alloc_metadata_num_slots::<A>()]: {}
 
 __impl_slice_eq1! { [] VecDeque<T, A>, Vec<U, A>, }
 __impl_slice_eq1! { [] VecDeque<T, A>, &[U], }
@@ -2687,22 +2700,25 @@ __impl_slice_eq1! { [const N: usize] VecDeque<T, A>, &[U; N], }
 __impl_slice_eq1! { [const N: usize] VecDeque<T, A>, &mut [U; N], }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: PartialOrd, A: Allocator> PartialOrd for VecDeque<T, A> {
+impl<T: PartialOrd, A: Allocator> PartialOrd for VecDeque<T, A>
+where [(); alloc::co_alloc_metadata_num_slots::<A>()]: {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         self.iter().partial_cmp(other.iter())
     }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Ord, A: Allocator> Ord for VecDeque<T, A> {
+impl<T: Ord, A: Allocator> Ord for VecDeque<T, A>
+where [(); alloc::co_alloc_metadata_num_slots::<A>()]: {
     #[inline]
     fn cmp(&self, other: &Self) -> Ordering {
         self.iter().cmp(other.iter())
     }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Hash, A: Allocator> Hash for VecDeque<T, A> {
+impl<T: Hash, A: Allocator> Hash for VecDeque<T, A>
+where [(); alloc::co_alloc_metadata_num_slots::<A>()]: {
     fn hash<H: Hasher>(&self, state: &mut H) {
         state.write_length_prefix(self.len);
         // It's not possible to use Hash::hash_slice on slices
@@ -2716,7 +2732,8 @@ impl<T: Hash, A: Allocator> Hash for VecDeque<T, A> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, A: Allocator> Index<usize> for VecDeque<T, A> {
+impl<T, A: Allocator> Index<usize> for VecDeque<T, A>
+where [(); alloc::co_alloc_metadata_num_slots::<A>()]: {
     type Output = T;
 
     #[inline]
@@ -2726,7 +2743,8 @@ impl<T, A: Allocator> Index<usize> for VecDeque<T, A> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, A: Allocator> IndexMut<usize> for VecDeque<T, A> {
+impl<T, A: Allocator> IndexMut<usize> for VecDeque<T, A>
+where [(); alloc::co_alloc_metadata_num_slots::<A>()]: {
     #[inline]
     fn index_mut(&mut self, index: usize) -> &mut T {
         self.get_mut(index).expect("Out of bounds access")
@@ -2741,7 +2759,8 @@ impl<T> FromIterator<T> for VecDeque<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, A: Allocator> IntoIterator for VecDeque<T, A> {
+impl<T, A: Allocator> IntoIterator for VecDeque<T, A>
+where [(); alloc::co_alloc_metadata_num_slots::<A>()]: {
     type Item = T;
     type IntoIter = IntoIter<T, A>;
 
@@ -2753,7 +2772,8 @@ impl<T, A: Allocator> IntoIterator for VecDeque<T, A> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T, A: Allocator> IntoIterator for &'a VecDeque<T, A> {
+impl<'a, T, A: Allocator> IntoIterator for &'a VecDeque<T, A>
+where [(); alloc::co_alloc_metadata_num_slots::<A>()]: {
     type Item = &'a T;
     type IntoIter = Iter<'a, T>;
 
@@ -2763,7 +2783,8 @@ impl<'a, T, A: Allocator> IntoIterator for &'a VecDeque<T, A> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T, A: Allocator> IntoIterator for &'a mut VecDeque<T, A> {
+impl<'a, T, A: Allocator> IntoIterator for &'a mut VecDeque<T, A>
+where [(); alloc::co_alloc_metadata_num_slots::<A>()]: {
     type Item = &'a mut T;
     type IntoIter = IterMut<'a, T>;
 
@@ -2773,7 +2794,8 @@ impl<'a, T, A: Allocator> IntoIterator for &'a mut VecDeque<T, A> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, A: Allocator> Extend<T> for VecDeque<T, A> {
+impl<T, A: Allocator> Extend<T> for VecDeque<T, A>
+where [(); alloc::co_alloc_metadata_num_slots::<A>()]: {
     fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
         <Self as SpecExtend<T, I::IntoIter>>::spec_extend(self, iter.into_iter());
     }
@@ -2790,7 +2812,8 @@ impl<T, A: Allocator> Extend<T> for VecDeque<T, A> {
 }
 
 #[stable(feature = "extend_ref", since = "1.2.0")]
-impl<'a, T: 'a + Copy, A: Allocator> Extend<&'a T> for VecDeque<T, A> {
+impl<'a, T: 'a + Copy, A: Allocator> Extend<&'a T> for VecDeque<T, A>
+where [(); alloc::co_alloc_metadata_num_slots::<A>()]: {
     fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
         self.spec_extend(iter.into_iter());
     }
@@ -2807,14 +2830,16 @@ impl<'a, T: 'a + Copy, A: Allocator> Extend<&'a T> for VecDeque<T, A> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: fmt::Debug, A: Allocator> fmt::Debug for VecDeque<T, A> {
+impl<T: fmt::Debug, A: Allocator> fmt::Debug for VecDeque<T, A>
+where [(); alloc::co_alloc_metadata_num_slots::<A>()]: {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_list().entries(self.iter()).finish()
     }
 }
 
 #[stable(feature = "vecdeque_vec_conversions", since = "1.10.0")]
-impl<T, A: Allocator> From<Vec<T, A>> for VecDeque<T, A> {
+impl<T, A: Allocator> From<Vec<T, A>> for VecDeque<T, A>
+where [(); alloc::co_alloc_metadata_num_slots::<A>()]: {
     /// Turn a [`Vec<T>`] into a [`VecDeque<T>`].
     ///
     /// [`Vec<T>`]: crate::vec::Vec
@@ -2831,7 +2856,8 @@ impl<T, A: Allocator> From<Vec<T, A>> for VecDeque<T, A> {
 }
 
 #[stable(feature = "vecdeque_vec_conversions", since = "1.10.0")]
-impl<T, A: Allocator> From<VecDeque<T, A>> for Vec<T, A> {
+impl<T, A: Allocator> From<VecDeque<T, A>> for Vec<T, A>
+where [(); alloc::co_alloc_metadata_num_slots::<A>()]: {
     /// Turn a [`VecDeque<T>`] into a [`Vec<T>`].
     ///
     /// [`Vec<T>`]: crate::vec::Vec

library/alloc/src/lib.rs

@@ -86,6 +86,7 @@
 #![warn(deprecated_in_future)]
 #![warn(missing_debug_implementations)]
 #![warn(missing_docs)]
+#![allow(incomplete_features)]
 #![allow(explicit_outlives_requirements)]
 //
 // Library features:
@@ -121,6 +122,7 @@
 #![feature(extend_one)]
 #![feature(fmt_internals)]
 #![feature(fn_traits)]
+#![feature(generic_const_exprs)]
 #![feature(global_co_alloc_meta)]
 #![feature(hasher_prefixfree_extras)]
 #![feature(inplace_iteration)]

library/alloc/src/raw_vec.rs

@@ -1,6 +1,6 @@
 #![unstable(feature = "raw_vec_internals", reason = "unstable const warnings", issue = "none")]
 
-use core::alloc::{LayoutError, GlobalCoAllocMeta};
+use core::alloc::{self, LayoutError, GlobalCoAllocMeta};
 use core::cmp;
 use core::intrinsics;
 use core::mem::{self, ManuallyDrop, MaybeUninit, SizedTypeProperties};
@@ -49,12 +49,19 @@ enum AllocInit {
 /// `usize::MAX`. This means that you need to be careful when round-tripping this type with a
 /// `Box<[T]>`, since `capacity()` won't yield the length.
 #[allow(missing_debug_implementations)]
-pub(crate) struct RawVec<T, A: Allocator = Global> {
+// @TODO
+// 1. make const generic _coop come from the target specification
+// 2. apply `_coop` with logical && to `A::IsCoAllocator`
+pub(crate) struct RawVec<T, A: Allocator = Global, const _coop: bool = true>
+where [(); alloc::co_alloc_metadata_num_slots::<A>()]:
+{
     ptr: Unique<T>,
     cap: usize,
     alloc: A,
-    #[allow(dead_code)]
-    pub(crate) meta: GlobalCoAllocMeta,
+    // As of v1.67.0, `cmp` for `TypeId` is not `const`, unfortunately:
+    //pub(crate) meta: [GlobalCoAllocMeta; {if core::any::TypeId::of::<A>()==core::any::TypeId::of::<Global>() {1} else {0}}],
+    //pub(crate) meta: [GlobalCoAllocMeta; mem::size_of::<A::IsCoAllocator>()],
+    pub(crate) meta: [GlobalCoAllocMeta; alloc::co_alloc_metadata_num_slots::<A>()],
 }
 
 impl<T> RawVec<T, Global> {
@@ -104,7 +111,9 @@ impl<T> RawVec<T, Global> {
     }
 }
 
-impl<T, A: Allocator> RawVec<T, A> {
+impl<T, A: Allocator> RawVec<T, A>
+where [(); alloc::co_alloc_metadata_num_slots::<A>()]:
+{
     // Tiny Vecs are dumb. Skip to:
     // - 8 if the element size is 1, because any heap allocators is likely
     //   to round up a request of less than 8 bytes to at least 8 bytes.
@@ -284,7 +293,9 @@ impl<T, A: Allocator> RawVec<T, A> {
             slf: &mut RawVec<T, A>,
             len: usize,
             additional: usize,
-        ) {
+        )
+        where [(); alloc::co_alloc_metadata_num_slots::<A>()]:
+        {
             handle_reserve(slf.grow_amortized(len, additional));
         }
 
@@ -357,14 +368,18 @@ impl<T, A: Allocator> RawVec<T, A> {
     }
 }
 
-impl<T, A: Allocator> RawVec<T, A> {
+impl<T, A: Allocator> RawVec<T, A>
+where [(); alloc::co_alloc_metadata_num_slots::<A>()]:
+{
     /// Returns if the buffer needs to grow to fulfill the needed extra capacity.
     /// Mainly used to make inlining reserve-calls possible without inlining `grow`.
-    fn needs_to_grow(&self, len: usize, additional: usize) -> bool {
+    fn needs_to_grow(&self, len: usize, additional: usize) -> bool
+     {
         additional > self.capacity().wrapping_sub(len)
     }
 
-    fn set_ptr_and_cap(&mut self, ptr: NonNull<[u8]>, cap: usize) {
+    fn set_ptr_and_cap(&mut self, ptr: NonNull<[u8]>, cap: usize)
+    {
         // Allocators currently return a `NonNull<[u8]>` whose length matches
         // the size requested. If that ever changes, the capacity here should
         // change to `ptr.len() / mem::size_of::<T>()`.
@@ -475,24 +490,27 @@ where
     memory.map_err(|_| AllocError { layout: new_layout, non_exhaustive: () }.into())
 }
 
-unsafe impl<#[may_dangle] T, A: Allocator> Drop for RawVec<T, A> {
+unsafe impl<#[may_dangle] T, A: Allocator> Drop for RawVec<T, A>
+where [(); alloc::co_alloc_metadata_num_slots::<A>()]:
+{
     /// Frees the memory owned by the `RawVec` *without* trying to drop its contents.
     default fn drop(&mut self) {
         if let Some((ptr, layout)) = self.current_memory() {
-            unsafe { self.alloc.deallocate(ptr, layout) }
+            unsafe { self.alloc.co_deallocate(ptr, layout) }
         }
     }
 }
 
-unsafe impl<#[may_dangle] T> Drop for RawVec<T, Global> {
+// @TODO Custom
+/*unsafe impl<#[may_dangle] T> Drop for RawVec<T, Global> {
     /// Frees the memory owned by the `RawVec` *without* trying to drop its contents.
     fn drop(&mut self) {
         // @TODO
         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))]