CoAlloc: Fixed specializations

Author: peter-lyons-kehl

library/alloc/src/co_alloc.rs

@@ -21,11 +21,11 @@
 /// - DO NOT hard code any values; and
 /// - DO NOT mix this/cast this with/to `u8`, `u16`, `usize` (nor any other integer).
 #[unstable(feature = "global_co_alloc_meta", issue = "none")]
-pub type CoAllocPref = u8;
+pub type CoAllocPref = usize; //u8;
 
-/// `CoAllocMetaNumSlotsPref` values indicate a type (but not an allocator) prefers to coallocate by
-/// carrying metadata, or not. (In either user space, or `std` space). Used as an argument to macro
-/// call of `co_alloc_pref`, which generates a `CoAllocPref` value.
+/// `CoAllocMetaNumSlotsPref` values indicate that a type (but not necessarily an allocator) prefers
+/// to coallocate by carrying metadata, or not. (In either user space, or `std` or `alloc` space).
+/// Used as an argument to macro call of `co_alloc_pref`, which generates a `CoAllocPref` value.
 ///
 /// Currently this indicates only the (preferred) number of `CoAllocMetaBase` slots being used
 /// (either 1 = coallocation, or 0 = no coallocation). However, in the future this type may have

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

@@ -12,7 +12,6 @@ pub(super) trait SpecFromIterCo<T, I> {
     fn spec_from_iter_co(iter: I) -> Self;
 }
 
-#[allow(unused_braces)]
 impl<T, I> SpecFromIter<T, I> for VecDeque<T>
 where
     I: Iterator<Item = T>,
@@ -26,15 +25,13 @@ where
     }
 }
 
-#[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 {

library/alloc/src/slice.rs

@@ -627,7 +627,10 @@ 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> {
+    #[allow(unused_braces)]
+    pub fn into_vec<A: Allocator>(self: Box<Self, A>) -> Vec<T, A>
+    where [(); { crate::meta_num_slots!(A, CO_ALLOC_PREF) }]:
+    {
         // N.B., see the `hack` module in this file for more details.
         hack::into_vec(self)
     }
@@ -981,12 +984,18 @@ where
 // public in the crate and has the Allocator parameter so that
 // vec::clone_from use it too.
 #[cfg(not(no_global_oom_handling))]
-pub(crate) trait SpecCloneIntoVec<T, A: Allocator> {
+#[allow(unused_braces)]
+pub(crate) trait SpecCloneIntoVec<T, A: Allocator>
+where [(); { crate::meta_num_slots!(A, CO_ALLOC_PREF) }]:
+{
     fn clone_into(&self, target: &mut Vec<T, A>);
 }
 
 #[cfg(not(no_global_oom_handling))]
-impl<T: Clone, A: Allocator> SpecCloneIntoVec<T, A> for [T] {
+#[allow(unused_braces)]
+impl<T: Clone, A: Allocator> SpecCloneIntoVec<T, A> for [T]
+where [(); { crate::meta_num_slots!(A, CO_ALLOC_PREF) }]:
+{
     default fn clone_into(&self, target: &mut Vec<T, A>) {
         // drop anything in target that will not be overwritten
         target.truncate(self.len());
@@ -1002,7 +1011,10 @@ impl<T: Clone, A: Allocator> SpecCloneIntoVec<T, A> for [T] {
 }
 
 #[cfg(not(no_global_oom_handling))]
-impl<T: Copy, A: Allocator> SpecCloneIntoVec<T, A> for [T] {
+#[allow(unused_braces)]
+impl<T: Copy, A: Allocator> SpecCloneIntoVec<T, A> for [T]
+where [(); { crate::meta_num_slots!(A, CO_ALLOC_PREF) }]:
+{
     fn clone_into(&self, target: &mut Vec<T, A>) {
         target.clear();
         target.extend_from_slice(self);

library/core/src/alloc/mod.rs

@@ -106,9 +106,10 @@ impl const CoAllocMetaBase for CoAllocMetaPlain {
 /// `#![feature(adt_const_params)]` are stable) to a dedicated struct/enum. Hence:
 /// - DO NOT mix this/cast this with/to `u8`, `u16`, (nor any other integer); and
 /// - DO NOT hard code any values, but use `CO_ALLOCATOR_SUPPORTS_META_YES` and `CO_ALLOCATOR_SUPPORTS_META_NO`.
-///
+// @FIXME Once ICE is fixed: Change to `u32` (or any other unused unsinged integer type, and other
+// than `usize`, so we can't mix it up with `usize`).
 #[unstable(feature = "global_co_alloc_meta", issue = "none")]
-pub type CoAllocatorMetaNumSlots = u32;
+pub type CoAllocatorMetaNumSlots = usize;
 
 /// Indicating that an Allocator supports coallocation (if a type of the allocated instances supports it, too).
 #[unstable(feature = "global_co_alloc_meta", issue = "none")]