CoAlloc: Using macros for config + transformations. WIP

Author: peter-lyons-kehl

library/alloc/src/lib.rs

@@ -249,6 +249,7 @@ mod boxed {
     pub use std::boxed::Box;
 }
 pub mod borrow;
+#[macro_use]
 #[unstable(feature = "global_co_alloc", issue = "none")]
 pub mod co_alloc;
 pub mod collections;

library/proc_macro/src/bridge/mod.rs

@@ -9,6 +9,7 @@
 #![deny(unsafe_code)]
 
 use crate::{Delimiter, Level, LineColumn, Spacing};
+use std::alloc::Global;
 use std::fmt;
 use std::hash::Hash;
 use std::marker;
@@ -252,14 +253,14 @@ impl<'a, T, M> Unmark for &'a mut Marked<T, M> {
     }
 }
 
-impl<T: Mark> Mark for Vec<T, Global, DEFAULT_CO_ALLOC_PREF> {
+impl<T: Mark> Mark for Vec<T, Global, {CO_ALLOC_PREF_DEFAULT!()}> {
     type Unmarked = Vec<T::Unmarked>;
     fn mark(unmarked: Self::Unmarked) -> Self {
         // Should be a no-op due to std's in-place collect optimizations.
         unmarked.into_iter().map(T::mark).collect()
     }
 }
-impl<T: Unmark> Unmark for Vec<T, Global, DEFAULT_CO_ALLOC_PREF> {
+impl<T: Unmark> Unmark for Vec<T, Global, {CO_ALLOC_PREF_DEFAULT!()}> {
     type Unmarked = Vec<T::Unmarked>;
     fn unmark(self) -> Self::Unmarked {
         // Should be a no-op due to std's in-place collect optimizations.

library/proc_macro/src/bridge/rpc.rs

@@ -5,9 +5,9 @@ use std::char;
 use std::io::Write;
 use std::num::NonZeroU32;
 use std::str;
-//use std::alloc::Global;
-use alloc::alloc::Global;
-use alloc::DEFAULT_CO_ALLOC_PREF;
+use std::alloc::Global;
+//use alloc::alloc::Global;
+//use std::CO_ALLOC_PREF_DEFAULT;
 
 pub(super) type Writer = super::buffer::Buffer;
 
@@ -228,7 +228,7 @@ impl<S> DecodeMut<'_, '_, S> for String {
     }
 }
 
-impl<S, T: Encode<S>> Encode<S> for Vec<T, Global, DEFAULT_CO_ALLOC_PREF!()> {
+impl<S, T: Encode<S>> Encode<S> for Vec<T, Global, {CO_ALLOC_PREF_DEFAULT!()}> {
     fn encode(self, w: &mut Writer, s: &mut S) {
         self.len().encode(w, s);
         for x in self {
@@ -238,7 +238,7 @@ impl<S, T: Encode<S>> Encode<S> for Vec<T, Global, DEFAULT_CO_ALLOC_PREF!()> {
 }
 
 impl<'a, S, T: for<'s> DecodeMut<'a, 's, S>> DecodeMut<'a, '_, S>
-    for Vec<T, Global, DEFAULT_CO_ALLOC_PREF>
+    for Vec<T, Global, {CO_ALLOC_PREF_DEFAULT!()}>
 {
     fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {
         let len = usize::decode(r, s);

library/proc_macro/src/diagnostic.rs

@@ -1,4 +1,5 @@
 use crate::Span;
+use std::alloc::Global;
 
 /// An enum representing a diagnostic level.
 #[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
@@ -30,7 +31,7 @@ impl MultiSpan for Span {
 }
 
 #[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
-impl MultiSpan for Vec<Span, Global, DEFAULT_CO_ALLOC_PREF> {
+impl MultiSpan for Vec<Span, Global, {CO_ALLOC_PREF_DEFAULT!()}> {
     fn into_spans(self) -> Vec<Span> {
         self
     }

library/proc_macro/src/lib.rs

@@ -22,6 +22,7 @@
 // to make it compile with rust-analyzer on stable.
 #![feature(rustc_allow_const_fn_unstable)]
 #![feature(staged_api)]
+#![feature(allocator_api)]
 #![feature(allow_internal_unstable)]
 #![feature(decl_macro)]
 #![feature(local_key_cell_methods)]
@@ -33,7 +34,9 @@
 #![feature(min_specialization)]
 #![feature(strict_provenance)]
 #![recursion_limit = "256"]
+#![feature(global_co_alloc)]
 #![feature(global_co_alloc_default)]
+#![feature(global_co_alloc_meta)]
 
 #[unstable(feature = "proc_macro_internals", issue = "27812")]
 #[doc(hidden)]

library/std/src/io/cursor.rs

@@ -6,7 +6,7 @@ use crate::io::prelude::*;
 use crate::alloc::Allocator;
 use crate::cmp;
 use crate::io::{self, BorrowedCursor, ErrorKind, IoSlice, IoSliceMut, SeekFrom};
-use core::alloc;
+use ::alloc::{co_alloc::CoAllocPref, meta_num_slots};
 
 /// A `Cursor` wraps an in-memory buffer and provides it with a
 /// [`Seek`] implementation.
@@ -398,13 +398,14 @@ fn slice_write_vectored(
 }
 
 /// Reserves the required space, and pads the vec with 0s if necessary.
+#[allow(unused_braces)]
 fn reserve_and_pad<A: Allocator, const CO_ALLOC_PREF: CoAllocPref>(
     pos_mut: &mut u64,
     vec: &mut Vec<u8, A, CO_ALLOC_PREF>,
     buf_len: usize,
 ) -> io::Result<usize>
 where
-    [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(CO_ALLOC_PREF)]:,
+    [(); {meta_num_slots!(A, CO_ALLOC_PREF)}]:,
 {
     let pos: usize = (*pos_mut).try_into().map_err(|_| {
         io::const_io_error!(
@@ -444,14 +445,15 @@ where
 
 /// Writes the slice to the vec without allocating
 /// # Safety: vec must have buf.len() spare capacity
+#[allow(unused_braces)]
 unsafe fn vec_write_unchecked<A, const CO_ALLOC_PREF: CoAllocPref>(
     pos: usize,
     vec: &mut Vec<u8, A, CO_ALLOC_PREF>,
     buf: &[u8],
 ) -> usize
 where
     A: Allocator,
-    [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(CO_ALLOC_PREF)]:,
+    [(); {meta_num_slots!(A, CO_ALLOC_PREF)}]:,
 {
     debug_assert!(vec.capacity() >= pos + buf.len());
     vec.as_mut_ptr().add(pos).copy_from(buf.as_ptr(), buf.len());
@@ -467,14 +469,15 @@ where
 /// This also allows for the vec body to be empty, but with a position of N.
 /// This means that [`Write`] will pad the vec with 0 initially,
 /// before writing anything from that point
+#[allow(unused_braces)]
 fn vec_write<A, const CO_ALLOC_PREF: CoAllocPref>(
     pos_mut: &mut u64,
     vec: &mut Vec<u8, A, CO_ALLOC_PREF>,
     buf: &[u8],
 ) -> io::Result<usize>
 where
     A: Allocator,
-    [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(CO_ALLOC_PREF)]:,
+    [(); {meta_num_slots!(A, CO_ALLOC_PREF)}]:,
 {
     let buf_len = buf.len();
     let mut pos = reserve_and_pad(pos_mut, vec, buf_len)?;
@@ -503,14 +506,15 @@ where
 /// This also allows for the vec body to be empty, but with a position of N.
 /// This means that [`Write`] will pad the vec with 0 initially,
 /// before writing anything from that point
+#[allow(unused_braces)]
 fn vec_write_vectored<A, const CO_ALLOC_PREF: CoAllocPref>(
     pos_mut: &mut u64,
     vec: &mut Vec<u8, A, CO_ALLOC_PREF>,
     bufs: &[IoSlice<'_>],
 ) -> io::Result<usize>
 where
     A: Allocator,
-    [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(CO_ALLOC_PREF)]:,
+    [(); {meta_num_slots!(A, CO_ALLOC_PREF)}]:,
 {
     // For safety reasons, we don't want this sum to overflow ever.
     // If this saturates, the reserve should panic to avoid any unsound writing.
@@ -558,10 +562,11 @@ impl Write for Cursor<&mut [u8]> {
 }
 
 #[stable(feature = "cursor_mut_vec", since = "1.25.0")]
+#[allow(unused_braces)]
 impl<A, const CO_ALLOC_PREF: CoAllocPref> Write for Cursor<&mut Vec<u8, A, CO_ALLOC_PREF>>
 where
     A: Allocator,
-    [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(CO_ALLOC_PREF)]:,
+    [(); {meta_num_slots!(A, CO_ALLOC_PREF)}]:,
 {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         vec_write(&mut self.pos, self.inner, buf)
@@ -583,10 +588,11 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
+#[allow(unused_braces)]
 impl<A, const CO_ALLOC_PREF: CoAllocPref> Write for Cursor<Vec<u8, A, CO_ALLOC_PREF>>
 where
     A: Allocator,
-    [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(CO_ALLOC_PREF)]:,
+    [(); {meta_num_slots!(A, CO_ALLOC_PREF)}]:,
 {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         vec_write(&mut self.pos, &mut self.inner, buf)

library/std/src/io/impls.rs

@@ -1,14 +1,15 @@
 #[cfg(test)]
 mod tests;
 
-use crate::alloc::{self, Allocator};
+use crate::alloc::Allocator;
 use crate::cmp;
 use crate::collections::VecDeque;
 use crate::fmt;
 use crate::io::{
     self, BorrowedCursor, BufRead, ErrorKind, IoSlice, IoSliceMut, Read, Seek, SeekFrom, Write,
 };
 use crate::mem;
+use ::alloc::{co_alloc::CoAllocPref, meta_num_slots};
 
 // =============================================================================
 // Forwarding implementations
@@ -378,9 +379,10 @@ impl Write for &mut [u8] {
 /// Write is implemented for `Vec<u8>` by appending to the vector.
 /// The vector will grow as needed.
 #[stable(feature = "rust1", since = "1.0.0")]
+#[allow(unused_braces)]
 impl<A: Allocator, const CO_ALLOC_PREF: CoAllocPref> Write for Vec<u8, A, CO_ALLOC_PREF>
 where
-    [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(CO_ALLOC_PREF)]:,
+    [(); {meta_num_slots!(A, CO_ALLOC_PREF)}]:,
 {
     #[inline]
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
@@ -417,9 +419,10 @@ where
 
 /// Read is implemented for `VecDeque<u8>` by consuming bytes from the front of the `VecDeque`.
 #[stable(feature = "vecdeque_read_write", since = "1.63.0")]
-impl<A: Allocator, const _CO_ALLOC_PREF: bool> Read for VecDeque<u8, A, _CO_ALLOC_PREF>
+#[allow(unused_braces)]
+impl<A: Allocator, const _CO_ALLOC_PREF: CoAllocPref> Read for VecDeque<u8, A, _CO_ALLOC_PREF>
 where
-    [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(_CO_ALLOC_PREF)]:,
+    [(); {meta_num_slots!(A, CO_ALLOC_PREF)}]:,
 {
     /// Fill `buf` with the contents of the "front" slice as returned by
     /// [`as_slices`][`VecDeque::as_slices`]. If the contained byte slices of the `VecDeque` are
@@ -444,9 +447,10 @@ where
 
 /// Write is implemented for `VecDeque<u8>` by appending to the `VecDeque`, growing it as needed.
 #[stable(feature = "vecdeque_read_write", since = "1.63.0")]
-impl<A: Allocator, const _CO_ALLOC_PREF: bool> Write for VecDeque<u8, A, _CO_ALLOC_PREF>
+#[allow(unused_braces)]
+impl<A: Allocator, const _CO_ALLOC_PREF: CoAllocPref> Write for VecDeque<u8, A, _CO_ALLOC_PREF>
 where
-    [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(_CO_ALLOC_PREF)]:,
+    [(); {meta_num_slots!(A, CO_ALLOC_PREF)}]:,
 {
     #[inline]
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {

library/std/src/lib.rs

@@ -217,7 +217,9 @@
 #![allow(incomplete_features)]
 #![feature(generic_const_exprs)]
 #![feature(global_co_alloc)]
+#![feature(global_co_alloc_default)]
 #![feature(global_co_alloc_plvec)]
+#![feature(global_co_alloc_meta)]
 #![warn(deprecated_in_future)]
 #![warn(missing_docs)]
 #![warn(missing_debug_implementations)]
@@ -420,6 +422,11 @@ pub mod prelude;
 pub use alloc_crate::borrow;
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use alloc_crate::boxed;
+#[unstable(feature = "global_co_alloc", issue = "none")]
+pub use alloc_crate::co_alloc;
+// @FIXME ugly - someone move this to a better place, please
+#[unstable(feature = "global_co_alloc", issue = "none")]
+pub use alloc_crate::{CO_ALLOC_PREF_DEFAULT};
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use alloc_crate::fmt;
 #[stable(feature = "rust1", since = "1.0.0")]

library/test/src/lib.rs

@@ -16,6 +16,7 @@
 
 #![unstable(feature = "test", issue = "50297")]
 #![doc(test(attr(deny(warnings))))]
+#![feature(allocator_api)]
 #![feature(internal_output_capture)]
 #![feature(is_terminal)]
 #![feature(staged_api)]
@@ -52,6 +53,7 @@ pub mod test {
 }
 
 use std::{
+    alloc::Global,
     collections::VecDeque,
     env, io,
     io::prelude::Write,
@@ -346,7 +348,7 @@ where
     };
 
     let mut running_tests: TestMap = HashMap::default();
-    let mut timeout_queue: VecDeque<TimeoutEntry> = VecDeque::new();
+    let mut timeout_queue: VecDeque<TimeoutEntry, Global> = VecDeque::new();
 
     fn get_timed_out_tests(
         running_tests: &TestMap,