CoAlloc: Fixed my previous bug in Vec's IntoIter::clone(). Cleanup for the next rebase.

Author: peter-lyons-kehl

library/alloc/src/collections/btree/node.rs

@@ -79,18 +79,6 @@ struct LeafNode<K, V> {
     vals: [MaybeUninit<V>; leaf_node_capacity!()],
 }
 
-/// @FIXME Remove once we remove leaf_node_capacity!() workaround for https://github.com/rust-lang/rust/issues/108751
-/// This should be in #[test], but that would mean having it in a separate file (as per `x test tidy --bless`) - too complicated for this workaround.
-#[allow(dead_code)]
-fn assert_leaf_node_capacity() {
-    fn leaf_node() -> LeafNode<char, bool> {
-        loop {}
-    }
-    let node = leaf_node();
-    let _keys: [MaybeUninit<char>; CAPACITY] = node.keys;
-    let _vals: [MaybeUninit<bool>; CAPACITY] = node.vals;
-}
-
 impl<K, V> LeafNode<K, V> {
     /// Initializes a new `LeafNode` in-place.
     unsafe fn init(this: *mut Self) {
@@ -129,17 +117,6 @@ struct InternalNode<K, V> {
     edges: [MaybeUninit<BoxedNode<K, V>>; internal_node_capacity!()], // @FIXME internal_node_capacity!() workaround for https://github.com/rust-lang/rust/issues/108751
 }
 
-/// @FIXME Remove once we remove internal_node_capacity!() workaround for https://github.com/rust-lang/rust/issues/108751
-/// This should be in #[test], but that would mean having it in a separate file (as per `x test tidy --bless`) - too complicated for this workaround.
-#[allow(dead_code)]
-fn assert_internal_node_capacity() {
-    fn internal_node() -> InternalNode<char, bool> {
-        loop {}
-    }
-    let node = internal_node();
-    let _edges: [MaybeUninit<BoxedNode<char, bool>>; 2 * B] = node.edges;
-}
-
 impl<K, V> InternalNode<K, V> {
     /// Creates a new boxed `InternalNode`.
     ///

library/alloc/src/raw_vec.rs

@@ -126,9 +126,10 @@ impl<T, A: Allocator, const CO_ALLOC_PREF: CoAllocPref> RawVec<T, A, CO_ALLOC_PR
 where
     [(); { crate::meta_num_slots!(A, CO_ALLOC_PREF) }]:,
 {
+    // @FIXME
     #[allow(dead_code)]
     const fn new_plain_metas() -> [A::CoAllocMeta; { meta_num_slots_default!(A) }] {
-        loop {}
+        panic!("FIXME")
     }
 
     // Tiny Vecs are dumb. Skip to:

library/alloc/src/vec/into_iter.rs

@@ -455,13 +455,13 @@ where
     #[cfg(not(test))]
     fn clone(&self) -> Self {
         // @FIXME Remove the following extras - used for type checks only
-        let slice = self.as_slice();
-        let vec: crate::vec::Vec<T, A, CO_ALLOC_PREF> =
-            slice.to_vec_in_co::<A, CO_ALLOC_PREF>(self.alloc.deref().clone());
-        let _iter: IntoIter<T, A, CO_ALLOC_PREF> = vec.into_iter();
-
-        //self.as_slice().to_vec_in::<A, CO_ALLOC_PREF>(self.alloc.deref().clone()).into_iter()
-        loop {}
+        if false {
+            let slice = self.as_slice();
+            let vec: crate::vec::Vec<T, A, CO_ALLOC_PREF> =
+                slice.to_vec_in_co::<A, CO_ALLOC_PREF>(self.alloc.deref().clone());
+            let _iter: IntoIter<T, A, CO_ALLOC_PREF> = vec.into_iter();
+        }
+        self.as_slice().to_vec_in_co::<A, CO_ALLOC_PREF>(self.alloc.deref().clone()).into_iter()
     }
     #[cfg(test)]
     fn clone(&self) -> Self {

library/alloc/src/vec/mod.rs

@@ -3160,7 +3160,7 @@ where
     where
         R: RangeBounds<usize>,
         I: IntoIterator<Item = T>,
-        [(); { crate::meta_num_slots!(A, crate::CO_ALLOC_PREF_META_YES!()) }]:,
+        [(); CO_ALLOC_PREF]:,
     {
         Splice { drain: self.drain(range), replace_with: replace_with.into_iter() }
     }

library/core/src/iter/adapters/peekable.rs

@@ -18,6 +18,24 @@ pub struct Peekable<I: Iterator> {
     peeked: Option<Option<I::Item>>,
 }
 
+/*
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<I: Iterator + Clone> Clone for Peekable<I>
+where I::Item : Clone {
+    fn clone(&self) -> Self {
+        dbg_printf!("Peekable::clone() started".as_bytes().as_ptr());
+        let ic= self.iter.clone();
+        dbg_printf!("self.iter cloned successfully.".as_bytes().as_ptr());
+        let pc= self.peeked.clone();
+        dbg_printf!("self.peeked cloned successfully.".as_bytes().as_ptr());
+
+        Self {
+            iter: ic, //self.iter.clone(),
+            peeked: pc //self.peeked.clone()
+        }
+    }
+}*/
+
 impl<I: Iterator> Peekable<I> {
     pub(in crate::iter) fn new(iter: I) -> Peekable<I> {
         Peekable { iter, peeked: None }

tests/ui/allocator/object-safe.rs

@@ -6,7 +6,8 @@
 
 //use std::alloc::{Allocator, System};
 
-// PK: nowhere else under rust source, only here:
+// @FIXME
+// peter-kehl: nowhere else under rust source, only here:
 //fn ensure_object_safe(_: &dyn Allocator) {}
 
 fn main() {