CoAlloc: Tiny fixes.

Author: peter-lyons-kehl

library/alloc/src/boxed.rs

@@ -146,6 +146,7 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
+#[cfg(not(no_global_oom_handling))]
 use crate::co_alloc::CoAllocPref;
 use core::any::Any;
 use core::async_iter::AsyncIterator;

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

@@ -607,7 +607,8 @@ impl<T, const CO_ALLOC_PREF: CoAllocPref> VecDeque<T, Global, CO_ALLOC_PREF>
 where
     [(); { crate::meta_num_slots_global!(CO_ALLOC_PREF) }]:,
 {
-    /// Coallocation-aware version of `new`.
+    // @FIXME intra-doc ref.
+    /// Coallocation-aware version of [VecDeque<T,>::new()].
     #[inline]
     #[unstable(feature = "co_alloc_global", issue = "none")]
     #[must_use]
@@ -617,7 +618,8 @@ where
         VecDeque { head: 0, len: 0, buf: RawVec::NEW }
     }
 
-    /// Coallocation-aware version of `with_capacity`.
+    // @FIXME intra-doc ref.
+    /// Coallocation-aware version of [VecDeque<T,>::with_capacity()].
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
     #[must_use]
@@ -2872,12 +2874,7 @@ impl<T, const CO_ALLOC_PREF: CoAllocPref> VecDeque<T, Global, CO_ALLOC_PREF>
 where
     [(); { crate::meta_num_slots_global!(CO_ALLOC_PREF) }]:,
 {
-    /// Like `<VecDeque::<T>>::from_iter()`, but coallocation-aware.
-    /// Like [`VecDeque::<T>::from_iter()`], but coallocation-aware.
-    /// Like [`<VecDeque::<T>>::from_iter(I)`], but coallocation-aware.
-    /// Like [`VecDeque::<T>::from_iter(I)`], but coallocation-aware.
-    /// Like [`<VecDeque::<T>>::from_iter(I: IntoIterator<Item = T>)`], but coallocation-aware.
-    /// Like [`VecDeque::<T>::from_iter(I: IntoIterator<Item = T>)`], but coallocation-aware.
+    /// Coallocation-aware version of [VecDeque<T,>::from_iter()].
     pub fn from_iter_co<I: IntoIterator<Item = T>>(iter: I) -> VecDeque<T, Global, CO_ALLOC_PREF> {
         SpecFromIterCo::spec_from_iter_co(iter.into_iter())
     }

library/alloc/src/rc.rs

@@ -275,6 +275,7 @@ use crate::alloc::handle_alloc_error;
 use crate::alloc::{box_free, WriteCloneIntoRaw};
 use crate::alloc::{AllocError, Allocator, Global, Layout};
 use crate::borrow::{Cow, ToOwned};
+#[cfg(not(no_global_oom_handling))]
 use crate::co_alloc::CoAllocPref;
 #[cfg(not(no_global_oom_handling))]
 use crate::string::String;

library/alloc/src/slice.rs

@@ -644,12 +644,7 @@ impl<T> [T] {
         hack::into_vec(self)
     }
 
-    /// Coallocation-aware version of `into_vec<A>()`.
-    /// Coallocation-aware version of `into_vec::<A>()`.
-    /// Coallocation-aware version of [`into_vec<A>(self)`].
-    /// Coallocation-aware version of [`into_vec::<A>(self)`].
-    /// Coallocation-aware version of [`into_vec<A>(Box<Self, A>)`].
-    /// Coallocation-aware version of [`into_vec::<A>(Box<Self, A>)`].
+    /// Coallocation-aware version of [\[T\]::into_vec()].
     #[rustc_allow_incoherent_impl]
     #[unstable(feature = "global_co_alloc", issue = "none")]
     #[inline]

library/alloc/src/vec/mod.rs

@@ -908,22 +908,22 @@ impl<T, A: Allocator, const CO_ALLOC_PREF: CoAllocPref> Vec<T, A, CO_ALLOC_PREF>
 where
     [(); { crate::meta_num_slots!(A, CO_ALLOC_PREF) }]:,
 {
-    /** Like `new_in`, but co-allocation-aware. */
+    /// Coallocation-aware version of [Vec<T,A>::new_in()].
     #[inline]
     #[unstable(feature = "global_co_alloc", issue = "none")]
     pub const fn new_in_co(alloc: A) -> Self {
         Vec { buf: RawVec::new_in(alloc), len: 0 }
     }
 
-    /** Like `with_capacity_in`, but co-allocation-aware. */
+    /// Coallocation-aware version of [Vec<T,A>::with_capacity_in()].
     #[cfg(not(no_global_oom_handling))]
     #[inline]
     #[unstable(feature = "global_co_alloc", issue = "none")]
     pub fn with_capacity_in_co(capacity: usize, alloc: A) -> Self {
         Vec { buf: RawVec::with_capacity_in(capacity, alloc), len: 0 }
     }
 
-    /** Like `from_raw_parts_in`, but co-allocation-aware. */
+    /// Coallocation-aware version of [Vec<T,A>::from_raw_parts_in()].
     #[inline]
     #[unstable(feature = "global_co_alloc", issue = "none")]
     pub unsafe fn from_raw_parts_in_co(

library/std/src/sys/hermit/thread_local_dtor.rs

@@ -1,13 +1,12 @@
 #![cfg(target_thread_local)]
 #![unstable(feature = "thread_local_internals", issue = "none")]
-#![feature(global_co_alloc_plvec)]
 
 // Simplify dtor registration by using a list of destructors.
 // The this solution works like the implementation of macOS and
 // doesn't additional OS support
 
 use crate::mem;
-use core::alloc::PlVec;
+use alloc::vec::PlVec;
 
 #[thread_local]
 static mut DTORS: PlVec<(*mut u8, unsafe extern "C" fn(*mut u8))> = PlVec::new();

library/std/src/sys/solid/thread_local_dtor.rs

@@ -1,14 +1,12 @@
 #![cfg(target_thread_local)]
 #![unstable(feature = "thread_local_internals", issue = "none")]
-#![feature(global_co_alloc_plvec)]
-#![feature(global_co_alloc_plvec)]
 
 // Simplify dtor registration by using a list of destructors.
 
 use super::{abi, itron::task};
 use crate::cell::Cell;
 use crate::mem;
-use core::alloc::PlVec;
+use alloc::vec::PlVec;
 
 #[thread_local]
 static REGISTERED: Cell<bool> = Cell::new(false);

library/std/src/sys/unix/thread_local_dtor.rs

@@ -53,6 +53,7 @@ pub unsafe fn register_dtor(t: *mut u8, dtor: unsafe extern "C" fn(*mut u8)) {
     use crate::cell::Cell;
     use crate::mem;
     use crate::ptr;
+    use alloc::vec::PlVec;
 
     #[thread_local]
     static REGISTERED: Cell<bool> = Cell::new(false);
@@ -65,15 +66,6 @@ pub unsafe fn register_dtor(t: *mut u8, dtor: unsafe extern "C" fn(*mut u8)) {
         REGISTERED.set(true);
     }
 
-    type List = alloc::vec::PlVec<(*mut u8, unsafe extern "C" fn(*mut u8))>;
-
-    #[thread_local]
-    static DTORS: Cell<*mut List> = Cell::new(ptr::null_mut());
-    if DTORS.get().is_null() {
-        let v: Box<List> = Box::new(Vec::new());
-        DTORS.set(Box::into_raw(v));
-    }
-
     extern "C" {
         fn _tlv_atexit(dtor: unsafe extern "C" fn(*mut u8), arg: *mut u8);
     }

library/std/src/sys/windows/thread_local_dtor.rs

@@ -3,9 +3,8 @@
 
 #![unstable(feature = "thread_local_internals", issue = "none")]
 #![cfg(target_thread_local)]
-#![feature(global_co_alloc_plvec)]
 
-use core::alloc::PlVec;
+use alloc::vec::PlVec;
 
 // Using a per-thread list avoids the problems in synchronizing global state.
 #[thread_local]