diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
index 9317579f70dd5..af7a9bd2123b3 100644
--- a/compiler/rustc_ast/src/ast.rs
+++ b/compiler/rustc_ast/src/ast.rs
@@ -25,6 +25,7 @@ pub use UnsafeSource::*;
use crate::ptr::P;
use crate::token::{self, CommentKind, Delimiter};
use crate::tokenstream::{DelimSpan, LazyAttrTokenStream, TokenStream};
+use core::alloc::GlobalCoAllocMeta;
use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
use rustc_data_structures::stack::ensure_sufficient_stack;
use rustc_data_structures::sync::Lrc;
@@ -36,7 +37,6 @@ use rustc_span::{Span, DUMMY_SP};
use std::fmt;
use std::mem;
use thin_vec::{thin_vec, ThinVec};
-
/// A "Label" is an identifier of some point in sources,
/// e.g. in the following code:
///
@@ -3100,26 +3100,26 @@ mod size_asserts {
static_assert_size!(AssocItem, 104);
static_assert_size!(AssocItemKind, 32);
static_assert_size!(Attribute, 32);
- static_assert_size!(Block, 48);
- static_assert_size!(Expr, 72);
- static_assert_size!(ExprKind, 40);
- static_assert_size!(Fn, 184);
+ static_assert_size!(Block, 48 + mem::size_of::<GlobalCoAllocMeta>());
+ static_assert_size!(Expr, 72 + mem::size_of::<GlobalCoAllocMeta>());
+ static_assert_size!(ExprKind, 40 + mem::size_of::<GlobalCoAllocMeta>());
+ static_assert_size!(Fn, 184 + 2 * mem::size_of::<GlobalCoAllocMeta>());
static_assert_size!(ForeignItem, 96);
static_assert_size!(ForeignItemKind, 24);
static_assert_size!(GenericArg, 24);
- static_assert_size!(GenericBound, 72);
- static_assert_size!(Generics, 72);
- static_assert_size!(Impl, 184);
- static_assert_size!(Item, 184);
- static_assert_size!(ItemKind, 112);
+ static_assert_size!(GenericBound, 72 + mem::size_of::<GlobalCoAllocMeta>());
+ static_assert_size!(Generics, 72 + 2 * mem::size_of::<GlobalCoAllocMeta>());
+ static_assert_size!(Impl, 184 + 3 * mem::size_of::<GlobalCoAllocMeta>());
+ static_assert_size!(Item, 184 + 3 * mem::size_of::<GlobalCoAllocMeta>());
+ static_assert_size!(ItemKind, 112 + 3 * mem::size_of::<GlobalCoAllocMeta>());
static_assert_size!(LitKind, 24);
static_assert_size!(Local, 72);
static_assert_size!(MetaItemLit, 40);
static_assert_size!(Param, 40);
- static_assert_size!(Pat, 88);
+ static_assert_size!(Pat, 88 + mem::size_of::<GlobalCoAllocMeta>());
static_assert_size!(Path, 24);
static_assert_size!(PathSegment, 24);
- static_assert_size!(PatKind, 64);
+ static_assert_size!(PatKind, 64 + mem::size_of::<GlobalCoAllocMeta>());
static_assert_size!(Stmt, 32);
static_assert_size!(StmtKind, 16);
static_assert_size!(Ty, 64);
diff --git a/compiler/rustc_ast/src/lib.rs b/compiler/rustc_ast/src/lib.rs
index 9c1dfeb1a6142..cd7242449a72d 100644
--- a/compiler/rustc_ast/src/lib.rs
+++ b/compiler/rustc_ast/src/lib.rs
@@ -12,6 +12,7 @@
#![feature(box_patterns)]
#![feature(const_default_impls)]
#![feature(const_trait_impl)]
+#![feature(global_co_alloc_meta)]
#![feature(if_let_guard)]
#![feature(let_chains)]
#![feature(min_specialization)]
diff --git a/compiler/rustc_middle/src/lib.rs b/compiler/rustc_middle/src/lib.rs
index 7e4063c2ffd78..7e05e4702d55d 100644
--- a/compiler/rustc_middle/src/lib.rs
+++ b/compiler/rustc_middle/src/lib.rs
@@ -32,6 +32,7 @@
#![feature(exhaustive_patterns)]
#![feature(generators)]
#![feature(get_mut_unchecked)]
+#![feature(global_co_alloc_meta)]
#![feature(if_let_guard)]
#![feature(iter_from_generator)]
#![feature(negative_impls)]
diff --git a/compiler/rustc_middle/src/mir/mod.rs b/compiler/rustc_middle/src/mir/mod.rs
index e52b243ecf635..61a8baee62196 100644
--- a/compiler/rustc_middle/src/mir/mod.rs
+++ b/compiler/rustc_middle/src/mir/mod.rs
@@ -13,6 +13,7 @@ use crate::ty::visit::{TypeVisitable, TypeVisitor};
use crate::ty::{self, DefIdTree, List, Ty, TyCtxt};
use crate::ty::{AdtDef, InstanceDef, ScalarInt, UserTypeAnnotationIndex};
use crate::ty::{GenericArg, InternalSubsts, SubstsRef};
+use core::alloc::GlobalCoAllocMeta;
use rustc_data_structures::captures::Captures;
use rustc_errors::ErrorGuaranteed;
@@ -3060,7 +3061,7 @@ mod size_asserts {
use super::*;
use rustc_data_structures::static_assert_size;
// tidy-alphabetical-start
- static_assert_size!(BasicBlockData<'_>, 144);
+ static_assert_size!(BasicBlockData<'_>, 144 + mem::size_of::<GlobalCoAllocMeta>());
static_assert_size!(LocalDecl<'_>, 56);
static_assert_size!(Statement<'_>, 32);
static_assert_size!(StatementKind<'_>, 16);
diff --git a/compiler/rustc_middle/src/mir/syntax.rs b/compiler/rustc_middle/src/mir/syntax.rs
index 52c2b10cbbea9..36cc4fa4cce3b 100644
--- a/compiler/rustc_middle/src/mir/syntax.rs
+++ b/compiler/rustc_middle/src/mir/syntax.rs
@@ -4,6 +4,8 @@
//! The intention is that this file only contains datatype declarations, no code.
use super::{BasicBlock, Constant, Field, Local, SwitchTargets, UserTypeProjection};
+use core::alloc::GlobalCoAllocMeta;
+use core::mem;
use crate::mir::coverage::{CodeRegion, CoverageKind};
use crate::traits::Reveal;
@@ -1278,6 +1280,6 @@ mod size_asserts {
static_assert_size!(Operand<'_>, 24);
static_assert_size!(Place<'_>, 16);
static_assert_size!(PlaceElem<'_>, 24);
- static_assert_size!(Rvalue<'_>, 40);
+ static_assert_size!(Rvalue<'_>, 40 + mem::size_of::<GlobalCoAllocMeta>());
// tidy-alphabetical-end
}
diff --git a/compiler/rustc_parse/src/lib.rs b/compiler/rustc_parse/src/lib.rs
index b49a01d75ed54..1ba1049b0bc80 100644
--- a/compiler/rustc_parse/src/lib.rs
+++ b/compiler/rustc_parse/src/lib.rs
@@ -2,6 +2,7 @@
#![feature(array_windows)]
#![feature(box_patterns)]
+#![feature(global_co_alloc_meta)]
#![feature(if_let_guard)]
#![feature(iter_intersperse)]
#![feature(let_chains)]
diff --git a/compiler/rustc_parse/src/parser/attr_wrapper.rs b/compiler/rustc_parse/src/parser/attr_wrapper.rs
index b97f22417cb7b..df02751005ce8 100644
--- a/compiler/rustc_parse/src/parser/attr_wrapper.rs
+++ b/compiler/rustc_parse/src/parser/attr_wrapper.rs
@@ -1,4 +1,6 @@
use super::{Capturing, FlatToken, ForceCollect, Parser, ReplaceRange, TokenCursor, TrailingToken};
+use core::alloc::GlobalCoAllocMeta;
+use core::mem;
use rustc_ast::token::{self, Delimiter, Token, TokenKind};
use rustc_ast::tokenstream::{AttrTokenStream, AttributesData, ToAttrTokenStream};
use rustc_ast::tokenstream::{AttrTokenTree, DelimSpan, LazyAttrTokenStream, Spacing};
@@ -469,6 +471,6 @@ mod size_asserts {
use rustc_data_structures::static_assert_size;
// tidy-alphabetical-start
static_assert_size!(AttrWrapper, 16);
- static_assert_size!(LazyAttrTokenStreamImpl, 144);
+ static_assert_size!(LazyAttrTokenStreamImpl, 144 + mem::size_of::<GlobalCoAllocMeta>());
// tidy-alphabetical-end
}
diff --git a/compiler/rustc_parse/src/parser/mod.rs b/compiler/rustc_parse/src/parser/mod.rs
index ffb23b50a160d..8b66ec971b006 100644
--- a/compiler/rustc_parse/src/parser/mod.rs
+++ b/compiler/rustc_parse/src/parser/mod.rs
@@ -12,6 +12,7 @@ mod ty;
use crate::lexer::UnmatchedBrace;
pub use attr_wrapper::AttrWrapper;
+use core::alloc::GlobalCoAllocMeta;
pub use diagnostics::AttemptLocalParseRecovery;
pub(crate) use item::FnParseMode;
pub use pat::{CommaRecoveryMode, RecoverColon, RecoverComma};
@@ -168,7 +169,10 @@ pub struct Parser<'a> {
// This type is used a lot, e.g. it's cloned when matching many declarative macro rules with nonterminals. Make sure
// it doesn't unintentionally get bigger.
#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
-rustc_data_structures::static_assert_size!(Parser<'_>, 336);
+rustc_data_structures::static_assert_size!(
+ Parser<'_>,
+ 336 + 4 * mem::size_of::<GlobalCoAllocMeta>()
+);
/// Stores span information about a closure.
#[derive(Clone)]
diff --git a/compiler/rustc_trait_selection/src/lib.rs b/compiler/rustc_trait_selection/src/lib.rs
index 6fa0941036390..d35cf93347b6e 100644
--- a/compiler/rustc_trait_selection/src/lib.rs
+++ b/compiler/rustc_trait_selection/src/lib.rs
@@ -15,6 +15,7 @@
#![feature(box_patterns)]
#![feature(control_flow_enum)]
#![feature(drain_filter)]
+#![feature(global_co_alloc_meta)]
#![feature(hash_drain_filter)]
#![feature(let_chains)]
#![feature(if_let_guard)]
diff --git a/compiler/rustc_trait_selection/src/traits/fulfill.rs b/compiler/rustc_trait_selection/src/traits/fulfill.rs
index 76a755ed9e09d..378419868c427 100644
--- a/compiler/rustc_trait_selection/src/traits/fulfill.rs
+++ b/compiler/rustc_trait_selection/src/traits/fulfill.rs
@@ -1,4 +1,6 @@
use crate::infer::{InferCtxt, TyOrConstInferVar};
+use core::alloc::GlobalCoAllocMeta;
+use core::mem;
use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::obligation_forest::ProcessResult;
use rustc_data_structures::obligation_forest::{Error, ForestObligation, Outcome};
@@ -80,7 +82,7 @@ pub struct PendingPredicateObligation<'tcx> {
// `PendingPredicateObligation` is used a lot. Make sure it doesn't unintentionally get bigger.
#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
-static_assert_size!(PendingPredicateObligation<'_>, 72);
+static_assert_size!(PendingPredicateObligation<'_>, 72 + mem::size_of::<GlobalCoAllocMeta>());
impl<'a, 'tcx> FulfillmentContext<'tcx> {
/// Creates a new fulfillment context.
diff --git a/library/alloc/src/borrow.rs b/library/alloc/src/borrow.rs
index 83a1385599bec..b733651c09721 100644
--- a/library/alloc/src/borrow.rs
+++ b/library/alloc/src/borrow.rs
@@ -11,16 +11,18 @@ use core::ops::{Add, AddAssign};
#[stable(feature = "rust1", since = "1.0.0")]
pub use core::borrow::{Borrow, BorrowMut};
-use crate::fmt;
+use crate::{fmt, DEFAULT_COOP_PREFERRED, alloc::Global};
#[cfg(not(no_global_oom_handling))]
use crate::string::String;
use Cow::*;
#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, B: ?Sized> Borrow<B> for Cow<'a, B>
+impl<'a, B: ?Sized, const COOP_PREFERRED: bool> Borrow<B> for Cow<'a, B, COOP_PREFERRED>
where
- B: ToOwned,
+ B: ToOwned<COOP_PREFERRED>,
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+
{
fn borrow(&self) -> &B {
&**self
@@ -35,7 +37,11 @@ where
/// from any borrow of a given type.
#[cfg_attr(not(test), rustc_diagnostic_item = "ToOwned")]
#[stable(feature = "rust1", since = "1.0.0")]
-pub trait ToOwned {
+#[allow(unused_braces)]
+pub trait ToOwned<const COOP_PREFERRED: bool = { DEFAULT_COOP_PREFERRED!() } >
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
/// The resulting type after obtaining ownership.
#[stable(feature = "rust1", since = "1.0.0")]
type Owned: Borrow<Self>;
@@ -79,9 +85,10 @@ pub trait ToOwned {
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ToOwned for T
+impl<T, const COOP_PREFERRED: bool> ToOwned<COOP_PREFERRED> for T
where
T: Clone,
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
{
type Owned = T;
fn to_owned(&self) -> T {
@@ -176,9 +183,11 @@ where
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[cfg_attr(not(test), rustc_diagnostic_item = "Cow")]
-pub enum Cow<'a, B: ?Sized + 'a>
+#[allow(unused_braces)]
+pub enum Cow<'a, B: ?Sized + 'a, const COOP_PREFERRED: bool = { DEFAULT_COOP_PREFERRED!() }>
where
- B: ToOwned,
+ B: ToOwned<COOP_PREFERRED>,
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
{
/// Borrowed data.
#[stable(feature = "rust1", since = "1.0.0")]
@@ -186,11 +195,14 @@ where
/// Owned data.
#[stable(feature = "rust1", since = "1.0.0")]
- Owned(#[stable(feature = "rust1", since = "1.0.0")] <B as ToOwned>::Owned),
+ Owned(#[stable(feature = "rust1", since = "1.0.0")] <B as ToOwned<COOP_PREFERRED>>::Owned),
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<B: ?Sized + ToOwned> Clone for Cow<'_, B> {
+impl<B: ?Sized + ToOwned<COOP_PREFERRED>, const COOP_PREFERRED: bool> Clone for Cow<'_, B, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
fn clone(&self) -> Self {
match *self {
Borrowed(b) => Borrowed(b),
@@ -209,7 +221,10 @@ impl<B: ?Sized + ToOwned> Clone for Cow<'_, B> {
}
}
-impl<B: ?Sized + ToOwned> Cow<'_, B> {
+impl<B: ?Sized + ToOwned<COOP_PREFERRED>, const COOP_PREFERRED: bool> Cow<'_, B, COOP_PREFERRED>
+where
+[(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
/// Returns true if the data is borrowed, i.e. if `to_mut` would require additional work.
///
/// # Examples
@@ -271,7 +286,7 @@ impl<B: ?Sized + ToOwned> Cow<'_, B> {
/// );
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn to_mut(&mut self) -> &mut <B as ToOwned>::Owned {
+ pub fn to_mut(&mut self) -> &mut <B as ToOwned<COOP_PREFERRED>>::Owned {
match *self {
Borrowed(borrowed) => {
*self = Owned(borrowed.to_owned());
@@ -319,7 +334,7 @@ impl<B: ?Sized + ToOwned> Cow<'_, B> {
/// );
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn into_owned(self) -> <B as ToOwned>::Owned {
+ pub fn into_owned(self) -> <B as ToOwned<COOP_PREFERRED>>::Owned {
match self {
Borrowed(borrowed) => borrowed.to_owned(),
Owned(owned) => owned,
@@ -329,9 +344,10 @@ impl<B: ?Sized + ToOwned> Cow<'_, B> {
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_deref", issue = "88955")]
-impl<B: ?Sized + ToOwned> const Deref for Cow<'_, B>
+impl<B: ?Sized + ToOwned<COOP_PREFERRED>, const COOP_PREFERRED: bool> const Deref for Cow<'_, B, COOP_PREFERRED>
where
B::Owned: ~const Borrow<B>,
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
{
type Target = B;
@@ -344,12 +360,18 @@ where
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<B: ?Sized> Eq for Cow<'_, B> where B: Eq + ToOwned {}
+impl<B: ?Sized, const COOP_PREFERRED: bool> Eq for Cow<'_, B, COOP_PREFERRED>
+where
+ B: Eq + ToOwned<COOP_PREFERRED>,
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+
+ {}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<B: ?Sized> Ord for Cow<'_, B>
+impl<B: ?Sized, const COOP_PREFERRED: bool> Ord for Cow<'_, B, COOP_PREFERRED>
where
- B: Ord + ToOwned,
+ B: Ord + ToOwned<COOP_PREFERRED>,
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
{
#[inline]
fn cmp(&self, other: &Self) -> Ordering {
@@ -358,32 +380,35 @@ where
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, 'b, B: ?Sized, C: ?Sized> PartialEq<Cow<'b, C>> for Cow<'a, B>
+impl<'a, 'b, B: ?Sized, C: ?Sized, const COOP_PREFERRED: bool> PartialEq<Cow<'b, C, COOP_PREFERRED>> for Cow<'a, B, COOP_PREFERRED>
where
- B: PartialEq<C> + ToOwned,
- C: ToOwned,
+ B: PartialEq<C> + ToOwned<COOP_PREFERRED>,
+ C: ToOwned<COOP_PREFERRED>,
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
{
#[inline]
- fn eq(&self, other: &Cow<'b, C>) -> bool {
+ fn eq(&self, other: &Cow<'b, C, COOP_PREFERRED>) -> bool {
PartialEq::eq(&**self, &**other)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, B: ?Sized> PartialOrd for Cow<'a, B>
+impl<'a, B: ?Sized, const COOP_PREFERRED: bool> PartialOrd for Cow<'a, B, COOP_PREFERRED>
where
- B: PartialOrd + ToOwned,
+ B: PartialOrd + ToOwned<COOP_PREFERRED>,
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
{
#[inline]
- fn partial_cmp(&self, other: &Cow<'a, B>) -> Option<Ordering> {
+ fn partial_cmp(&self, other: &Cow<'a, B, COOP_PREFERRED>) -> Option<Ordering> {
PartialOrd::partial_cmp(&**self, &**other)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<B: ?Sized> fmt::Debug for Cow<'_, B>
+impl<B: ?Sized, const COOP_PREFERRED: bool> fmt::Debug for Cow<'_, B, COOP_PREFERRED>
where
- B: fmt::Debug + ToOwned<Owned: fmt::Debug>,
+ B: fmt::Debug + ToOwned<COOP_PREFERRED, Owned: fmt::Debug>,
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
@@ -394,9 +419,10 @@ where
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<B: ?Sized> fmt::Display for Cow<'_, B>
+impl<B: ?Sized, const COOP_PREFERRED: bool> fmt::Display for Cow<'_, B, COOP_PREFERRED>
where
- B: fmt::Display + ToOwned<Owned: fmt::Display>,
+ B: fmt::Display + ToOwned<COOP_PREFERRED, Owned: fmt::Display>,
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match *self {
@@ -407,20 +433,22 @@ where
}
#[stable(feature = "default", since = "1.11.0")]
-impl<B: ?Sized> Default for Cow<'_, B>
+impl<B: ?Sized, const COOP_PREFERRED: bool> Default for Cow<'_, B, COOP_PREFERRED>
where
- B: ToOwned<Owned: Default>,
+ B: ToOwned<COOP_PREFERRED, Owned: Default>,
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
{
/// Creates an owned Cow<'a, B> with the default value for the contained owned value.
fn default() -> Self {
- Owned(<B as ToOwned>::Owned::default())
+ Owned(<B as ToOwned<COOP_PREFERRED>>::Owned::default())
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<B: ?Sized> Hash for Cow<'_, B>
+impl<B: ?Sized, const COOP_PREFERRED: bool> Hash for Cow<'_, B, COOP_PREFERRED>
where
- B: Hash + ToOwned,
+ B: Hash + ToOwned<COOP_PREFERRED>,
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
{
#[inline]
fn hash<H: Hasher>(&self, state: &mut H) {
@@ -429,7 +457,9 @@ where
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: ?Sized + ToOwned> AsRef<T> for Cow<'_, T> {
+impl<T: ?Sized + ToOwned<COOP_PREFERRED>, const COOP_PREFERRED: bool> AsRef<T> for Cow<'_, T, COOP_PREFERRED>
+where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
fn as_ref(&self) -> &T {
self
}
@@ -437,8 +467,10 @@ impl<T: ?Sized + ToOwned> AsRef<T> for Cow<'_, T> {
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "cow_add", since = "1.14.0")]
-impl<'a> Add<&'a str> for Cow<'a, str> {
- type Output = Cow<'a, str>;
+impl<'a, const COOP_PREFERRED: bool> Add<&'a str> for Cow<'a, str, COOP_PREFERRED>
+where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
+ type Output = Cow<'a, str, COOP_PREFERRED>;
#[inline]
fn add(mut self, rhs: &'a str) -> Self::Output {
@@ -449,11 +481,13 @@ impl<'a> Add<&'a str> for Cow<'a, str> {
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "cow_add", since = "1.14.0")]
-impl<'a> Add<Cow<'a, str>> for Cow<'a, str> {
- type Output = Cow<'a, str>;
+impl<'a, const COOP_PREFERRED: bool> Add<Cow<'a, str, COOP_PREFERRED>> for Cow<'a, str, COOP_PREFERRED>
+where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
+ type Output = Cow<'a, str, COOP_PREFERRED>;
#[inline]
- fn add(mut self, rhs: Cow<'a, str>) -> Self::Output {
+ fn add(mut self, rhs: Cow<'a, str, COOP_PREFERRED>) -> Self::Output {
self += rhs;
self
}
@@ -461,7 +495,9 @@ impl<'a> Add<Cow<'a, str>> for Cow<'a, str> {
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "cow_add", since = "1.14.0")]
-impl<'a> AddAssign<&'a str> for Cow<'a, str> {
+impl<'a, const COOP_PREFERRED: bool> AddAssign<&'a str> for Cow<'a, str, COOP_PREFERRED>
+where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
fn add_assign(&mut self, rhs: &'a str) {
if self.is_empty() {
*self = Cow::Borrowed(rhs)
@@ -478,8 +514,10 @@ impl<'a> AddAssign<&'a str> for Cow<'a, str> {
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "cow_add", since = "1.14.0")]
-impl<'a> AddAssign<Cow<'a, str>> for Cow<'a, str> {
- fn add_assign(&mut self, rhs: Cow<'a, str>) {
+impl<'a, const COOP_PREFERRED: bool> AddAssign<Cow<'a, str, COOP_PREFERRED>> for Cow<'a, str, COOP_PREFERRED>
+where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
+ fn add_assign(&mut self, rhs: Cow<'a, str, COOP_PREFERRED>) {
if self.is_empty() {
*self = rhs
} else if !rhs.is_empty() {
diff --git a/library/alloc/src/boxed.rs b/library/alloc/src/boxed.rs
index a563b2587236c..3806d42973c86 100644
--- a/library/alloc/src/boxed.rs
+++ b/library/alloc/src/boxed.rs
@@ -641,7 +641,8 @@ impl<T> Box<[T]> {
#[unstable(feature = "new_uninit", issue = "63291")]
#[must_use]
pub fn new_uninit_slice(len: usize) -> Box<[mem::MaybeUninit<T>]> {
- unsafe { RawVec::with_capacity(len).into_box(len) }
+ // false = no need for co-alloc metadata, since it would get lost once converted to Box.
+ unsafe { RawVec::<T, Global, false>::with_capacity(len).into_box(len) }
}
/// Constructs a new boxed slice with uninitialized contents, with the memory
@@ -666,7 +667,8 @@ impl<T> Box<[T]> {
#[unstable(feature = "new_uninit", issue = "63291")]
#[must_use]
pub fn new_zeroed_slice(len: usize) -> Box<[mem::MaybeUninit<T>]> {
- unsafe { RawVec::with_capacity_zeroed(len).into_box(len) }
+ // false = no need for co-alloc metadata, since it would get lost once converted to Box.
+ unsafe { RawVec::<T, Global, false>::with_capacity_zeroed(len).into_box(len) }
}
/// Constructs a new boxed slice with uninitialized contents. Returns an error if
@@ -698,7 +700,12 @@ impl<T> Box<[T]> {
Err(_) => return Err(AllocError),
};
let ptr = Global.allocate(layout)?;
- Ok(RawVec::from_raw_parts_in(ptr.as_mut_ptr() as *mut _, len, Global).into_box(len))
+ Ok(RawVec::<T, Global, false>::from_raw_parts_in(
+ ptr.as_mut_ptr() as *mut _,
+ len,
+ Global,
+ )
+ .into_box(len))
}
}
@@ -730,12 +737,20 @@ impl<T> Box<[T]> {
Err(_) => return Err(AllocError),
};
let ptr = Global.allocate_zeroed(layout)?;
- Ok(RawVec::from_raw_parts_in(ptr.as_mut_ptr() as *mut _, len, Global).into_box(len))
+ Ok(RawVec::<T, Global, false>::from_raw_parts_in(
+ ptr.as_mut_ptr() as *mut _,
+ len,
+ Global,
+ )
+ .into_box(len))
}
}
}
-impl<T, A: Allocator> Box<[T], A> {
+impl<T, A: Allocator> Box<[T], A>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots::<A>()]:,
+{
/// Constructs a new boxed slice with uninitialized contents in the provided allocator.
///
/// # Examples
@@ -762,8 +777,16 @@ impl<T, A: Allocator> Box<[T], A> {
#[unstable(feature = "allocator_api", issue = "32838")]
// #[unstable(feature = "new_uninit", issue = "63291")]
#[must_use]
- pub fn new_uninit_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit<T>], A> {
- unsafe { RawVec::with_capacity_in(len, alloc).into_box(len) }
+ #[allow(unused_braces)]
+ pub fn new_uninit_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit<T>], A>
+ where
+ // false = no need for co-alloc metadata, since it would get lost once converted to Box.
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(false)]:,
+ {
+ unsafe {
+ RawVec::<T, A, false>::with_capacity_in(len, alloc)
+ .into_box(len)
+ }
}
/// Constructs a new boxed slice with uninitialized contents in the provided allocator,
@@ -790,8 +813,18 @@ impl<T, A: Allocator> Box<[T], A> {
#[unstable(feature = "allocator_api", issue = "32838")]
// #[unstable(feature = "new_uninit", issue = "63291")]
#[must_use]
- pub fn new_zeroed_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit<T>], A> {
- unsafe { RawVec::with_capacity_zeroed_in(len, alloc).into_box(len) }
+ #[allow(unused_braces)]
+ pub fn new_zeroed_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit<T>], A>
+ where
+ // false = no need for co-alloc metadata, since it would get lost once converted to Box.
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(false)]:,
+ {
+ unsafe {
+ RawVec::<T, A, false>::with_capacity_zeroed_in(
+ len, alloc,
+ )
+ .into_box(len)
+ }
}
}
@@ -1496,7 +1529,8 @@ impl<T: Copy> From<&[T]> for Box<[T]> {
/// ```
fn from(slice: &[T]) -> Box<[T]> {
let len = slice.len();
- let buf = RawVec::with_capacity(len);
+ // false = no need for co-alloc metadata, since it would get lost once converted to Box.
+ let buf = RawVec::<T, Global, false>::with_capacity(len);
unsafe {
ptr::copy_nonoverlapping(slice.as_ptr(), buf.ptr(), len);
buf.into_box(slice.len()).assume_init()
@@ -1661,8 +1695,12 @@ impl<T, const N: usize> TryFrom<Box<[T]>> for Box<[T; N]> {
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "boxed_array_try_from_vec", since = "1.66.0")]
-impl<T, const N: usize> TryFrom<Vec<T>> for Box<[T; N]> {
- type Error = Vec<T>;
+impl<T, const N: usize, const COOP_PREFERRED: bool> TryFrom<Vec<T, Global, COOP_PREFERRED>>
+ for Box<[T; N]>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
+ type Error = Vec<T, Global, COOP_PREFERRED>;
/// Attempts to convert a `Vec<T>` into a `Box<[T; N]>`.
///
@@ -1682,7 +1720,7 @@ impl<T, const N: usize> TryFrom<Vec<T>> for Box<[T; N]> {
/// let state: Box<[f32; 100]> = vec![1.0; 100].try_into().unwrap();
/// assert_eq!(state.len(), 100);
/// ```
- fn try_from(vec: Vec<T>) -> Result<Self, Self::Error> {
+ fn try_from(vec: Vec<T, Global, COOP_PREFERRED>) -> Result<Self, Self::Error> {
if vec.len() == N {
let boxed_slice = vec.into_boxed_slice();
Ok(unsafe { boxed_slice_as_array_unchecked(boxed_slice) })
@@ -2019,10 +2057,14 @@ impl<I> FromIterator<I> for Box<[I]> {
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "box_slice_clone", since = "1.3.0")]
-impl<T: Clone, A: Allocator + Clone> Clone for Box<[T], A> {
+impl<T: Clone, A: Allocator + Clone> Clone for Box<[T], A>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(false)]:,
+{
fn clone(&self) -> Self {
let alloc = Box::allocator(self).clone();
- self.to_vec_in(alloc).into_boxed_slice()
+ // false = no need for co-alloc metadata, since it would get lost once converted to the boxed slice.
+ self.to_vec_in::<A, false>(alloc).into_boxed_slice()
}
fn clone_from(&mut self, other: &Self) {
diff --git a/library/alloc/src/collections/binary_heap/mod.rs b/library/alloc/src/collections/binary_heap/mod.rs
index 0b73b1af4eb35..1290a449facd2 100644
--- a/library/alloc/src/collections/binary_heap/mod.rs
+++ b/library/alloc/src/collections/binary_heap/mod.rs
@@ -143,16 +143,19 @@
#![allow(missing_docs)]
#![stable(feature = "rust1", since = "1.0.0")]
-use core::fmt;
use core::iter::{FromIterator, FusedIterator, InPlaceIterable, SourceIter, TrustedLen};
use core::mem::{self, swap, ManuallyDrop};
use core::num::NonZeroUsize;
use core::ops::{Deref, DerefMut};
use core::ptr;
+use core::fmt;
+
+use crate::alloc::Global;
use crate::collections::TryReserveError;
use crate::slice;
use crate::vec::{self, AsVecIntoIter, Vec};
+use crate::DEFAULT_COOP_PREFERRED;
use super::SpecExtend;
@@ -1241,7 +1244,8 @@ impl<T> BinaryHeap<T> {
/// ```
#[inline]
#[stable(feature = "drain", since = "1.6.0")]
- pub fn drain(&mut self) -> Drain<'_, T> {
+ #[allow(unused_braces)]
+ pub fn drain(&mut self) -> Drain<'_, T, { SHORT_TERM_VEC_PREFERS_COOP!() }> {
Drain { iter: self.data.drain(..) }
}
@@ -1521,12 +1525,18 @@ unsafe impl<T: Ord> TrustedLen for IntoIterSorted<T> {}
/// [`drain`]: BinaryHeap::drain
#[stable(feature = "drain", since = "1.6.0")]
#[derive(Debug)]
-pub struct Drain<'a, T: 'a> {
- iter: vec::Drain<'a, T>,
+pub struct Drain<'a, T: 'a, const COOP_PREFERRED: bool>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
+ iter: vec::Drain<'a, T, Global, COOP_PREFERRED>,
}
#[stable(feature = "drain", since = "1.6.0")]
-impl<T> Iterator for Drain<'_, T> {
+impl<T, const COOP_PREFERRED: bool> Iterator for Drain<'_, T, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
type Item = T;
#[inline]
@@ -1541,7 +1551,10 @@ impl<T> Iterator for Drain<'_, T> {
}
#[stable(feature = "drain", since = "1.6.0")]
-impl<T> DoubleEndedIterator for Drain<'_, T> {
+impl<T, const COOP_PREFERRED: bool> DoubleEndedIterator for Drain<'_, T, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
#[inline]
fn next_back(&mut self) -> Option<T> {
self.iter.next_back()
@@ -1549,14 +1562,20 @@ impl<T> DoubleEndedIterator for Drain<'_, T> {
}
#[stable(feature = "drain", since = "1.6.0")]
-impl<T> ExactSizeIterator for Drain<'_, T> {
+impl<T, const COOP_PREFERRED: bool> ExactSizeIterator for Drain<'_, T, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
fn is_empty(&self) -> bool {
self.iter.is_empty()
}
}
#[stable(feature = "fused", since = "1.26.0")]
-impl<T> FusedIterator for Drain<'_, T> {}
+impl<T, const COOP_PREFERRED: bool> FusedIterator for Drain<'_, T, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{}
/// A draining iterator over the elements of a `BinaryHeap`.
///
@@ -1644,7 +1663,8 @@ impl<T: Ord, const N: usize> From<[T; N]> for BinaryHeap<T> {
}
#[stable(feature = "binary_heap_extras_15", since = "1.5.0")]
-impl<T> From<BinaryHeap<T>> for Vec<T> {
+#[allow(unused_braces)]
+impl<T> From<BinaryHeap<T>> for Vec<T, Global, {DEFAULT_COOP_PREFERRED!()}> {
/// Converts a `BinaryHeap<T>` into a `Vec<T>`.
///
/// This conversion requires no data movement or allocation, and has
diff --git a/library/alloc/src/collections/btree/node.rs b/library/alloc/src/collections/btree/node.rs
index 6912466448fab..ec616fdf79fcf 100644
--- a/library/alloc/src/collections/btree/node.rs
+++ b/library/alloc/src/collections/btree/node.rs
@@ -319,7 +319,8 @@ impl<BorrowType: marker::BorrowType, K, V, Type> NodeRef<BorrowType, K, V, Type>
self,
) -> Result<Handle<NodeRef<BorrowType, K, V, marker::Internal>, marker::Edge>, Self> {
const {
- assert!(BorrowType::TRAVERSAL_PERMIT);
+ //@FIXME uncomment once compilable
+ //assert!(BorrowType::TRAVERSAL_PERMIT);
}
// We need to use raw pointers to nodes because, if BorrowType is marker::ValMut,
@@ -1007,7 +1008,8 @@ impl<BorrowType: marker::BorrowType, K, V>
/// both, upon success, do nothing.
pub fn descend(self) -> NodeRef<BorrowType, K, V, marker::LeafOrInternal> {
const {
- assert!(BorrowType::TRAVERSAL_PERMIT);
+ // @FIXME uncomment once compilable
+ //assert!(BorrowType::TRAVERSAL_PERMIT);
}
// We need to use raw pointers to nodes because, if BorrowType is
diff --git a/library/alloc/src/collections/vec_deque/drain.rs b/library/alloc/src/collections/vec_deque/drain.rs
index 89feb361ddc11..cd0e6caace3f4 100644
--- a/library/alloc/src/collections/vec_deque/drain.rs
+++ b/library/alloc/src/collections/vec_deque/drain.rs
@@ -2,7 +2,7 @@ use core::iter::FusedIterator;
use core::marker::PhantomData;
use core::mem::{self, SizedTypeProperties};
use core::ptr::NonNull;
-use core::{fmt, ptr};
+use core::{alloc, fmt, ptr};
use crate::alloc::{Allocator, Global};
@@ -15,14 +15,18 @@ use super::VecDeque;
///
/// [`drain`]: VecDeque::drain
#[stable(feature = "drain", since = "1.6.0")]
+#[allow(unused_braces)]
pub struct Drain<
'a,
T: 'a,
#[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
-> {
+ const COOP_PREFERRED: bool = { SHORT_TERM_VEC_PREFERS_COOP!() },
+> where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
// We can't just use a &mut VecDeque<T, A>, as that would make Drain invariant over T
// and we want it to be covariant instead
- deque: NonNull<VecDeque<T, A>>,
+ deque: NonNull<VecDeque<T, A, COOP_PREFERRED>>,
// drain_start is stored in deque.len
drain_len: usize,
// index into the logical array, not the physical one (always lies in [0..deque.len))
@@ -34,9 +38,12 @@ pub struct Drain<
_marker: PhantomData<&'a T>,
}
-impl<'a, T, A: Allocator> Drain<'a, T, A> {
+impl<'a, T, A: Allocator, const COOP_PREFERRED: bool> Drain<'a, T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
pub(super) unsafe fn new(
- deque: &'a mut VecDeque<T, A>,
+ deque: &'a mut VecDeque<T, A, COOP_PREFERRED>,
drain_start: usize,
drain_len: usize,
) -> Self {
@@ -88,7 +95,11 @@ impl<'a, T, A: Allocator> Drain<'a, T, A> {
}
#[stable(feature = "collection_debug", since = "1.17.0")]
-impl<T: fmt::Debug, A: Allocator> fmt::Debug for Drain<'_, T, A> {
+impl<T: fmt::Debug, A: Allocator, const COOP_PREFERRED: bool> fmt::Debug
+ for Drain<'_, T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_tuple("Drain")
.field(&self.drain_len)
@@ -100,16 +111,37 @@ impl<T: fmt::Debug, A: Allocator> fmt::Debug for Drain<'_, T, A> {
}
#[stable(feature = "drain", since = "1.6.0")]
-unsafe impl<T: Sync, A: Allocator + Sync> Sync for Drain<'_, T, A> {}
+unsafe impl<T: Sync, A: Allocator + Sync, const COOP_PREFERRED: bool> Sync
+ for Drain<'_, T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
+}
#[stable(feature = "drain", since = "1.6.0")]
-unsafe impl<T: Send, A: Allocator + Send> Send for Drain<'_, T, A> {}
+unsafe impl<T: Send, A: Allocator + Send, const COOP_PREFERRED: bool> Send
+ for Drain<'_, T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
+}
#[stable(feature = "drain", since = "1.6.0")]
-impl<T, A: Allocator> Drop for Drain<'_, T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> Drop for Drain<'_, T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
fn drop(&mut self) {
- struct DropGuard<'r, 'a, T, A: Allocator>(&'r mut Drain<'a, T, A>);
+ struct DropGuard<'r, 'a, T, A: Allocator, const COOP_PREFERRED: bool>(
+ &'r mut Drain<'a, T, A, COOP_PREFERRED>,
+ )
+ where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:;
- impl<'r, 'a, T, A: Allocator> Drop for DropGuard<'r, 'a, T, A> {
+ impl<'r, 'a, T, A: Allocator, const COOP_PREFERRED: bool> Drop
+ for DropGuard<'r, 'a, T, A, COOP_PREFERRED>
+ where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+ {
fn drop(&mut self) {
if self.0.remaining != 0 {
unsafe {
@@ -190,7 +222,10 @@ impl<T, A: Allocator> Drop for Drain<'_, T, A> {
}
#[stable(feature = "drain", since = "1.6.0")]
-impl<T, A: Allocator> Iterator for Drain<'_, T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> Iterator for Drain<'_, T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
type Item = T;
#[inline]
@@ -212,7 +247,11 @@ impl<T, A: Allocator> Iterator for Drain<'_, T, A> {
}
#[stable(feature = "drain", since = "1.6.0")]
-impl<T, A: Allocator> DoubleEndedIterator for Drain<'_, T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> DoubleEndedIterator
+ for Drain<'_, T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
#[inline]
fn next_back(&mut self) -> Option<T> {
if self.remaining == 0 {
@@ -225,7 +264,15 @@ impl<T, A: Allocator> DoubleEndedIterator for Drain<'_, T, A> {
}
#[stable(feature = "drain", since = "1.6.0")]
-impl<T, A: Allocator> ExactSizeIterator for Drain<'_, T, A> {}
+impl<T, A: Allocator, const COOP_PREFERRED: bool> ExactSizeIterator
+ for Drain<'_, T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
+}
#[stable(feature = "fused", since = "1.26.0")]
-impl<T, A: Allocator> FusedIterator for Drain<'_, T, A> {}
+impl<T, A: Allocator, const COOP_PREFERRED: bool> FusedIterator for Drain<'_, T, A, COOP_PREFERRED> where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:
+{
+}
diff --git a/library/alloc/src/collections/vec_deque/into_iter.rs b/library/alloc/src/collections/vec_deque/into_iter.rs
index e54880e865230..38aba07585a90 100644
--- a/library/alloc/src/collections/vec_deque/into_iter.rs
+++ b/library/alloc/src/collections/vec_deque/into_iter.rs
@@ -1,5 +1,5 @@
-use core::fmt;
use core::iter::{FusedIterator, TrustedLen};
+use core::{alloc, fmt};
use crate::alloc::{Allocator, Global};
@@ -17,29 +17,41 @@ use super::VecDeque;
pub struct IntoIter<
T,
#[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
-> {
- inner: VecDeque<T, A>,
+ const COOP_PREFERRED: bool = true,
+> where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
+ inner: VecDeque<T, A, COOP_PREFERRED>,
}
-impl<T, A: Allocator> IntoIter<T, A> {
- pub(super) fn new(inner: VecDeque<T, A>) -> Self {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> IntoIter<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
+ pub(super) fn new(inner: VecDeque<T, A, COOP_PREFERRED>) -> Self {
IntoIter { inner }
}
- pub(super) fn into_vecdeque(self) -> VecDeque<T, A> {
+ pub(super) fn into_vecdeque(self) -> VecDeque<T, A, COOP_PREFERRED> {
self.inner
}
}
#[stable(feature = "collection_debug", since = "1.17.0")]
-impl<T: fmt::Debug, A: Allocator> fmt::Debug for IntoIter<T, A> {
+impl<T: fmt::Debug, A: Allocator, const COOP_PREFERRED: bool> fmt::Debug for IntoIter<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_tuple("IntoIter").field(&self.inner).finish()
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T, A: Allocator> Iterator for IntoIter<T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> Iterator for IntoIter<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
type Item = T;
#[inline]
@@ -55,7 +67,10 @@ impl<T, A: Allocator> Iterator for IntoIter<T, A> {
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T, A: Allocator> DoubleEndedIterator for IntoIter<T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> DoubleEndedIterator for IntoIter<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
#[inline]
fn next_back(&mut self) -> Option<T> {
self.inner.pop_back()
@@ -63,14 +78,25 @@ impl<T, A: Allocator> DoubleEndedIterator for IntoIter<T, A> {
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T, A: Allocator> ExactSizeIterator for IntoIter<T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> ExactSizeIterator for IntoIter<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
fn is_empty(&self) -> bool {
self.inner.is_empty()
}
}
#[stable(feature = "fused", since = "1.26.0")]
-impl<T, A: Allocator> FusedIterator for IntoIter<T, A> {}
+impl<T, A: Allocator, const COOP_PREFERRED: bool> FusedIterator for IntoIter<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
+}
#[unstable(feature = "trusted_len", issue = "37572")]
-unsafe impl<T, A: Allocator> TrustedLen for IntoIter<T, A> {}
+unsafe impl<T, A: Allocator, const COOP_PREFERRED : bool> TrustedLen for IntoIter<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
+}
diff --git a/library/alloc/src/collections/vec_deque/macros.rs b/library/alloc/src/collections/vec_deque/macros.rs
index 5c7913073fe87..68ee43152b5b5 100644
--- a/library/alloc/src/collections/vec_deque/macros.rs
+++ b/library/alloc/src/collections/vec_deque/macros.rs
@@ -1,9 +1,10 @@
macro_rules! __impl_slice_eq1 {
([$($vars:tt)*] $lhs:ty, $rhs:ty, $($constraints:tt)*) => {
#[stable(feature = "vec_deque_partial_eq_slice", since = "1.17.0")]
- impl<T, U, A: Allocator, $($vars)*> PartialEq<$rhs> for $lhs
+ impl<T, U, A: Allocator, const COOP_PREFERRED: bool, $($vars)*> PartialEq<$rhs> for $lhs
where
T: PartialEq<U>,
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
$($constraints)*
{
fn eq(&self, other: &$rhs) -> bool {
diff --git a/library/alloc/src/collections/vec_deque/mod.rs b/library/alloc/src/collections/vec_deque/mod.rs
index 451e4936bc50e..3a64f52ffb925 100644
--- a/library/alloc/src/collections/vec_deque/mod.rs
+++ b/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.
+#![feature(global_co_alloc)]
#![stable(feature = "rust1", since = "1.0.0")]
-
+use crate::DEFAULT_COOP_PREFERRED;
+use core::alloc;
use core::cmp::{self, Ordering};
use core::fmt;
use core::hash::{Hash, Hasher};
@@ -91,10 +93,14 @@ mod tests;
#[cfg_attr(not(test), rustc_diagnostic_item = "VecDeque")]
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_insignificant_dtor]
+#[allow(unused_braces)]
pub struct VecDeque<
T,
#[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
-> {
+ const COOP_PREFERRED: bool = {DEFAULT_COOP_PREFERRED!()},
+> where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
// `self[0]`, if it exists, is `buf[head]`.
// `head < buf.capacity()`, unless `buf.capacity() == 0` when `head == 0`.
head: usize,
@@ -102,11 +108,15 @@ pub struct VecDeque<
// if `len == 0`, the exact value of `head` is unimportant.
// if `T` is zero-Sized, then `self.len <= usize::MAX`, otherwise `self.len <= isize::MAX as usize`.
len: usize,
- buf: RawVec<T, A>,
+ buf: RawVec<T, A, COOP_PREFERRED>,
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Clone, A: Allocator + Clone> Clone for VecDeque<T, A> {
+impl<T: Clone, A: Allocator + Clone, const COOP_PREFERRED: bool> Clone
+ for VecDeque<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
fn clone(&self) -> Self {
let mut deq = Self::with_capacity_in(self.len(), self.allocator().clone());
deq.extend(self.iter().cloned());
@@ -120,7 +130,11 @@ 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, const COOP_PREFERRED: bool> Drop
+ for VecDeque<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
fn drop(&mut self) {
/// Runs the destructor for all items in the slice when it gets dropped (normally or
/// during unwinding).
@@ -145,15 +159,21 @@ unsafe impl<#[may_dangle] T, A: Allocator> Drop for VecDeque<T, A> {
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> Default for VecDeque<T> {
+impl<T, const COOP_PREFERRED: bool> Default for VecDeque<T, Global, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
/// Creates an empty deque.
#[inline]
- fn default() -> VecDeque<T> {
- VecDeque::new()
+ fn default() -> VecDeque<T, Global, COOP_PREFERRED> {
+ VecDeque::<T, Global, COOP_PREFERRED>::new()
}
}
-impl<T, A: Allocator> VecDeque<T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> VecDeque<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
/// Marginally more convenient
#[inline]
fn ptr(&self) -> *mut T {
@@ -442,12 +462,18 @@ impl<T, A: Allocator> VecDeque<T, A> {
mut iter: impl Iterator<Item = T>,
len: usize,
) -> usize {
- struct Guard<'a, T, A: Allocator> {
- deque: &'a mut VecDeque<T, A>,
+ struct Guard<'a, T, A: Allocator, const COOP_PREFERRED: bool>
+ where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+ {
+ deque: &'a mut VecDeque<T, A, COOP_PREFERRED>,
written: usize,
}
- impl<'a, T, A: Allocator> Drop for Guard<'a, T, A> {
+ impl<'a, T, A: Allocator, const COOP_PREFERRED: bool> Drop for Guard<'a, T, A, COOP_PREFERRED>
+ where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+ {
fn drop(&mut self) {
self.deque.len += self.written;
}
@@ -525,7 +551,11 @@ impl<T, A: Allocator> VecDeque<T, A> {
}
}
-impl<T> VecDeque<T> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> VecDeque<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
/// Creates an empty deque.
///
/// # Examples
@@ -539,7 +569,9 @@ impl<T> VecDeque<T> {
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_stable(feature = "const_vec_deque_new", since = "CURRENT_RUSTC_VERSION")]
#[must_use]
- pub const fn new() -> VecDeque<T> {
+ pub const fn new() -> VecDeque<T, Global, COOP_PREFERRED>
+ where [(); alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+ {
// FIXME: This should just be `VecDeque::new_in(Global)` once that hits stable.
VecDeque { head: 0, len: 0, buf: RawVec::NEW }
}
@@ -556,12 +588,15 @@ impl<T> VecDeque<T> {
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
#[must_use]
- pub fn with_capacity(capacity: usize) -> VecDeque<T> {
- Self::with_capacity_in(capacity, Global)
+ pub fn with_capacity(capacity: usize) -> VecDeque<T, Global, COOP_PREFERRED> {
+ VecDeque::<T, Global, COOP_PREFERRED>::with_capacity_in(capacity, Global)
}
}
-impl<T, A: Allocator> VecDeque<T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> VecDeque<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
/// Creates an empty deque.
///
/// # Examples
@@ -573,7 +608,7 @@ impl<T, A: Allocator> VecDeque<T, A> {
/// ```
#[inline]
#[unstable(feature = "allocator_api", issue = "32838")]
- pub const fn new_in(alloc: A) -> VecDeque<T, A> {
+ pub const fn new_in(alloc: A) -> VecDeque<T, A, COOP_PREFERRED> {
VecDeque { head: 0, len: 0, buf: RawVec::new_in(alloc) }
}
@@ -587,7 +622,7 @@ impl<T, A: Allocator> VecDeque<T, A> {
/// let deque: VecDeque<u32> = VecDeque::with_capacity(10);
/// ```
#[unstable(feature = "allocator_api", issue = "32838")]
- pub fn with_capacity_in(capacity: usize, alloc: A) -> VecDeque<T, A> {
+ pub fn with_capacity_in(capacity: usize, alloc: A) -> VecDeque<T, A, COOP_PREFERRED> {
VecDeque { head: 0, len: 0, buf: RawVec::with_capacity_in(capacity, alloc) }
}
@@ -1368,7 +1403,7 @@ impl<T, A: Allocator> VecDeque<T, A> {
/// ```
#[inline]
#[stable(feature = "drain", since = "1.6.0")]
- pub fn drain<R>(&mut self, range: R) -> Drain<'_, T, A>
+ pub fn drain<R>(&mut self, range: R) -> Drain<'_, T, A, COOP_PREFERRED>
where
R: RangeBounds<usize>,
{
@@ -2596,7 +2631,10 @@ impl<T, A: Allocator> VecDeque<T, A> {
}
}
-impl<T: Clone, A: Allocator> VecDeque<T, A> {
+impl<T: Clone, A: Allocator, const COOP_PREFERRED: bool> VecDeque<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
/// 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.
@@ -2641,7 +2679,11 @@ 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, const COOP_PREFERRED: bool> PartialEq
+ for VecDeque<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
fn eq(&self, other: &Self) -> bool {
if self.len != other.len() {
return false;
@@ -2680,24 +2722,34 @@ 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, const COOP_PREFERRED: bool> Eq for VecDeque<T, A, COOP_PREFERRED> where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:
+{
+}
-__impl_slice_eq1! { [] VecDeque<T, A>, Vec<U, A>, }
-__impl_slice_eq1! { [] VecDeque<T, A>, &[U], }
-__impl_slice_eq1! { [] VecDeque<T, A>, &mut [U], }
-__impl_slice_eq1! { [const N: usize] VecDeque<T, A>, [U; N], }
-__impl_slice_eq1! { [const N: usize] VecDeque<T, A>, &[U; N], }
-__impl_slice_eq1! { [const N: usize] VecDeque<T, A>, &mut [U; N], }
+__impl_slice_eq1! { [] VecDeque<T, A, COOP_PREFERRED>, Vec<U, A, COOP_PREFERRED>, }
+__impl_slice_eq1! { [] VecDeque<T, A, COOP_PREFERRED>, &[U], }
+__impl_slice_eq1! { [] VecDeque<T, A, COOP_PREFERRED>, &mut [U], }
+__impl_slice_eq1! { [const N: usize] VecDeque<T, A, COOP_PREFERRED>, [U; N], }
+__impl_slice_eq1! { [const N: usize] VecDeque<T, A, COOP_PREFERRED>, &[U; N], }
+__impl_slice_eq1! { [const N: usize] VecDeque<T, A, COOP_PREFERRED>, &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, const COOP_PREFERRED: bool> PartialOrd
+ for VecDeque<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
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, const COOP_PREFERRED: bool> Ord for VecDeque<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
#[inline]
fn cmp(&self, other: &Self) -> Ordering {
self.iter().cmp(other.iter())
@@ -2705,7 +2757,10 @@ impl<T: Ord, A: Allocator> Ord for VecDeque<T, A> {
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Hash, A: Allocator> Hash for VecDeque<T, A> {
+impl<T: Hash, A: Allocator, const COOP_PREFERRED: bool> Hash for VecDeque<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
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
@@ -2719,7 +2774,10 @@ 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, const COOP_PREFERRED: bool> Index<usize> for VecDeque<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
type Output = T;
#[inline]
@@ -2729,7 +2787,10 @@ 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, const COOP_PREFERRED: bool> IndexMut<usize> for VecDeque<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
#[inline]
fn index_mut(&mut self, index: usize) -> &mut T {
self.get_mut(index).expect("Out of bounds access")
@@ -2737,26 +2798,36 @@ impl<T, A: Allocator> IndexMut<usize> for VecDeque<T, A> {
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> FromIterator<T> for VecDeque<T> {
- fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> VecDeque<T> {
+impl<T, const COOP_PREFERRED: bool> FromIterator<T> for VecDeque<T, Global, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
+ fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> VecDeque<T, Global, COOP_PREFERRED> {
SpecFromIter::spec_from_iter(iter.into_iter())
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T, A: Allocator> IntoIterator for VecDeque<T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> IntoIterator for VecDeque<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
type Item = T;
- type IntoIter = IntoIter<T, A>;
+ type IntoIter = IntoIter<T, A, COOP_PREFERRED>;
/// Consumes the deque into a front-to-back iterator yielding elements by
/// value.
- fn into_iter(self) -> IntoIter<T, A> {
+ fn into_iter(self) -> IntoIter<T, A, COOP_PREFERRED> {
IntoIter::new(self)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T, A: Allocator> IntoIterator for &'a VecDeque<T, A> {
+impl<'a, T, A: Allocator, const COOP_PREFERRED: bool> IntoIterator
+ for &'a VecDeque<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
type Item = &'a T;
type IntoIter = Iter<'a, T>;
@@ -2766,7 +2837,11 @@ 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, const COOP_PREFERRED: bool> IntoIterator
+ for &'a mut VecDeque<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
type Item = &'a mut T;
type IntoIter = IterMut<'a, T>;
@@ -2776,7 +2851,10 @@ 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, const COOP_PREFERRED: bool> Extend<T> for VecDeque<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
<Self as SpecExtend<T, I::IntoIter>>::spec_extend(self, iter.into_iter());
}
@@ -2793,7 +2871,11 @@ 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, const COOP_PREFERRED: bool> Extend<&'a T>
+ for VecDeque<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
self.spec_extend(iter.into_iter());
}
@@ -2810,14 +2892,25 @@ 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, const COOP_PREFERRED: bool> fmt::Debug
+ for VecDeque<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
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, const COOP_PREFERRED: bool, const OTHER_COOP_PREFERRED: bool> From<Vec<T, A, OTHER_COOP_PREFERRED>>
+ for VecDeque<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(
+ OTHER_COOP_PREFERRED,
+ )]:,
+{
/// Turn a [`Vec<T>`] into a [`VecDeque<T>`].
///
/// [`Vec<T>`]: crate::vec::Vec
@@ -2827,14 +2920,20 @@ impl<T, A: Allocator> From<Vec<T, A>> for VecDeque<T, A> {
/// and to not re-allocate the `Vec`'s buffer or allocate
/// any additional memory.
#[inline]
- fn from(other: Vec<T, A>) -> Self {
+ fn from(other: Vec<T, A, OTHER_COOP_PREFERRED>) -> Self
+ {
let (ptr, len, cap, alloc) = other.into_raw_parts_with_alloc();
- Self { head: 0, len, buf: unsafe { RawVec::from_raw_parts_in(ptr, cap, alloc) } }
+ Self { head: 0, len, buf: unsafe { RawVec::<T, A, COOP_PREFERRED>::from_raw_parts_in(ptr, cap, alloc) } }
}
}
#[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, const COOP_PREFERRED: bool, const VECDEQUE_COOP_PREFERRED: bool> From<VecDeque<T, A, VECDEQUE_COOP_PREFERRED>>
+ for Vec<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(VECDEQUE_COOP_PREFERRED)]:,
+{
/// Turn a [`VecDeque<T>`] into a [`Vec<T>`].
///
/// [`Vec<T>`]: crate::vec::Vec
@@ -2864,7 +2963,12 @@ impl<T, A: Allocator> From<VecDeque<T, A>> for Vec<T, A> {
/// assert_eq!(vec, [8, 9, 1, 2, 3, 4]);
/// assert_eq!(vec.as_ptr(), ptr);
/// ```
- fn from(mut other: VecDeque<T, A>) -> Self {
+ fn from(
+ mut other: VecDeque<T, A, VECDEQUE_COOP_PREFERRED>,
+ ) -> Self
+ where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(VECDEQUE_COOP_PREFERRED)]:,
+ {
other.make_contiguous();
unsafe {
@@ -2877,13 +2981,18 @@ impl<T, A: Allocator> From<VecDeque<T, A>> for Vec<T, A> {
if other.head != 0 {
ptr::copy(buf.add(other.head), buf, len);
}
- Vec::from_raw_parts_in(buf, len, cap, alloc)
+ // @FIXME: COOP
+ Vec::<T, A, COOP_PREFERRED>::from_raw_parts_in(buf, len, cap, alloc)
}
}
}
#[stable(feature = "std_collections_from_array", since = "1.56.0")]
-impl<T, const N: usize> From<[T; N]> for VecDeque<T> {
+impl<T, const N: usize, const COOP_PREFERRED: bool> From<[T; N]>
+ for VecDeque<T, Global, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
/// Converts a `[T; N]` into a `VecDeque<T>`.
///
/// ```
@@ -2894,11 +3003,12 @@ impl<T, const N: usize> From<[T; N]> for VecDeque<T> {
/// assert_eq!(deq1, deq2);
/// ```
fn from(arr: [T; N]) -> Self {
- let mut deq = VecDeque::with_capacity(N);
+ let mut deq = VecDeque::<T, Global, COOP_PREFERRED>::with_capacity(N);
let arr = ManuallyDrop::new(arr);
if !<T>::IS_ZST {
// SAFETY: VecDeque::with_capacity ensures that there is enough capacity.
unsafe {
+ // @FIXME for COOP_PREFERRED:
ptr::copy_nonoverlapping(arr.as_ptr(), deq.ptr(), N);
}
}
diff --git a/library/alloc/src/collections/vec_deque/spec_extend.rs b/library/alloc/src/collections/vec_deque/spec_extend.rs
index dccf40ccb38aa..b1a9d23fd4a99 100644
--- a/library/alloc/src/collections/vec_deque/spec_extend.rs
+++ b/library/alloc/src/collections/vec_deque/spec_extend.rs
@@ -1,5 +1,8 @@
+#![feature(min_specialization)]
+
use crate::alloc::Allocator;
use crate::vec;
+use core::alloc;
use core::iter::TrustedLen;
use core::slice;
@@ -10,9 +13,11 @@ pub(super) trait SpecExtend<T, I> {
fn spec_extend(&mut self, iter: I);
}
-impl<T, I, A: Allocator> SpecExtend<T, I> for VecDeque<T, A>
+impl<T, I, A: Allocator, const COOP_PREFERRED: bool> SpecExtend<T, I>
+ for VecDeque<T, A, COOP_PREFERRED>
where
I: Iterator<Item = T>,
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
{
default fn spec_extend(&mut self, mut iter: I) {
// This function should be the moral equivalent of:
@@ -22,7 +27,12 @@ where
// }
// May only be called if `deque.len() < deque.capacity()`
- unsafe fn push_unchecked<T, A: Allocator>(deque: &mut VecDeque<T, A>, element: T) {
+ unsafe fn push_unchecked<T, A: Allocator, const COOP_PREFERRED: bool>(
+ deque: &mut VecDeque<T, A, COOP_PREFERRED>,
+ element: T,
+ ) where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+ {
// SAFETY: Because of the precondition, it's guaranteed that there is space
// in the logical array after the last element.
unsafe { deque.buffer_write(deque.to_physical_idx(deque.len), element) };
@@ -49,9 +59,11 @@ where
}
}
-impl<T, I, A: Allocator> SpecExtend<T, I> for VecDeque<T, A>
+impl<T, I, A: Allocator, const COOP_PREFERRED: bool> SpecExtend<T, I>
+ for VecDeque<T, A, COOP_PREFERRED>
where
I: TrustedLen<Item = T>,
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
{
default fn spec_extend(&mut self, iter: I) {
// This is the case for a TrustedLen iterator.
@@ -84,7 +96,11 @@ where
}
}
-impl<T, A: Allocator> SpecExtend<T, vec::IntoIter<T>> for VecDeque<T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> SpecExtend<T, vec::IntoIter<T>>
+ for VecDeque<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
fn spec_extend(&mut self, mut iterator: vec::IntoIter<T>) {
let slice = iterator.as_slice();
self.reserve(slice.len());
@@ -97,19 +113,23 @@ impl<T, A: Allocator> SpecExtend<T, vec::IntoIter<T>> for VecDeque<T, A> {
}
}
-impl<'a, T: 'a, I, A: Allocator> SpecExtend<&'a T, I> for VecDeque<T, A>
+impl<'a, T: 'a, I, A: Allocator, const COOP_PREFERRED: bool> SpecExtend<&'a T, I>
+ for VecDeque<T, A, COOP_PREFERRED>
where
I: Iterator<Item = &'a T>,
T: Copy,
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
{
default fn spec_extend(&mut self, iterator: I) {
self.spec_extend(iterator.copied())
}
}
-impl<'a, T: 'a, A: Allocator> SpecExtend<&'a T, slice::Iter<'a, T>> for VecDeque<T, A>
+impl<'a, T: 'a, A: Allocator, const COOP_PREFERRED: bool> SpecExtend<&'a T, slice::Iter<'a, T>>
+ for VecDeque<T, A, COOP_PREFERRED>
where
T: Copy,
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
{
fn spec_extend(&mut self, iterator: slice::Iter<'a, T>) {
let slice = iterator.as_slice();
diff --git a/library/alloc/src/collections/vec_deque/spec_from_iter.rs b/library/alloc/src/collections/vec_deque/spec_from_iter.rs
index 7650492ebdad1..5da3faaabe2c6 100644
--- a/library/alloc/src/collections/vec_deque/spec_from_iter.rs
+++ b/library/alloc/src/collections/vec_deque/spec_from_iter.rs
@@ -1,33 +1,45 @@
use super::{IntoIter, VecDeque};
+use crate::alloc::Global;
+use core::alloc;
/// Specialization trait used for `VecDeque::from_iter`
pub(super) trait SpecFromIter<T, I> {
fn spec_from_iter(iter: I) -> Self;
}
-impl<T, I> SpecFromIter<T, I> for VecDeque<T>
+impl<T, I, const COOP_PREFERRED: bool> SpecFromIter<T, I>
+ for VecDeque<T, Global, COOP_PREFERRED>
where
I: Iterator<Item = T>,
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
{
default fn spec_from_iter(iterator: I) -> Self {
// Since converting is O(1) now, just re-use the `Vec` logic for
// anything where we can't do something extra-special for `VecDeque`,
// especially as that could save us some monomorphiziation work
// if one uses the same iterators (like slice ones) with both.
- crate::vec::Vec::from_iter(iterator).into()
+ crate::vec::Vec::<T, Global, COOP_PREFERRED>::from_iter(iterator).into()
}
}
-impl<T> SpecFromIter<T, crate::vec::IntoIter<T>> for VecDeque<T> {
+impl<T, const COOP_PREFERRED: bool> SpecFromIter<T, crate::vec::IntoIter<T, Global, COOP_PREFERRED>>
+ for VecDeque<T, Global, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
#[inline]
- fn spec_from_iter(iterator: crate::vec::IntoIter<T>) -> Self {
+ fn spec_from_iter(iterator: crate::vec::IntoIter<T, Global, COOP_PREFERRED>) -> Self {
iterator.into_vecdeque()
}
}
-impl<T> SpecFromIter<T, IntoIter<T>> for VecDeque<T> {
+impl<T, const COOP_PREFERRED: bool> SpecFromIter<T, IntoIter<T, Global, COOP_PREFERRED>>
+ for VecDeque<T, Global, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
#[inline]
- fn spec_from_iter(iterator: IntoIter<T>) -> Self {
+ fn spec_from_iter(iterator: IntoIter<T, Global, COOP_PREFERRED>) -> Self {
iterator.into_vecdeque()
}
}
diff --git a/library/alloc/src/ffi/c_str.rs b/library/alloc/src/ffi/c_str.rs
index 11bd4c4dc1ba8..e3344cbbf98f9 100644
--- a/library/alloc/src/ffi/c_str.rs
+++ b/library/alloc/src/ffi/c_str.rs
@@ -17,6 +17,8 @@ use core::ptr;
use core::slice;
use core::slice::memchr;
use core::str::{self, Utf8Error};
+use crate::alloc::Global;
+use crate::DEFAULT_COOP_PREFERRED;
#[cfg(target_has_atomic = "ptr")]
use crate::sync::Arc;
@@ -494,7 +496,10 @@ impl CString {
/// ```
#[must_use = "`self` will be dropped if the result is not used"]
#[stable(feature = "cstring_into", since = "1.7.0")]
- pub fn into_bytes(self) -> Vec<u8> {
+ pub fn into_bytes<const COOP_PREFERRED: bool>(self) -> Vec<u8, Global, COOP_PREFERRED>
+ where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+ {
let mut vec = into_vec(self.into_inner());
let _nul = vec.pop();
debug_assert_eq!(_nul, Some(0u8));
@@ -723,12 +728,15 @@ impl fmt::Debug for CString {
}
#[stable(feature = "cstring_into", since = "1.7.0")]
-impl From<CString> for Vec<u8> {
+#[allow(unused_braces)]
+impl<const COOP_PREFERRED: bool> From<CString> for Vec<u8, Global, COOP_PREFERRED>
+where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
/// Converts a [`CString`] into a <code>[Vec]<[u8]></code>.
///
/// The conversion consumes the [`CString`], and removes the terminating NUL byte.
#[inline]
- fn from(s: CString) -> Vec<u8> {
+ fn from(s: CString) -> Vec<u8, Global, COOP_PREFERRED> {
s.into_bytes()
}
}
@@ -738,7 +746,8 @@ impl Default for CString {
/// Creates an empty `CString`.
fn default() -> CString {
let a: &CStr = Default::default();
- a.to_owned()
+ // false = no need for co-alloc metadata, since it would get lost once converted to Box.
+ <CStr as ToOwned<false>>::to_owned(a)
}
}
@@ -751,11 +760,13 @@ impl Borrow<CStr> for CString {
}
#[stable(feature = "cstring_from_cow_cstr", since = "1.28.0")]
-impl<'a> From<Cow<'a, CStr>> for CString {
+impl<'a, const COOP_PREFERRED: bool> From<Cow<'a, CStr, COOP_PREFERRED>> for CString
+where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
/// Converts a `Cow<'a, CStr>` into a `CString`, by copying the contents if they are
/// borrowed.
#[inline]
- fn from(s: Cow<'a, CStr>) -> Self {
+ fn from(s: Cow<'a, CStr, COOP_PREFERRED>) -> Self {
s.into_owned()
}
}
@@ -772,11 +783,13 @@ impl From<&CStr> for Box<CStr> {
}
#[stable(feature = "box_from_cow", since = "1.45.0")]
-impl From<Cow<'_, CStr>> for Box<CStr> {
+impl<const COOP_PREFERRED: bool> From<Cow<'_, CStr, COOP_PREFERRED>> for Box<CStr>
+where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
/// Converts a `Cow<'a, CStr>` into a `Box<CStr>`,
/// by copying the contents if they are borrowed.
#[inline]
- fn from(cow: Cow<'_, CStr>) -> Box<CStr> {
+ fn from(cow: Cow<'_, CStr, COOP_PREFERRED>) -> Box<CStr> {
match cow {
Cow::Borrowed(s) => Box::from(s),
Cow::Owned(s) => Box::from(s),
@@ -835,28 +848,33 @@ impl From<CString> for Box<CStr> {
}
#[stable(feature = "cow_from_cstr", since = "1.28.0")]
-impl<'a> From<CString> for Cow<'a, CStr> {
+#[allow(unused_braces)]
+impl<'a> From<CString> for Cow<'a, CStr, { DEFAULT_COOP_PREFERRED!() }> {
/// Converts a [`CString`] into an owned [`Cow`] without copying or allocating.
#[inline]
- fn from(s: CString) -> Cow<'a, CStr> {
+ fn from(s: CString) -> Cow<'a, CStr, { DEFAULT_COOP_PREFERRED!() }> {
Cow::Owned(s)
}
}
#[stable(feature = "cow_from_cstr", since = "1.28.0")]
-impl<'a> From<&'a CStr> for Cow<'a, CStr> {
+#[allow(unused_braces)]
+impl<'a> From<&'a CStr> for Cow<'a, CStr, { DEFAULT_COOP_PREFERRED!() }> {
/// Converts a [`CStr`] into a borrowed [`Cow`] without copying or allocating.
#[inline]
- fn from(s: &'a CStr) -> Cow<'a, CStr> {
+ fn from(s: &'a CStr) -> Cow<'a, CStr, { DEFAULT_COOP_PREFERRED!() }> {
Cow::Borrowed(s)
}
}
#[stable(feature = "cow_from_cstr", since = "1.28.0")]
-impl<'a> From<&'a CString> for Cow<'a, CStr> {
+impl<'a, const COOP_PREFERRED: bool> From<&'a CString> for Cow<'a, CStr, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
/// Converts a `&`[`CString`] into a borrowed [`Cow`] without copying or allocating.
#[inline]
- fn from(s: &'a CString) -> Cow<'a, CStr> {
+ fn from(s: &'a CString) -> Cow<'a, CStr, COOP_PREFERRED> {
Cow::Borrowed(s.as_c_str())
}
}
@@ -1014,7 +1032,11 @@ impl fmt::Display for IntoStringError {
}
#[stable(feature = "cstr_borrow", since = "1.3.0")]
-impl ToOwned for CStr {
+// @FIXME try remove COOP_PREFERRED and have ToOwned<_>
+impl<const COOP_PREFERRED: bool> ToOwned<COOP_PREFERRED> for CStr
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
type Owned = CString;
fn to_owned(&self) -> CString {
@@ -1031,7 +1053,8 @@ impl ToOwned for CStr {
#[stable(feature = "cstring_asref", since = "1.7.0")]
impl From<&CStr> for CString {
fn from(s: &CStr) -> CString {
- s.to_owned()
+ // false = no need for co-alloc metadata, since it would get lost once converted to Box.
+ <CStr as ToOwned<false>>::to_owned(s)
}
}
@@ -1099,8 +1122,11 @@ impl CStr {
#[must_use = "this returns the result of the operation, \
without modifying the original"]
#[stable(feature = "cstr_to_str", since = "1.4.0")]
- pub fn to_string_lossy(&self) -> Cow<'_, str> {
- String::from_utf8_lossy(self.to_bytes())
+ pub fn to_string_lossy<const COOP_PREFERRED: bool>(&self) -> Cow<'_, str, COOP_PREFERRED>
+ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+ {
+ // false = no need for co-alloc metadata, since it would get lost once converted to the slice.
+ String::<COOP_PREFERRED>::from_utf8_lossy_co(self.to_bytes())
}
/// Converts a <code>[Box]<[CStr]></code> into a [`CString`] without copying or allocating.
diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs
index ca75c3895f41f..b41f5045069bd 100644
--- a/library/alloc/src/lib.rs
+++ b/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:
@@ -123,6 +124,8 @@
#![feature(extend_one)]
#![feature(fmt_internals)]
#![feature(fn_traits)]
+#![feature(generic_const_exprs)]
+#![feature(global_co_alloc_meta)]
#![feature(hasher_prefixfree_extras)]
#![feature(inline_const)]
#![feature(inplace_iteration)]
@@ -178,9 +181,18 @@
#![feature(exclusive_range_pattern)]
#![feature(fundamental)]
#![cfg_attr(not(test), feature(generator_trait))]
+#![feature(global_co_alloc)]
+#![feature(global_co_alloc_short_term_pref)]
#![feature(hashmap_internals)]
#![feature(lang_items)]
-#![feature(min_specialization)]
+#![feature(global_co_alloc_def)]
+// When we used min_specialization instead of specialization, library/alloc/src/vec/mod.rs was failing with:
+// - cannot specialize on predicate `the constant `core::alloc::co_alloc_metadata_num_slots::<A>()` can be evaluated`
+// - cannot specialize on predicate `[(); _] well-formed`
+// - cannot specialize on predicate `the constant `core::alloc::co_alloc_metadata_num_slots::<A>()` can be evaluated`
+//#![feature(min_specialization)]
+#![feature(associated_type_defaults)]
+#![feature(specialization)]
#![feature(negative_impls)]
#![feature(never_type)]
#![feature(rustc_allow_const_fn_unstable)]
@@ -275,3 +287,4 @@ pub(crate) mod test_helpers {
rand::SeedableRng::from_seed(seed)
}
}
+
diff --git a/library/alloc/src/macros.rs b/library/alloc/src/macros.rs
index 5198bf297d925..c2f1e9df41c11 100644
--- a/library/alloc/src/macros.rs
+++ b/library/alloc/src/macros.rs
@@ -41,7 +41,7 @@
#[allow_internal_unstable(rustc_attrs, liballoc_internals)]
macro_rules! vec {
() => (
- $crate::__rust_force_expr!($crate::vec::Vec::new())
+ $crate::__rust_force_expr!($crate::vec::Vec::new_co())
);
($elem:expr; $n:expr) => (
$crate::__rust_force_expr!($crate::vec::from_elem($elem, $n))
diff --git a/library/alloc/src/raw_vec.rs b/library/alloc/src/raw_vec.rs
index 5a10121bbbe4b..cb0cb4216a5a9 100644
--- a/library/alloc/src/raw_vec.rs
+++ b/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;
+use core::alloc::{self, GlobalCoAllocMeta, LayoutError, PtrAndMeta};
use core::cmp;
use core::intrinsics;
use core::mem::{self, ManuallyDrop, MaybeUninit, SizedTypeProperties};
@@ -14,6 +14,7 @@ use crate::alloc::{Allocator, Global, Layout};
use crate::boxed::Box;
use crate::collections::TryReserveError;
use crate::collections::TryReserveErrorKind::*;
+use crate::DEFAULT_COOP_PREFERRED;
#[cfg(test)]
mod tests;
@@ -49,13 +50,28 @@ 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> {
+#[allow(unused_braces)]
+pub(crate) struct RawVec<
+ T,
+ A: Allocator = Global,
+ const COOP_PREFERRED: bool = {DEFAULT_COOP_PREFERRED!()},
+> where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
ptr: Unique<T>,
cap: usize,
alloc: A,
+ // 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) metas: [GlobalCoAllocMeta;
+ alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)],
}
-impl<T> RawVec<T, Global> {
+impl<T, const COOP_PREFERRED: bool> RawVec<T, Global, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
/// HACK(Centril): This exists because stable `const fn` can only call stable `const fn`, so
/// they cannot call `Self::new()`.
///
@@ -102,7 +118,10 @@ impl<T> RawVec<T, Global> {
}
}
-impl<T, A: Allocator> RawVec<T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> RawVec<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
// 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.
@@ -120,7 +139,13 @@ impl<T, A: Allocator> RawVec<T, A> {
/// the returned `RawVec`.
pub const fn new_in(alloc: A) -> Self {
// `cap: 0` means "unallocated". zero-sized types are ignored.
- Self { ptr: Unique::dangling(), cap: 0, alloc }
+ Self {
+ ptr: Unique::dangling(),
+ cap: 0,
+ alloc,
+ metas: [GlobalCoAllocMeta {/*one: 1*/ /* , two: 2, three: 3, four: 4*/};
+ alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)],
+ }
}
/// Like `with_capacity`, but parameterized over the choice of
@@ -197,6 +222,10 @@ impl<T, A: Allocator> RawVec<T, A> {
ptr: unsafe { Unique::new_unchecked(ptr.cast().as_ptr()) },
cap: capacity,
alloc,
+ metas: [GlobalCoAllocMeta {/*one: 1*/ /*, two: 2, three: 3, four: 4*/};
+ alloc::co_alloc_metadata_num_slots_with_preference::<A>(
+ COOP_PREFERRED,
+ )],
}
}
}
@@ -213,7 +242,13 @@ impl<T, A: Allocator> RawVec<T, A> {
/// guaranteed.
#[inline]
pub unsafe fn from_raw_parts_in(ptr: *mut T, capacity: usize, alloc: A) -> Self {
- Self { ptr: unsafe { Unique::new_unchecked(ptr) }, cap: capacity, alloc }
+ Self {
+ ptr: unsafe { Unique::new_unchecked(ptr) },
+ cap: capacity,
+ alloc,
+ metas: [GlobalCoAllocMeta {/*one: 1*/ /*, two: 2, three: 3, four: 4*/};
+ alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)],
+ }
}
/// Gets a raw pointer to the start of the allocation. Note that this is
@@ -277,11 +312,13 @@ impl<T, A: Allocator> RawVec<T, A> {
// handle_reserve behind a call, while making sure that this function is likely to be
// inlined as just a comparison and a call if the comparison fails.
#[cold]
- fn do_reserve_and_handle<T, A: Allocator>(
- slf: &mut RawVec<T, A>,
+ fn do_reserve_and_handle<T, A: Allocator, const COOP_PREFERRED: bool>(
+ slf: &mut RawVec<T, A, COOP_PREFERRED>,
len: usize,
additional: usize,
- ) {
+ ) where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+ {
handle_reserve(slf.grow_amortized(len, additional));
}
@@ -354,7 +391,10 @@ impl<T, A: Allocator> RawVec<T, A> {
}
}
-impl<T, A: Allocator> RawVec<T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> RawVec<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
/// 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 {
@@ -472,11 +512,20 @@ 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, const COOP_PREFERRED: bool> Drop
+ for RawVec<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
/// Frees the memory owned by the `RawVec` *without* trying to drop its contents.
- fn drop(&mut self) {
+ default fn drop(&mut self) {
if let Some((ptr, layout)) = self.current_memory() {
- unsafe { self.alloc.deallocate(ptr, layout) }
+ if A::IS_CO_ALLOCATOR && COOP_PREFERRED {
+ let meta = self.metas[0];
+ unsafe { self.alloc.co_deallocate(PtrAndMeta { ptr, meta }, layout) }
+ } else {
+ unsafe { self.alloc.deallocate(ptr, layout) }
+ }
}
}
}
diff --git a/library/alloc/src/rc.rs b/library/alloc/src/rc.rs
index c9aa23fc4af1f..e4bf9d5fe2fba 100644
--- a/library/alloc/src/rc.rs
+++ b/library/alloc/src/rc.rs
@@ -1987,7 +1987,10 @@ impl<T: ?Sized> From<Box<T>> for Rc<T> {
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "shared_from_slice", since = "1.21.0")]
-impl<T> From<Vec<T>> for Rc<[T]> {
+impl<T, const COOP_PREFERRED: bool> From<Vec<T, Global, COOP_PREFERRED>> for Rc<[T]>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
/// Allocate a reference-counted slice and move `v`'s items into it.
///
/// # Example
@@ -1999,7 +2002,10 @@ impl<T> From<Vec<T>> for Rc<[T]> {
/// assert_eq!(vec![1, 2, 3], *shared);
/// ```
#[inline]
- fn from(mut v: Vec<T>) -> Rc<[T]> {
+ fn from(mut v: Vec<T, Global, COOP_PREFERRED>) -> Rc<[T]>
+ where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+ {
unsafe {
let rc = Rc::copy_from_slice(&v);
// Allow the Vec to free its memory, but not destroy its contents
@@ -2120,6 +2126,7 @@ trait ToRcSlice<T>: Iterator<Item = T> + Sized {
fn to_rc_slice(self) -> Rc<[T]>;
}
+// COOP_NOT_POSSIBLE
#[cfg(not(no_global_oom_handling))]
impl<T, I: Iterator<Item = T>> ToRcSlice<T> for I {
default fn to_rc_slice(self) -> Rc<[T]> {
diff --git a/library/alloc/src/slice.rs b/library/alloc/src/slice.rs
index e9886fc571799..6f0c6a52b6dc8 100644
--- a/library/alloc/src/slice.rs
+++ b/library/alloc/src/slice.rs
@@ -95,7 +95,14 @@ pub(crate) mod hack {
// We shouldn't add inline attribute to this since this is used in
// `vec!` macro mostly and causes perf regression. See #71204 for
// discussion and perf results.
- pub fn into_vec<T, A: Allocator>(b: Box<[T], A>) -> Vec<T, A> {
+ pub fn into_vec<T, A: Allocator, const COOP_PREFERRED: bool>(
+ b: Box<[T], A>,
+ ) -> Vec<T, A, COOP_PREFERRED>
+ where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(
+ COOP_PREFERRED,
+ )]:,
+ {
unsafe {
let len = b.len();
let (b, alloc) = Box::into_raw_with_allocator(b);
@@ -105,26 +112,58 @@ pub(crate) mod hack {
#[cfg(not(no_global_oom_handling))]
#[inline]
- pub fn to_vec<T: ConvertVec, A: Allocator>(s: &[T], alloc: A) -> Vec<T, A> {
+ pub fn to_vec<T: ConvertVec, A: Allocator, const COOP_PREFERRED: bool>(
+ s: &[T],
+ alloc: A,
+ ) -> Vec<T, A, COOP_PREFERRED>
+ where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(
+ COOP_PREFERRED,
+ )]:,
+ {
T::to_vec(s, alloc)
}
#[cfg(not(no_global_oom_handling))]
pub trait ConvertVec {
- fn to_vec<A: Allocator>(s: &[Self], alloc: A) -> Vec<Self, A>
+ fn to_vec<A: Allocator, const COOP_PREFERRED: bool>(
+ s: &[Self],
+ alloc: A,
+ ) -> Vec<Self, A, COOP_PREFERRED>
where
- Self: Sized;
+ Self: Sized,
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(
+ COOP_PREFERRED,
+ )]:;
}
#[cfg(not(no_global_oom_handling))]
impl<T: Clone> ConvertVec for T {
#[inline]
- default fn to_vec<A: Allocator>(s: &[Self], alloc: A) -> Vec<Self, A> {
- struct DropGuard<'a, T, A: Allocator> {
- vec: &'a mut Vec<T, A>,
+ default fn to_vec<A: Allocator, const COOP_PREFERRED: bool>(
+ s: &[Self],
+ alloc: A,
+ ) -> Vec<Self, A, COOP_PREFERRED>
+ where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(
+ COOP_PREFERRED,
+ )]:,
+ {
+ struct DropGuard<'a, T, A: Allocator, const COOP_PREFERRED: bool>
+ where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(
+ COOP_PREFERRED,
+ )]:,
+ {
+ vec: &'a mut Vec<T, A, COOP_PREFERRED>,
num_init: usize,
}
- impl<'a, T, A: Allocator> Drop for DropGuard<'a, T, A> {
+ impl<'a, T, A: Allocator, const COOP_PREFERRED: bool> Drop for DropGuard<'a, T, A, COOP_PREFERRED>
+ where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(
+ COOP_PREFERRED,
+ )]:,
+ {
#[inline]
fn drop(&mut self) {
// SAFETY:
@@ -156,7 +195,15 @@ pub(crate) mod hack {
#[cfg(not(no_global_oom_handling))]
impl<T: Copy> ConvertVec for T {
#[inline]
- fn to_vec<A: Allocator>(s: &[Self], alloc: A) -> Vec<Self, A> {
+ fn to_vec<A: Allocator, const COOP_PREFERRED: bool>(
+ s: &[Self],
+ alloc: A,
+ ) -> Vec<Self, A, COOP_PREFERRED>
+ where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(
+ COOP_PREFERRED,
+ )]:,
+ {
let mut v = Vec::with_capacity_in(s.len(), alloc);
// SAFETY:
// allocated above with the capacity of `s`, and initialize to `s.len()` in
@@ -407,11 +454,14 @@ impl<T> [T] {
#[rustc_conversion_suggestion]
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
- pub fn to_vec(&self) -> Vec<T>
+ pub fn to_vec<const COOP_PREFERRED: bool>(&self) -> Vec<T, Global, COOP_PREFERRED>
where
T: Clone,
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(
+ COOP_PREFERRED,
+ )]:,
{
- self.to_vec_in(Global)
+ self.to_vec_in::<Global, COOP_PREFERRED>(Global)
}
/// Copies `self` into a new `Vec` with an allocator.
@@ -431,9 +481,15 @@ impl<T> [T] {
#[rustc_allow_incoherent_impl]
#[inline]
#[unstable(feature = "allocator_api", issue = "32838")]
- pub fn to_vec_in<A: Allocator>(&self, alloc: A) -> Vec<T, A>
+ pub fn to_vec_in<A: Allocator, const COOP_PREFERRED: bool>(
+ &self,
+ alloc: A,
+ ) -> Vec<T, A, COOP_PREFERRED>
where
T: Clone,
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(
+ COOP_PREFERRED,
+ )]:,
{
// N.B., see the `hack` module in this file for more details.
hack::to_vec(self, alloc)
@@ -456,7 +512,14 @@ 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> {
+ pub fn into_vec<A: Allocator, const COOP_PREFERRED: bool>(
+ self: Box<Self, A>,
+ ) -> Vec<T, A, COOP_PREFERRED>
+ where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(
+ COOP_PREFERRED,
+ )]:,
+ {
// N.B., see the `hack` module in this file for more details.
hack::into_vec(self)
}
@@ -700,6 +763,7 @@ pub trait Join<Separator> {
fn join(slice: &Self, sep: Separator) -> Self::Output;
}
+// COOP_NOT_POSSIBLE
#[cfg(not(no_global_oom_handling))]
#[unstable(feature = "slice_concat_ext", issue = "27747")]
impl<T: Clone, V: Borrow<[T]>> Concat<T> for [V] {
@@ -715,6 +779,7 @@ impl<T: Clone, V: Borrow<[T]>> Concat<T> for [V] {
}
}
+// COOP_NOT_POSSIBLE
#[cfg(not(no_global_oom_handling))]
#[unstable(feature = "slice_concat_ext", issue = "27747")]
impl<T: Clone, V: Borrow<[T]>> Join<&T> for [V] {
@@ -738,10 +803,11 @@ impl<T: Clone, V: Borrow<[T]>> Join<&T> for [V] {
}
}
+// COOP_NOT_POSSIBLE
#[cfg(not(no_global_oom_handling))]
#[unstable(feature = "slice_concat_ext", issue = "27747")]
impl<T: Clone, V: Borrow<[T]>> Join<&[T]> for [V] {
- type Output = Vec<T>;
+ type Output = Vec<T, Global>;
fn join(slice: &Self, sep: &[T]) -> Vec<T> {
let mut iter = slice.iter();
@@ -767,14 +833,20 @@ impl<T: Clone, V: Borrow<[T]>> Join<&[T]> for [V] {
////////////////////////////////////////////////////////////////////////////////
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T, A: Allocator> Borrow<[T]> for Vec<T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> Borrow<[T]> for Vec<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
fn borrow(&self) -> &[T] {
&self[..]
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T, A: Allocator> BorrowMut<[T]> for Vec<T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> BorrowMut<[T]> for Vec<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
fn borrow_mut(&mut self) -> &mut [T] {
&mut self[..]
}
@@ -782,19 +854,24 @@ impl<T, A: Allocator> BorrowMut<[T]> for Vec<T, A> {
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Clone> ToOwned for [T] {
- type Owned = Vec<T>;
+impl<T: Clone, const COOP_PREFERRED: bool> ToOwned<COOP_PREFERRED> for [T]
+where
+[(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(
+ COOP_PREFERRED,
+)]:,
+{
+ type Owned = Vec<T, Global, COOP_PREFERRED>;
#[cfg(not(test))]
- fn to_owned(&self) -> Vec<T> {
+ fn to_owned(&self) -> Vec<T, Global, COOP_PREFERRED> {
self.to_vec()
}
#[cfg(test)]
- fn to_owned(&self) -> Vec<T> {
+ fn to_owned(&self) -> Vec<T, Global, COOP_PREFERRED> {
hack::to_vec(self, Global)
}
- fn clone_into(&self, target: &mut Vec<T>) {
+ fn clone_into(&self, target: &mut Vec<T, Global, COOP_PREFERRED>) {
// drop anything in target that will not be overwritten
target.truncate(self.len());
@@ -1039,13 +1116,16 @@ where
// shallow copies of the contents of `v` without risking the dtors running on copies if
// `is_less` panics. When merging two sorted runs, this buffer holds a copy of the shorter run,
// which will always have length at most `len / 2`.
- let mut buf = Vec::with_capacity(len / 2);
+ // `buf` is temporary = not passed around too much => using COOP_PREFERRED=true.
+ // @FIXME move definitions of `buf` and `runs` down, after while end > 0 {...}, just before they are used. Then benchmark if it makes (cache-related) difference.
+ let mut buf = Vec::<T, Global, true>::with_capacity(len / 2);
// In order to identify natural runs in `v`, we traverse it backwards. That might seem like a
// strange decision, but consider the fact that merges more often go in the opposite direction
// (forwards). According to benchmarks, merging forwards is slightly faster than merging
// backwards. To conclude, identifying runs by traversing backwards improves performance.
- let mut runs = vec![];
+ // `runs` is temporary = not passed around too much => using COOP_PREFERRED=true.
+ let mut runs: Vec<_, Global, true> = vec![];
let mut end = len;
while end > 0 {
// Find the next natural run, and reverse it if it's strictly descending.
diff --git a/library/alloc/src/str.rs b/library/alloc/src/str.rs
index afbe5cfaf8ef9..06fa07eefa9be 100644
--- a/library/alloc/src/str.rs
+++ b/library/alloc/src/str.rs
@@ -14,6 +14,8 @@ use core::ptr;
use core::str::pattern::{DoubleEndedSearcher, Pattern, ReverseSearcher, Searcher};
use core::unicode::conversions;
+use crate::alloc;
+use crate::alloc::Global;
use crate::borrow::ToOwned;
use crate::boxed::Box;
use crate::slice::{Concat, Join, SliceIndex};
@@ -126,11 +128,15 @@ macro_rules! copy_slice_and_advance {
// [T] and str both impl AsRef<[T]> for some T
// => s.borrow().as_ref() and we always have slices
#[cfg(not(no_global_oom_handling))]
-fn join_generic_copy<B, T, S>(slice: &[S], sep: &[T]) -> Vec<T>
+fn join_generic_copy<B, T, S, const COOP_PREFERRED: bool>(
+ slice: &[S],
+ sep: &[T],
+) -> Vec<T, Global, COOP_PREFERRED>
where
T: Copy,
B: AsRef<[T]> + ?Sized,
S: Borrow<B>,
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
{
let sep_len = sep.len();
let mut iter = slice.iter();
@@ -185,7 +191,10 @@ where
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl Borrow<str> for String {
+impl<const COOP_PREFERRED: bool> Borrow<str> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
#[inline]
fn borrow(&self) -> &str {
&self[..]
@@ -193,7 +202,10 @@ impl Borrow<str> for String {
}
#[stable(feature = "string_borrow_mut", since = "1.36.0")]
-impl BorrowMut<str> for String {
+impl<const COOP_PREFERRED: bool> BorrowMut<str> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
#[inline]
fn borrow_mut(&mut self) -> &mut str {
&mut self[..]
@@ -202,17 +214,20 @@ impl BorrowMut<str> for String {
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
-impl ToOwned for str {
- type Owned = String;
+impl<const COOP_PREFERRED: bool> ToOwned<COOP_PREFERRED> for str
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
+ type Owned = String<COOP_PREFERRED>;
#[inline]
- fn to_owned(&self) -> String {
- unsafe { String::from_utf8_unchecked(self.as_bytes().to_owned()) }
+ fn to_owned(&self) -> String<COOP_PREFERRED> {
+ unsafe { String::<COOP_PREFERRED>::from_utf8_unchecked(self.as_bytes().to_owned()) }
}
- fn clone_into(&self, target: &mut String) {
+ fn clone_into(&self, target: &mut String<COOP_PREFERRED>) {
let mut b = mem::take(target).into_bytes();
self.as_bytes().clone_into(&mut b);
- *target = unsafe { String::from_utf8_unchecked(b) }
+ *target = unsafe { String::<COOP_PREFERRED>::from_utf8_unchecked(b) }
}
}
@@ -499,7 +514,10 @@ impl str {
#[rustc_allow_incoherent_impl]
#[must_use = "`self` will be dropped if the result is not used"]
#[inline]
- pub fn into_string(self: Box<str>) -> String {
+ pub fn into_string<const COOP_PREFERRED: bool>(self: Box<str>) -> String<COOP_PREFERRED>
+ where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+ {
let slice = Box::<[u8]>::from(self);
unsafe { String::from_utf8_unchecked(slice.into_vec()) }
}
diff --git a/library/alloc/src/string.rs b/library/alloc/src/string.rs
index 3118c7189a5ed..ae95207c0fd0b 100644
--- a/library/alloc/src/string.rs
+++ b/library/alloc/src/string.rs
@@ -41,7 +41,11 @@
//! ```
#![stable(feature = "rust1", since = "1.0.0")]
+#![feature(global_co_alloc_plvec)]
+use crate::alloc::Global;
+
+use core::alloc;
#[cfg(not(no_global_oom_handling))]
use core::char::{decode_utf16, REPLACEMENT_CHARACTER};
use core::error::Error;
@@ -71,6 +75,7 @@ use crate::str::{self, from_utf8_unchecked_mut, Chars, Utf8Error};
#[cfg(not(no_global_oom_handling))]
use crate::str::{from_boxed_utf8_unchecked, FromStr};
use crate::vec::Vec;
+use crate::DEFAULT_COOP_PREFERRED;
/// A UTF-8–encoded, growable string.
///
@@ -364,8 +369,12 @@ use crate::vec::Vec;
#[derive(PartialOrd, Eq, Ord)]
#[stable(feature = "rust1", since = "1.0.0")]
#[cfg_attr(not(test), lang = "String")]
-pub struct String {
- vec: Vec<u8>,
+#[allow(unused_braces)]
+pub struct String<const COOP_PREFERRED: bool = {DEFAULT_COOP_PREFERRED!()}>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
+ vec: Vec<u8, Global, COOP_PREFERRED>,
}
/// A possible error value when converting a `String` from a UTF-8 byte vector.
@@ -404,8 +413,11 @@ pub struct String {
#[stable(feature = "rust1", since = "1.0.0")]
#[cfg_attr(not(no_global_oom_handling), derive(Clone))]
#[derive(Debug, PartialEq, Eq)]
-pub struct FromUtf8Error {
- bytes: Vec<u8>,
+pub struct FromUtf8Error<const COOP_PREFERRED: bool>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
+ bytes: Vec<u8, Global, COOP_PREFERRED>,
error: Utf8Error,
}
@@ -429,7 +441,10 @@ pub struct FromUtf8Error {
#[derive(Debug)]
pub struct FromUtf16Error(());
-impl String {
+impl<const COOP_PREFERRED: bool> String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
/// Creates a new empty `String`.
///
/// Given that the `String` is empty, this will not allocate any initial
@@ -452,8 +467,8 @@ impl String {
#[rustc_const_stable(feature = "const_string_new", since = "1.39.0")]
#[stable(feature = "rust1", since = "1.0.0")]
#[must_use]
- pub const fn new() -> String {
- String { vec: Vec::new() }
+ pub const fn new() -> String<COOP_PREFERRED> {
+ String { vec: Vec::new_co() }
}
/// Creates a new empty `String` with at least the specified capacity.
@@ -497,7 +512,7 @@ impl String {
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
#[must_use]
- pub fn with_capacity(capacity: usize) -> String {
+ pub fn with_capacity(capacity: usize) -> String<COOP_PREFERRED> {
String { vec: Vec::with_capacity(capacity) }
}
@@ -507,7 +522,10 @@ impl String {
// NB see the slice::hack module in slice.rs for more information
#[inline]
#[cfg(test)]
- pub fn from_str(_: &str) -> String {
+ pub fn from_str(_: &str) -> String<COOP_PREFERRED>
+ where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+ {
panic!("not available with cfg(test)");
}
@@ -569,13 +587,48 @@ impl String {
/// [`into_bytes`]: String::into_bytes
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn from_utf8(vec: Vec<u8>) -> Result<String, FromUtf8Error> {
+ pub fn from_utf8(vec: Vec<u8, Global, COOP_PREFERRED>) -> Result<String<COOP_PREFERRED>, FromUtf8Error<COOP_PREFERRED>> {
match str::from_utf8(&vec) {
Ok(..) => Ok(String { vec }),
Err(e) => Err(FromUtf8Error { bytes: vec, error: e }),
}
}
+ /// Like `from_utf8_lossy`, but this honors COOP_PREFERRED.
+ #[unstable(feature = "string_from_utf8_lossy_co", reason = "confirm_or_fix_the_function_name", issue = "none")]
+ pub fn from_utf8_lossy_co(v: &[u8]) -> Cow<'_, str, COOP_PREFERRED> {
+ let mut iter = Utf8Chunks::new(v);
+
+ let first_valid = if let Some(chunk) = iter.next() {
+ let valid = chunk.valid();
+ if chunk.invalid().is_empty() {
+ debug_assert_eq!(valid.len(), v.len());
+ return Cow::Borrowed(valid);
+ }
+ valid
+ } else {
+ return Cow::Borrowed("");
+ };
+
+ const REPLACEMENT: &str = "\u{FFFD}";
+
+ #[allow(unused_braces)]
+ let mut res = String::<COOP_PREFERRED>::with_capacity(v.len());
+ res.push_str(first_valid);
+ res.push_str(REPLACEMENT);
+
+ for chunk in iter {
+ res.push_str(chunk.valid());
+ if !chunk.invalid().is_empty() {
+ res.push_str(REPLACEMENT);
+ }
+ }
+
+ Cow::Owned(res)
+ }
+}
+
+impl String {
/// Converts a slice of bytes to a string, including invalid characters.
///
/// Strings are made of bytes ([`u8`]), and a slice of bytes
@@ -625,39 +678,22 @@ impl String {
///
/// assert_eq!("Hello �World", output);
/// ```
+ /// @FIXME Should this return Cow<'_, str, false> instead, so it's both
+ /// - backwards compatible, and
+ /// - independent of DEFAULT_COOP_PREFERRED (for backwards compatbility)? But `String` (and others) use default, too.
#[must_use]
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn from_utf8_lossy(v: &[u8]) -> Cow<'_, str> {
- let mut iter = Utf8Chunks::new(v);
-
- let first_valid = if let Some(chunk) = iter.next() {
- let valid = chunk.valid();
- if chunk.invalid().is_empty() {
- debug_assert_eq!(valid.len(), v.len());
- return Cow::Borrowed(valid);
- }
- valid
- } else {
- return Cow::Borrowed("");
- };
-
- const REPLACEMENT: &str = "\u{FFFD}";
-
- let mut res = String::with_capacity(v.len());
- res.push_str(first_valid);
- res.push_str(REPLACEMENT);
-
- for chunk in iter {
- res.push_str(chunk.valid());
- if !chunk.invalid().is_empty() {
- res.push_str(REPLACEMENT);
- }
- }
-
- Cow::Owned(res)
+ #[allow(unused_braces)]
+ pub fn from_utf8_lossy(v: &[u8]) -> Cow<'_, str, {DEFAULT_COOP_PREFERRED!()}> {
+ String::<{DEFAULT_COOP_PREFERRED!()}>::from_utf8_lossy_co(v)
}
+}
+impl<const COOP_PREFERRED: bool> String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
/// Decode a UTF-16–encoded vector `v` into a `String`, returning [`Err`]
/// if `v` contains any invalid data.
///
@@ -679,7 +715,7 @@ impl String {
/// ```
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn from_utf16(v: &[u16]) -> Result<String, FromUtf16Error> {
+ pub fn from_utf16(v: &[u16]) -> Result<String<COOP_PREFERRED>, FromUtf16Error> {
// This isn't done via collect::<Result<_, _>>() for performance reasons.
// FIXME: the function can be simplified again when #48994 is closed.
let mut ret = String::with_capacity(v.len());
@@ -721,7 +757,7 @@ impl String {
#[must_use]
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn from_utf16_lossy(v: &[u16]) -> String {
+ pub fn from_utf16_lossy(v: &[u16]) -> String<COOP_PREFERRED> {
decode_utf16(v.iter().cloned()).map(|r| r.unwrap_or(REPLACEMENT_CHARACTER)).collect()
}
@@ -807,7 +843,11 @@ impl String {
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub unsafe fn from_raw_parts(buf: *mut u8, length: usize, capacity: usize) -> String {
+ pub unsafe fn from_raw_parts(
+ buf: *mut u8,
+ length: usize,
+ capacity: usize,
+ ) -> String<COOP_PREFERRED> {
unsafe { String { vec: Vec::from_raw_parts(buf, length, capacity) } }
}
@@ -842,7 +882,9 @@ impl String {
#[inline]
#[must_use]
#[stable(feature = "rust1", since = "1.0.0")]
- pub unsafe fn from_utf8_unchecked(bytes: Vec<u8>) -> String {
+ pub unsafe fn from_utf8_unchecked(
+ bytes: Vec<u8, Global, COOP_PREFERRED>,
+ ) -> String<COOP_PREFERRED> {
String { vec: bytes }
}
@@ -863,7 +905,10 @@ impl String {
#[inline]
#[must_use = "`self` will be dropped if the result is not used"]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn into_bytes(self) -> Vec<u8> {
+ pub fn into_bytes(self) -> Vec<u8, Global, COOP_PREFERRED>
+ where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+ {
self.vec
}
@@ -1453,13 +1498,19 @@ impl String {
where
F: FnMut(char) -> bool,
{
- struct SetLenOnDrop<'a> {
- s: &'a mut String,
+ struct SetLenOnDrop<'a, const LOCAL_COOP_PREFERRED: bool>
+ where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(LOCAL_COOP_PREFERRED)]:,
+ {
+ s: &'a mut String<LOCAL_COOP_PREFERRED>,
idx: usize,
del_bytes: usize,
}
- impl<'a> Drop for SetLenOnDrop<'a> {
+ impl<'a, const LOCAL_COOP_PREFERRED: bool> Drop for SetLenOnDrop<'a, LOCAL_COOP_PREFERRED>
+ where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(LOCAL_COOP_PREFERRED)]:,
+ {
fn drop(&mut self) {
let new_len = self.idx - self.del_bytes;
debug_assert!(new_len <= self.s.len());
@@ -1610,7 +1661,10 @@ impl String {
/// ```
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
- pub unsafe fn as_mut_vec(&mut self) -> &mut Vec<u8> {
+ pub unsafe fn as_mut_vec(&mut self) -> &mut Vec<u8, Global, COOP_PREFERRED>
+ where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+ {
&mut self.vec
}
@@ -1684,7 +1738,10 @@ impl String {
#[inline]
#[stable(feature = "string_split_off", since = "1.16.0")]
#[must_use = "use `.truncate()` if you don't need the other half"]
- pub fn split_off(&mut self, at: usize) -> String {
+ pub fn split_off(&mut self, at: usize) -> String<COOP_PREFERRED>
+ where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+ {
assert!(self.is_char_boundary(at));
let other = self.vec.split_off(at);
unsafe { String::from_utf8_unchecked(other) }
@@ -1750,7 +1807,7 @@ impl String {
/// assert_eq!(s, "");
/// ```
#[stable(feature = "drain", since = "1.6.0")]
- pub fn drain<R>(&mut self, range: R) -> Drain<'_>
+ pub fn drain<R>(&mut self, range: R) -> Drain<'_, COOP_PREFERRED>
where
R: RangeBounds<usize>,
{
@@ -1880,7 +1937,9 @@ impl String {
}
}
-impl FromUtf8Error {
+impl <const COOP_PREFERRED: bool> FromUtf8Error<COOP_PREFERRED>
+where
+[(); alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:, {
/// Returns a slice of [`u8`]s bytes that were attempted to convert to a `String`.
///
/// # Examples
@@ -1921,7 +1980,10 @@ impl FromUtf8Error {
/// ```
#[must_use = "`self` will be dropped if the result is not used"]
#[stable(feature = "rust1", since = "1.0.0")]
- pub fn into_bytes(self) -> Vec<u8> {
+ pub fn into_bytes(self) -> Vec<u8, Global, COOP_PREFERRED>
+ where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+ {
self.bytes
}
@@ -1956,7 +2018,10 @@ impl FromUtf8Error {
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl fmt::Display for FromUtf8Error {
+impl<const COOP_PREFERRED: bool> fmt::Display for FromUtf8Error<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Display::fmt(&self.error, f)
}
@@ -1970,7 +2035,10 @@ impl fmt::Display for FromUtf16Error {
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl Error for FromUtf8Error {
+impl<const COOP_PREFERRED: bool> Error for FromUtf8Error<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
#[allow(deprecated)]
fn description(&self) -> &str {
"invalid utf-8"
@@ -1987,7 +2055,10 @@ impl Error for FromUtf16Error {
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
-impl Clone for String {
+impl<const COOP_PREFERRED: bool> Clone for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
fn clone(&self) -> Self {
String { vec: self.vec.clone() }
}
@@ -1999,8 +2070,11 @@ impl Clone for String {
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
-impl FromIterator<char> for String {
- fn from_iter<I: IntoIterator<Item = char>>(iter: I) -> String {
+impl<const COOP_PREFERRED: bool> FromIterator<char> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
+ fn from_iter<I: IntoIterator<Item = char>>(iter: I) -> String<COOP_PREFERRED> {
let mut buf = String::new();
buf.extend(iter);
buf
@@ -2009,8 +2083,11 @@ impl FromIterator<char> for String {
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "string_from_iter_by_ref", since = "1.17.0")]
-impl<'a> FromIterator<&'a char> for String {
- fn from_iter<I: IntoIterator<Item = &'a char>>(iter: I) -> String {
+impl<'a, const COOP_PREFERRED: bool> FromIterator<&'a char> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
+ fn from_iter<I: IntoIterator<Item = &'a char>>(iter: I) -> String<COOP_PREFERRED> {
let mut buf = String::new();
buf.extend(iter);
buf
@@ -2019,8 +2096,11 @@ impl<'a> FromIterator<&'a char> for String {
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a> FromIterator<&'a str> for String {
- fn from_iter<I: IntoIterator<Item = &'a str>>(iter: I) -> String {
+impl<'a, const COOP_PREFERRED: bool> FromIterator<&'a str> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
+ fn from_iter<I: IntoIterator<Item = &'a str>>(iter: I) -> String<COOP_PREFERRED> {
let mut buf = String::new();
buf.extend(iter);
buf
@@ -2029,8 +2109,13 @@ impl<'a> FromIterator<&'a str> for String {
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "extend_string", since = "1.4.0")]
-impl FromIterator<String> for String {
- fn from_iter<I: IntoIterator<Item = String>>(iter: I) -> String {
+impl<const COOP_PREFERRED: bool> FromIterator<String<COOP_PREFERRED>> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
+ fn from_iter<I: IntoIterator<Item = String<COOP_PREFERRED>>>(
+ iter: I,
+ ) -> String<COOP_PREFERRED> {
let mut iterator = iter.into_iter();
// Because we're iterating over `String`s, we can avoid at least
@@ -2048,8 +2133,11 @@ impl FromIterator<String> for String {
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "box_str2", since = "1.45.0")]
-impl FromIterator<Box<str>> for String {
- fn from_iter<I: IntoIterator<Item = Box<str>>>(iter: I) -> String {
+impl<const COOP_PREFERRED: bool> FromIterator<Box<str>> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
+ fn from_iter<I: IntoIterator<Item = Box<str>>>(iter: I) -> String<COOP_PREFERRED> {
let mut buf = String::new();
buf.extend(iter);
buf
@@ -2058,8 +2146,11 @@ impl FromIterator<Box<str>> for String {
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "herd_cows", since = "1.19.0")]
-impl<'a> FromIterator<Cow<'a, str>> for String {
- fn from_iter<I: IntoIterator<Item = Cow<'a, str>>>(iter: I) -> String {
+impl<'a, const COOP_PREFERRED: bool> FromIterator<Cow<'a, str, COOP_PREFERRED>> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
+ fn from_iter<I: IntoIterator<Item = Cow<'a, str, COOP_PREFERRED>>>(iter: I) -> String<COOP_PREFERRED> {
let mut iterator = iter.into_iter();
// Because we're iterating over CoWs, we can (potentially) avoid at least
@@ -2078,7 +2169,10 @@ impl<'a> FromIterator<Cow<'a, str>> for String {
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
-impl Extend<char> for String {
+impl<const COOP_PREFERRED: bool> Extend<char> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
fn extend<I: IntoIterator<Item = char>>(&mut self, iter: I) {
let iterator = iter.into_iter();
let (lower_bound, _) = iterator.size_hint();
@@ -2099,7 +2193,10 @@ impl Extend<char> for String {
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "extend_ref", since = "1.2.0")]
-impl<'a> Extend<&'a char> for String {
+impl<'a, const COOP_PREFERRED: bool> Extend<&'a char> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
fn extend<I: IntoIterator<Item = &'a char>>(&mut self, iter: I) {
self.extend(iter.into_iter().cloned());
}
@@ -2117,7 +2214,10 @@ impl<'a> Extend<&'a char> for String {
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a> Extend<&'a str> for String {
+impl<'a, const COOP_PREFERRED: bool> Extend<&'a str> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
fn extend<I: IntoIterator<Item = &'a str>>(&mut self, iter: I) {
iter.into_iter().for_each(move |s| self.push_str(s));
}
@@ -2130,7 +2230,9 @@ impl<'a> Extend<&'a str> for String {
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "box_str2", since = "1.45.0")]
-impl Extend<Box<str>> for String {
+impl<const COOP_PREFERRED: bool> Extend<Box<str>> for String<COOP_PREFERRED>
+where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
fn extend<I: IntoIterator<Item = Box<str>>>(&mut self, iter: I) {
iter.into_iter().for_each(move |s| self.push_str(&s));
}
@@ -2138,26 +2240,32 @@ impl Extend<Box<str>> for String {
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "extend_string", since = "1.4.0")]
-impl Extend<String> for String {
- fn extend<I: IntoIterator<Item = String>>(&mut self, iter: I) {
+impl<const COOP_PREFERRED: bool> Extend<String<COOP_PREFERRED>> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
+ fn extend<I: IntoIterator<Item = String<COOP_PREFERRED>>>(&mut self, iter: I) {
iter.into_iter().for_each(move |s| self.push_str(&s));
}
#[inline]
- fn extend_one(&mut self, s: String) {
+ fn extend_one(&mut self, s: String<COOP_PREFERRED>) {
self.push_str(&s);
}
}
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "herd_cows", since = "1.19.0")]
-impl<'a> Extend<Cow<'a, str>> for String {
- fn extend<I: IntoIterator<Item = Cow<'a, str>>>(&mut self, iter: I) {
+impl<'a, const COOP_PREFERRED: bool> Extend<Cow<'a, str, COOP_PREFERRED>> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
+ fn extend<I: IntoIterator<Item = Cow<'a, str, COOP_PREFERRED>>>(&mut self, iter: I) {
iter.into_iter().for_each(move |s| self.push_str(&s));
}
#[inline]
- fn extend_one(&mut self, s: Cow<'a, str>) {
+ fn extend_one(&mut self, s: Cow<'a, str, COOP_PREFERRED>) {
self.push_str(&s);
}
}
@@ -2174,7 +2282,10 @@ impl<'a> Extend<Cow<'a, str>> for String {
reason = "API not fully fleshed out and ready to be stabilized",
issue = "27721"
)]
-impl<'a, 'b> Pattern<'a> for &'b String {
+impl<'a, 'b, const COOP_PREFERRED: bool> Pattern<'a> for &'b String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
type Searcher = <&'b str as Pattern<'a>>::Searcher;
fn into_searcher(self, haystack: &'a str) -> <&'b str as Pattern<'a>>::Searcher {
@@ -2208,13 +2319,16 @@ impl<'a, 'b> Pattern<'a> for &'b String {
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl PartialEq for String {
+impl<const COOP_PREFERRED: bool> PartialEq for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
#[inline]
- fn eq(&self, other: &String) -> bool {
+ fn eq(&self, other: &String<COOP_PREFERRED>) -> bool {
PartialEq::eq(&self[..], &other[..])
}
#[inline]
- fn ne(&self, other: &String) -> bool {
+ fn ne(&self, other: &String<COOP_PREFERRED>) -> bool {
PartialEq::ne(&self[..], &other[..])
}
}
@@ -2249,6 +2363,7 @@ macro_rules! impl_eq {
};
}
+// @FIXME for COOP_PREFERRED
impl_eq! { String, str }
impl_eq! { String, &'a str }
#[cfg(not(no_global_oom_handling))]
@@ -2260,16 +2375,22 @@ impl_eq! { Cow<'a, str>, String }
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_default_impls", issue = "87864")]
-impl const Default for String {
+impl<const COOP_PREFERRED: bool> const Default for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
/// Creates an empty `String`.
#[inline]
- fn default() -> String {
+ fn default() -> String<COOP_PREFERRED> {
String::new()
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl fmt::Display for String {
+impl<const COOP_PREFERRED: bool> fmt::Display for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
#[inline]
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Display::fmt(&**self, f)
@@ -2277,7 +2398,10 @@ impl fmt::Display for String {
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl fmt::Debug for String {
+impl<const COOP_PREFERRED: bool> fmt::Debug for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
#[inline]
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Debug::fmt(&**self, f)
@@ -2285,7 +2409,10 @@ impl fmt::Debug for String {
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl hash::Hash for String {
+impl<const COOP_PREFERRED: bool> hash::Hash for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
#[inline]
fn hash<H: hash::Hasher>(&self, hasher: &mut H) {
(**self).hash(hasher)
@@ -2331,11 +2458,14 @@ impl hash::Hash for String {
/// ```
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
-impl Add<&str> for String {
- type Output = String;
+impl<const COOP_PREFERRED: bool> Add<&str> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
+ type Output = String<COOP_PREFERRED>;
#[inline]
- fn add(mut self, other: &str) -> String {
+ fn add(mut self, other: &str) -> String<COOP_PREFERRED> {
self.push_str(other);
self
}
@@ -2346,7 +2476,10 @@ impl Add<&str> for String {
/// This has the same behavior as the [`push_str`][String::push_str] method.
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "stringaddassign", since = "1.12.0")]
-impl AddAssign<&str> for String {
+impl<const COOP_PREFERRED: bool> AddAssign<&str> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
#[inline]
fn add_assign(&mut self, other: &str) {
self.push_str(other);
@@ -2354,7 +2487,10 @@ impl AddAssign<&str> for String {
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl ops::Index<ops::Range<usize>> for String {
+impl<const COOP_PREFERRED: bool> ops::Index<ops::Range<usize>> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
type Output = str;
#[inline]
@@ -2363,7 +2499,10 @@ impl ops::Index<ops::Range<usize>> for String {
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl ops::Index<ops::RangeTo<usize>> for String {
+impl<const COOP_PREFERRED: bool> ops::Index<ops::RangeTo<usize>> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
type Output = str;
#[inline]
@@ -2372,7 +2511,10 @@ impl ops::Index<ops::RangeTo<usize>> for String {
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl ops::Index<ops::RangeFrom<usize>> for String {
+impl<const COOP_PREFERRED: bool> ops::Index<ops::RangeFrom<usize>> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
type Output = str;
#[inline]
@@ -2381,7 +2523,10 @@ impl ops::Index<ops::RangeFrom<usize>> for String {
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl ops::Index<ops::RangeFull> for String {
+impl<const COOP_PREFERRED: bool> ops::Index<ops::RangeFull> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
type Output = str;
#[inline]
@@ -2390,7 +2535,10 @@ impl ops::Index<ops::RangeFull> for String {
}
}
#[stable(feature = "inclusive_range", since = "1.26.0")]
-impl ops::Index<ops::RangeInclusive<usize>> for String {
+impl<const COOP_PREFERRED: bool> ops::Index<ops::RangeInclusive<usize>> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
type Output = str;
#[inline]
@@ -2399,7 +2547,10 @@ impl ops::Index<ops::RangeInclusive<usize>> for String {
}
}
#[stable(feature = "inclusive_range", since = "1.26.0")]
-impl ops::Index<ops::RangeToInclusive<usize>> for String {
+impl<const COOP_PREFERRED: bool> ops::Index<ops::RangeToInclusive<usize>> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
type Output = str;
#[inline]
@@ -2409,42 +2560,62 @@ impl ops::Index<ops::RangeToInclusive<usize>> for String {
}
#[stable(feature = "derefmut_for_string", since = "1.3.0")]
-impl ops::IndexMut<ops::Range<usize>> for String {
+impl<const COOP_PREFERRED: bool> ops::IndexMut<ops::Range<usize>> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
#[inline]
fn index_mut(&mut self, index: ops::Range<usize>) -> &mut str {
&mut self[..][index]
}
}
#[stable(feature = "derefmut_for_string", since = "1.3.0")]
-impl ops::IndexMut<ops::RangeTo<usize>> for String {
+impl<const COOP_PREFERRED: bool> ops::IndexMut<ops::RangeTo<usize>> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
#[inline]
fn index_mut(&mut self, index: ops::RangeTo<usize>) -> &mut str {
&mut self[..][index]
}
}
#[stable(feature = "derefmut_for_string", since = "1.3.0")]
-impl ops::IndexMut<ops::RangeFrom<usize>> for String {
+impl<const COOP_PREFERRED: bool> ops::IndexMut<ops::RangeFrom<usize>> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
#[inline]
fn index_mut(&mut self, index: ops::RangeFrom<usize>) -> &mut str {
&mut self[..][index]
}
}
#[stable(feature = "derefmut_for_string", since = "1.3.0")]
-impl ops::IndexMut<ops::RangeFull> for String {
+impl<const COOP_PREFERRED: bool> ops::IndexMut<ops::RangeFull> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
#[inline]
fn index_mut(&mut self, _index: ops::RangeFull) -> &mut str {
unsafe { str::from_utf8_unchecked_mut(&mut *self.vec) }
}
}
#[stable(feature = "inclusive_range", since = "1.26.0")]
-impl ops::IndexMut<ops::RangeInclusive<usize>> for String {
+impl<const COOP_PREFERRED: bool> ops::IndexMut<ops::RangeInclusive<usize>>
+ for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
#[inline]
fn index_mut(&mut self, index: ops::RangeInclusive<usize>) -> &mut str {
IndexMut::index_mut(&mut **self, index)
}
}
#[stable(feature = "inclusive_range", since = "1.26.0")]
-impl ops::IndexMut<ops::RangeToInclusive<usize>> for String {
+impl<const COOP_PREFERRED: bool> ops::IndexMut<ops::RangeToInclusive<usize>>
+ for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
#[inline]
fn index_mut(&mut self, index: ops::RangeToInclusive<usize>) -> &mut str {
IndexMut::index_mut(&mut **self, index)
@@ -2452,7 +2623,10 @@ impl ops::IndexMut<ops::RangeToInclusive<usize>> for String {
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl ops::Deref for String {
+impl<const COOP_PREFERRED: bool> ops::Deref for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
type Target = str;
#[inline]
@@ -2462,7 +2636,10 @@ impl ops::Deref for String {
}
#[stable(feature = "derefmut_for_string", since = "1.3.0")]
-impl ops::DerefMut for String {
+impl<const COOP_PREFERRED: bool> ops::DerefMut for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
#[inline]
fn deref_mut(&mut self) -> &mut str {
unsafe { str::from_utf8_unchecked_mut(&mut *self.vec) }
@@ -2479,10 +2656,13 @@ pub type ParseError = core::convert::Infallible;
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
-impl FromStr for String {
+impl<const COOP_PREFERRED: bool> FromStr for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
type Err = core::convert::Infallible;
#[inline]
- fn from_str(s: &str) -> Result<String, Self::Err> {
+ fn from_str(s: &str) -> Result<String<COOP_PREFERRED>, Self::Err> {
Ok(String::from(s))
}
}
@@ -2497,7 +2677,15 @@ impl FromStr for String {
/// [`Display`]: fmt::Display
#[cfg_attr(not(test), rustc_diagnostic_item = "ToString")]
#[stable(feature = "rust1", since = "1.0.0")]
-pub trait ToString {
+#[allow(unused_braces)]
+pub trait ToString<const COOP_PREFERRED: bool = {DEFAULT_COOP_PREFERRED!()}>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
+ /// NOT for public use. Do not override. This exists to woraround (current) limitations of const generic defaults.
+ #[unstable(feature = "global_co_alloc", issue = "none")]
+ type RESULT = String<COOP_PREFERRED>;
+
/// Converts the given value to a `String`.
///
/// # Examples
@@ -2512,7 +2700,7 @@ pub trait ToString {
/// ```
#[rustc_conversion_suggestion]
#[stable(feature = "rust1", since = "1.0.0")]
- fn to_string(&self) -> String;
+ fn to_string(&self) -> Self::RESULT;
}
/// # Panics
@@ -2523,13 +2711,16 @@ pub trait ToString {
/// since `fmt::Write for String` never returns an error itself.
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: fmt::Display + ?Sized> ToString for T {
+impl<T: fmt::Display + ?Sized, const COOP_PREFERRED: bool> ToString<COOP_PREFERRED> for T
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
// A common guideline is to not inline generic functions. However,
// removing `#[inline]` from this method causes non-negligible regressions.
// See <https://github.com/rust-lang/rust/pull/74852>, the last attempt
// to try to remove it.
#[inline]
- default fn to_string(&self) -> String {
+ default fn to_string(&self) -> String<COOP_PREFERRED> {
let mut buf = String::new();
let mut formatter = core::fmt::Formatter::new(&mut buf);
// Bypass format_args!() to avoid write_str with zero-length strs
@@ -2541,27 +2732,36 @@ impl<T: fmt::Display + ?Sized> ToString for T {
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "char_to_string_specialization", since = "1.46.0")]
-impl ToString for char {
+impl<const COOP_PREFERRED: bool> ToString<COOP_PREFERRED> for char
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
#[inline]
- fn to_string(&self) -> String {
+ fn to_string(&self) -> String<COOP_PREFERRED> {
String::from(self.encode_utf8(&mut [0; 4]))
}
}
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "bool_to_string_specialization", since = "CURRENT_RUSTC_VERSION")]
-impl ToString for bool {
+impl<const COOP_PREFERRED: bool> ToString<COOP_PREFERRED> for bool
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
#[inline]
- fn to_string(&self) -> String {
+ fn to_string(&self) -> String<COOP_PREFERRED> {
String::from(if *self { "true" } else { "false" })
}
}
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "u8_to_string_specialization", since = "1.54.0")]
-impl ToString for u8 {
+impl<const COOP_PREFERRED: bool> ToString<COOP_PREFERRED> for u8
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
#[inline]
- fn to_string(&self) -> String {
+ fn to_string(&self) -> String<COOP_PREFERRED> {
let mut buf = String::with_capacity(3);
let mut n = *self;
if n >= 10 {
@@ -2579,9 +2779,12 @@ impl ToString for u8 {
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "i8_to_string_specialization", since = "1.54.0")]
-impl ToString for i8 {
+impl<const COOP_PREFERRED: bool> ToString<COOP_PREFERRED> for i8
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
#[inline]
- fn to_string(&self) -> String {
+ fn to_string(&self) -> String<COOP_PREFERRED> {
let mut buf = String::with_capacity(4);
if self.is_negative() {
buf.push('-');
@@ -2602,33 +2805,45 @@ impl ToString for i8 {
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "str_to_string_specialization", since = "1.9.0")]
-impl ToString for str {
+impl<const COOP_PREFERRED: bool> ToString<COOP_PREFERRED> for str
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
#[inline]
- fn to_string(&self) -> String {
+ fn to_string(&self) -> String<COOP_PREFERRED> {
String::from(self)
}
}
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "cow_str_to_string_specialization", since = "1.17.0")]
-impl ToString for Cow<'_, str> {
+impl<const COOP_PREFERRED: bool> ToString<COOP_PREFERRED> for Cow<'_, str, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
#[inline]
- fn to_string(&self) -> String {
+ fn to_string(&self) -> String<COOP_PREFERRED> {
self[..].to_owned()
}
}
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "string_to_string_specialization", since = "1.17.0")]
-impl ToString for String {
+impl<const COOP_PREFERRED: bool> ToString<COOP_PREFERRED> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
#[inline]
- fn to_string(&self) -> String {
+ fn to_string(&self) -> String<COOP_PREFERRED> {
self.to_owned()
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl AsRef<str> for String {
+impl<const COOP_PREFERRED: bool> AsRef<str> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
#[inline]
fn as_ref(&self) -> &str {
self
@@ -2636,7 +2851,10 @@ impl AsRef<str> for String {
}
#[stable(feature = "string_as_mut", since = "1.43.0")]
-impl AsMut<str> for String {
+impl<const COOP_PREFERRED: bool> AsMut<str> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
#[inline]
fn as_mut(&mut self) -> &mut str {
self
@@ -2644,7 +2862,10 @@ impl AsMut<str> for String {
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl AsRef<[u8]> for String {
+impl<const COOP_PREFERRED: bool> AsRef<[u8]> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
#[inline]
fn as_ref(&self) -> &[u8] {
self.as_bytes()
@@ -2653,36 +2874,45 @@ impl AsRef<[u8]> for String {
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
-impl From<&str> for String {
+impl<const COOP_PREFERRED: bool> From<&str> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
/// Converts a `&str` into a [`String`].
///
/// The result is allocated on the heap.
#[inline]
- fn from(s: &str) -> String {
+ fn from(s: &str) -> String<COOP_PREFERRED> {
s.to_owned()
}
}
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "from_mut_str_for_string", since = "1.44.0")]
-impl From<&mut str> for String {
+impl<const COOP_PREFERRED: bool> From<&mut str> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
/// Converts a `&mut str` into a [`String`].
///
/// The result is allocated on the heap.
#[inline]
- fn from(s: &mut str) -> String {
+ fn from(s: &mut str) -> String<COOP_PREFERRED> {
s.to_owned()
}
}
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "from_ref_string", since = "1.35.0")]
-impl From<&String> for String {
+impl<const COOP_PREFERRED: bool> From<&String<COOP_PREFERRED>> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
/// Converts a `&String` into a [`String`].
///
/// This clones `s` and returns the clone.
#[inline]
- fn from(s: &String) -> String {
+ fn from(s: &String<COOP_PREFERRED>) -> String<COOP_PREFERRED> {
s.clone()
}
}
@@ -2690,7 +2920,9 @@ impl From<&String> for String {
// note: test pulls in std, which causes errors here
#[cfg(not(test))]
#[stable(feature = "string_from_box", since = "1.18.0")]
-impl From<Box<str>> for String {
+impl<const COOP_PREFERRED: bool> From<Box<str>> for String<COOP_PREFERRED>
+where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
/// Converts the given boxed `str` slice to a [`String`].
/// It is notable that the `str` slice is owned.
///
@@ -2705,14 +2937,17 @@ impl From<Box<str>> for String {
///
/// assert_eq!("hello world", s3)
/// ```
- fn from(s: Box<str>) -> String {
+ fn from(s: Box<str>) -> String<COOP_PREFERRED> {
s.into_string()
}
}
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "box_from_str", since = "1.20.0")]
-impl From<String> for Box<str> {
+impl<const COOP_PREFERRED: bool> From<String<COOP_PREFERRED>> for Box<str>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
/// Converts the given [`String`] to a boxed `str` slice that is owned.
///
/// # Examples
@@ -2726,14 +2961,17 @@ impl From<String> for Box<str> {
///
/// assert_eq!("hello world", s3)
/// ```
- fn from(s: String) -> Box<str> {
+ fn from(s: String<COOP_PREFERRED>) -> Box<str> {
s.into_boxed_str()
}
}
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "string_from_cow_str", since = "1.14.0")]
-impl<'a> From<Cow<'a, str>> for String {
+impl<'a, const COOP_PREFERRED: bool> From<Cow<'a, str, COOP_PREFERRED>> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
/// Converts a clone-on-write string to an owned
/// instance of [`String`].
///
@@ -2750,14 +2988,17 @@ impl<'a> From<Cow<'a, str>> for String {
/// let owned: String = String::from(cow);
/// assert_eq!(&owned[..], "eggplant");
/// ```
- fn from(s: Cow<'a, str>) -> String {
+ fn from(s: Cow<'a, str, COOP_PREFERRED>) -> String<COOP_PREFERRED> {
s.into_owned()
}
}
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a> From<&'a str> for Cow<'a, str> {
+impl<'a, const COOP_PREFERRED: bool> From<&'a str> for Cow<'a, str, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
/// Converts a string slice into a [`Borrowed`] variant.
/// No heap allocation is performed, and the string
/// is not copied.
@@ -2771,14 +3012,17 @@ impl<'a> From<&'a str> for Cow<'a, str> {
///
/// [`Borrowed`]: crate::borrow::Cow::Borrowed "borrow::Cow::Borrowed"
#[inline]
- fn from(s: &'a str) -> Cow<'a, str> {
+ fn from(s: &'a str) -> Cow<'a, str, COOP_PREFERRED> {
Cow::Borrowed(s)
}
}
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a> From<String> for Cow<'a, str> {
+impl<'a, const COOP_PREFERRED: bool> From<String<COOP_PREFERRED>> for Cow<'a, str, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
/// Converts a [`String`] into an [`Owned`] variant.
/// No heap allocation is performed, and the string
/// is not copied.
@@ -2794,14 +3038,17 @@ impl<'a> From<String> for Cow<'a, str> {
///
/// [`Owned`]: crate::borrow::Cow::Owned "borrow::Cow::Owned"
#[inline]
- fn from(s: String) -> Cow<'a, str> {
+ fn from(s: String<COOP_PREFERRED>) -> Cow<'a, str, COOP_PREFERRED> {
Cow::Owned(s)
}
}
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "cow_from_string_ref", since = "1.28.0")]
-impl<'a> From<&'a String> for Cow<'a, str> {
+impl<'a, const COOP_PREFERRED: bool> From<&'a String<COOP_PREFERRED>> for Cow<'a, str, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
/// Converts a [`String`] reference into a [`Borrowed`] variant.
/// No heap allocation is performed, and the string
/// is not copied.
@@ -2816,37 +3063,49 @@ impl<'a> From<&'a String> for Cow<'a, str> {
///
/// [`Borrowed`]: crate::borrow::Cow::Borrowed "borrow::Cow::Borrowed"
#[inline]
- fn from(s: &'a String) -> Cow<'a, str> {
+ fn from(s: &'a String<COOP_PREFERRED>) -> Cow<'a, str, COOP_PREFERRED> {
Cow::Borrowed(s.as_str())
}
}
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "cow_str_from_iter", since = "1.12.0")]
-impl<'a> FromIterator<char> for Cow<'a, str> {
- fn from_iter<I: IntoIterator<Item = char>>(it: I) -> Cow<'a, str> {
+impl<'a, const COOP_PREFERRED: bool> FromIterator<char> for Cow<'a, str, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
+ fn from_iter<I: IntoIterator<Item = char>>(it: I) -> Cow<'a, str, COOP_PREFERRED> {
Cow::Owned(FromIterator::from_iter(it))
}
}
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "cow_str_from_iter", since = "1.12.0")]
-impl<'a, 'b> FromIterator<&'b str> for Cow<'a, str> {
- fn from_iter<I: IntoIterator<Item = &'b str>>(it: I) -> Cow<'a, str> {
+impl<'a, 'b, const COOP_PREFERRED: bool> FromIterator<&'b str> for Cow<'a, str, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
+ fn from_iter<I: IntoIterator<Item = &'b str>>(it: I) -> Cow<'a, str, COOP_PREFERRED> {
Cow::Owned(FromIterator::from_iter(it))
}
}
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "cow_str_from_iter", since = "1.12.0")]
-impl<'a> FromIterator<String> for Cow<'a, str> {
- fn from_iter<I: IntoIterator<Item = String>>(it: I) -> Cow<'a, str> {
+impl<'a, const COOP_PREFERRED: bool> FromIterator<String<COOP_PREFERRED>> for Cow<'a, str, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
+ fn from_iter<I: IntoIterator<Item = String<COOP_PREFERRED>>>(it: I) -> Cow<'a, str, COOP_PREFERRED> {
Cow::Owned(FromIterator::from_iter(it))
}
}
#[stable(feature = "from_string_for_vec_u8", since = "1.14.0")]
-impl From<String> for Vec<u8> {
+impl<const COOP_PREFERRED: bool> From<String<COOP_PREFERRED>> for Vec<u8, Global, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
/// Converts the given [`String`] to a vector [`Vec`] that holds values of type [`u8`].
///
/// # Examples
@@ -2861,14 +3120,17 @@ impl From<String> for Vec<u8> {
/// println!("{b}");
/// }
/// ```
- fn from(string: String) -> Vec<u8> {
+ fn from(string: String<COOP_PREFERRED>) -> Vec<u8, Global, COOP_PREFERRED> {
string.into_bytes()
}
}
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
-impl fmt::Write for String {
+impl<const COOP_PREFERRED: bool> fmt::Write for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
#[inline]
fn write_str(&mut self, s: &str) -> fmt::Result {
self.push_str(s);
@@ -2889,9 +3151,14 @@ impl fmt::Write for String {
///
/// [`drain`]: String::drain
#[stable(feature = "drain", since = "1.6.0")]
-pub struct Drain<'a> {
+#[allow(unused_braces)]
+// @FIXME Do we need to use DEFAULT_COOP_PREFERRED here?
+pub struct Drain<'a, const COOP_PREFERRED: bool = {DEFAULT_COOP_PREFERRED!()}>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
/// Will be used as &'a mut String in the destructor
- string: *mut String,
+ string: *mut String<COOP_PREFERRED>,
/// Start of part to remove
start: usize,
/// End of part to remove
@@ -2901,19 +3168,31 @@ pub struct Drain<'a> {
}
#[stable(feature = "collection_debug", since = "1.17.0")]
-impl fmt::Debug for Drain<'_> {
+impl<const COOP_PREFERRED: bool> fmt::Debug for Drain<'_, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_tuple("Drain").field(&self.as_str()).finish()
}
}
#[stable(feature = "drain", since = "1.6.0")]
-unsafe impl Sync for Drain<'_> {}
+unsafe impl<const COOP_PREFERRED: bool> Sync for Drain<'_, COOP_PREFERRED> where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:
+{
+}
#[stable(feature = "drain", since = "1.6.0")]
-unsafe impl Send for Drain<'_> {}
+unsafe impl<const COOP_PREFERRED: bool> Send for Drain<'_, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{}
#[stable(feature = "drain", since = "1.6.0")]
-impl Drop for Drain<'_> {
+impl<const COOP_PREFERRED: bool> Drop for Drain<'_, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
fn drop(&mut self) {
unsafe {
// Use Vec::drain. "Reaffirm" the bounds checks to avoid
@@ -2926,7 +3205,10 @@ impl Drop for Drain<'_> {
}
}
-impl<'a> Drain<'a> {
+impl<'a, const COOP_PREFERRED: bool> Drain<'a, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
/// Returns the remaining (sub)string of this iterator as a slice.
///
/// # Examples
@@ -2946,21 +3228,30 @@ impl<'a> Drain<'a> {
}
#[stable(feature = "string_drain_as_str", since = "1.55.0")]
-impl<'a> AsRef<str> for Drain<'a> {
+impl<'a, const COOP_PREFERRED: bool> AsRef<str> for Drain<'a, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
fn as_ref(&self) -> &str {
self.as_str()
}
}
#[stable(feature = "string_drain_as_str", since = "1.55.0")]
-impl<'a> AsRef<[u8]> for Drain<'a> {
+impl<'a, const COOP_PREFERRED: bool> AsRef<[u8]> for Drain<'a, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
fn as_ref(&self) -> &[u8] {
self.as_str().as_bytes()
}
}
#[stable(feature = "drain", since = "1.6.0")]
-impl Iterator for Drain<'_> {
+impl<const COOP_PREFERRED: bool> Iterator for Drain<'_, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
type Item = char;
#[inline]
@@ -2979,7 +3270,10 @@ impl Iterator for Drain<'_> {
}
#[stable(feature = "drain", since = "1.6.0")]
-impl DoubleEndedIterator for Drain<'_> {
+impl<const COOP_PREFERRED: bool> DoubleEndedIterator for Drain<'_, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
#[inline]
fn next_back(&mut self) -> Option<char> {
self.iter.next_back()
@@ -2987,11 +3281,17 @@ impl DoubleEndedIterator for Drain<'_> {
}
#[stable(feature = "fused", since = "1.26.0")]
-impl FusedIterator for Drain<'_> {}
+impl<const COOP_PREFERRED: bool> FusedIterator for Drain<'_, COOP_PREFERRED> where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:
+{
+}
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "from_char_for_string", since = "1.46.0")]
-impl From<char> for String {
+impl<const COOP_PREFERRED: bool> From<char> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
/// Allocates an owned [`String`] from a single character.
///
/// # Example
@@ -3001,7 +3301,7 @@ impl From<char> for String {
/// assert_eq!("a", &s[..]);
/// ```
#[inline]
- fn from(c: char) -> Self {
+ fn from(c: char) -> String<COOP_PREFERRED> {
c.to_string()
}
}
diff --git a/library/alloc/src/vec/drain.rs b/library/alloc/src/vec/drain.rs
index 2b1a787cc5499..a219ca302d4c4 100644
--- a/library/alloc/src/vec/drain.rs
+++ b/library/alloc/src/vec/drain.rs
@@ -3,7 +3,7 @@ use core::fmt;
use core::iter::{FusedIterator, TrustedLen};
use core::mem::{self, ManuallyDrop, SizedTypeProperties};
use core::ptr::{self, NonNull};
-use core::slice::{self};
+use core::{alloc, slice};
use super::Vec;
@@ -19,28 +19,39 @@ use super::Vec;
/// let iter: std::vec::Drain<_> = v.drain(..);
/// ```
#[stable(feature = "drain", since = "1.6.0")]
+#[allow(unused_braces)]
pub struct Drain<
'a,
T: 'a,
#[unstable(feature = "allocator_api", issue = "32838")] A: Allocator + 'a = Global,
-> {
+ const COOP_PREFERRED: bool = { SHORT_TERM_VEC_PREFERS_COOP!() },
+> where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
/// Index of tail to preserve
pub(super) tail_start: usize,
/// Length of tail
pub(super) tail_len: usize,
/// Current remaining range to remove
pub(super) iter: slice::Iter<'a, T>,
- pub(super) vec: NonNull<Vec<T, A>>,
+ pub(super) vec: NonNull<Vec<T, A, COOP_PREFERRED>>,
}
#[stable(feature = "collection_debug", since = "1.17.0")]
-impl<T: fmt::Debug, A: Allocator> fmt::Debug for Drain<'_, T, A> {
+impl<T: fmt::Debug, A: Allocator, const COOP_PREFERRED: bool> fmt::Debug
+ for Drain<'_, T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_tuple("Drain").field(&self.iter.as_slice()).finish()
}
}
-impl<'a, T, A: Allocator> Drain<'a, T, A> {
+impl<'a, T, A: Allocator, const COOP_PREFERRED: bool> Drain<'a, T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
/// Returns the remaining items of this iterator as a slice.
///
/// # Examples
@@ -139,19 +150,35 @@ impl<'a, T, A: Allocator> Drain<'a, T, A> {
}
#[stable(feature = "vec_drain_as_slice", since = "1.46.0")]
-impl<'a, T, A: Allocator> AsRef<[T]> for Drain<'a, T, A> {
+impl<'a, T, A: Allocator, const COOP_PREFERRED: bool> AsRef<[T]> for Drain<'a, T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
fn as_ref(&self) -> &[T] {
self.as_slice()
}
}
#[stable(feature = "drain", since = "1.6.0")]
-unsafe impl<T: Sync, A: Sync + Allocator> Sync for Drain<'_, T, A> {}
+unsafe impl<T: Sync, A: Sync + Allocator, const COOP_PREFERRED: bool> Sync
+ for Drain<'_, T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
+}
#[stable(feature = "drain", since = "1.6.0")]
-unsafe impl<T: Send, A: Send + Allocator> Send for Drain<'_, T, A> {}
+unsafe impl<T: Send, A: Send + Allocator, const COOP_PREFERRED: bool> Send
+ for Drain<'_, T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
+}
#[stable(feature = "drain", since = "1.6.0")]
-impl<T, A: Allocator> Iterator for Drain<'_, T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> Iterator for Drain<'_, T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
type Item = T;
#[inline]
@@ -165,7 +192,11 @@ impl<T, A: Allocator> Iterator for Drain<'_, T, A> {
}
#[stable(feature = "drain", since = "1.6.0")]
-impl<T, A: Allocator> DoubleEndedIterator for Drain<'_, T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> DoubleEndedIterator
+ for Drain<'_, T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
#[inline]
fn next_back(&mut self) -> Option<T> {
self.iter.next_back().map(|elt| unsafe { ptr::read(elt as *const _) })
@@ -173,12 +204,23 @@ impl<T, A: Allocator> DoubleEndedIterator for Drain<'_, T, A> {
}
#[stable(feature = "drain", since = "1.6.0")]
-impl<T, A: Allocator> Drop for Drain<'_, T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> Drop for Drain<'_, T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
fn drop(&mut self) {
/// Moves back the un-`Drain`ed elements to restore the original `Vec`.
- struct DropGuard<'r, 'a, T, A: Allocator>(&'r mut Drain<'a, T, A>);
-
- impl<'r, 'a, T, A: Allocator> Drop for DropGuard<'r, 'a, T, A> {
+ struct DropGuard<'r, 'a, T, A: Allocator, const COOP_PREFERRED: bool>(
+ &'r mut Drain<'a, T, A, COOP_PREFERRED>,
+ )
+ where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:;
+
+ impl<'r, 'a, T, A: Allocator, const COOP_PREFERRED: bool> Drop
+ for DropGuard<'r, 'a, T, A, COOP_PREFERRED>
+ where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+ {
fn drop(&mut self) {
if self.0.tail_len > 0 {
unsafe {
@@ -242,14 +284,26 @@ impl<T, A: Allocator> Drop for Drain<'_, T, A> {
}
#[stable(feature = "drain", since = "1.6.0")]
-impl<T, A: Allocator> ExactSizeIterator for Drain<'_, T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> ExactSizeIterator
+ for Drain<'_, T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
fn is_empty(&self) -> bool {
self.iter.is_empty()
}
}
#[unstable(feature = "trusted_len", issue = "37572")]
-unsafe impl<T, A: Allocator> TrustedLen for Drain<'_, T, A> {}
+unsafe impl<T, A: Allocator, const COOP_PREFERRED: bool> TrustedLen
+ for Drain<'_, T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
+}
#[stable(feature = "fused", since = "1.26.0")]
-impl<T, A: Allocator> FusedIterator for Drain<'_, T, A> {}
+impl<T, A: Allocator, const COOP_PREFERRED: bool> FusedIterator for Drain<'_, T, A, COOP_PREFERRED> where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:
+{
+}
diff --git a/library/alloc/src/vec/drain_filter.rs b/library/alloc/src/vec/drain_filter.rs
index 8c03f1692d940..89baafca46729 100644
--- a/library/alloc/src/vec/drain_filter.rs
+++ b/library/alloc/src/vec/drain_filter.rs
@@ -1,7 +1,6 @@
use crate::alloc::{Allocator, Global};
use core::mem::{self, ManuallyDrop};
-use core::ptr;
-use core::slice;
+use core::{alloc, ptr, slice};
use super::Vec;
@@ -25,10 +24,12 @@ pub struct DrainFilter<
T,
F,
#[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+ const COOP_PREFERRED: bool = true,
> where
F: FnMut(&mut T) -> bool,
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
{
- pub(super) vec: &'a mut Vec<T, A>,
+ pub(super) vec: &'a mut Vec<T, A, COOP_PREFERRED>,
/// The index of the item that will be inspected by the next call to `next`.
pub(super) idx: usize,
/// The number of items that have been drained (removed) thus far.
@@ -45,9 +46,10 @@ pub struct DrainFilter<
pub(super) panic_flag: bool,
}
-impl<T, F, A: Allocator> DrainFilter<'_, T, F, A>
+impl<T, F, A: Allocator, const COOP_PREFERRED: bool> DrainFilter<'_, T, F, A, COOP_PREFERRED>
where
F: FnMut(&mut T) -> bool,
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
{
/// Returns a reference to the underlying allocator.
#[unstable(feature = "allocator_api", issue = "32838")]
@@ -113,9 +115,11 @@ where
}
#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")]
-impl<T, F, A: Allocator> Iterator for DrainFilter<'_, T, F, A>
+impl<T, F, A: Allocator, const COOP_PREFERRED: bool> Iterator
+ for DrainFilter<'_, T, F, A, COOP_PREFERRED>
where
F: FnMut(&mut T) -> bool,
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
{
type Item = T;
@@ -151,21 +155,26 @@ where
}
#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")]
-impl<T, F, A: Allocator> Drop for DrainFilter<'_, T, F, A>
+impl<T, F, A: Allocator, const COOP_PREFERRED: bool> Drop
+ for DrainFilter<'_, T, F, A, COOP_PREFERRED>
where
F: FnMut(&mut T) -> bool,
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
{
fn drop(&mut self) {
- struct BackshiftOnDrop<'a, 'b, T, F, A: Allocator>
+ struct BackshiftOnDrop<'a, 'b, T, F, A: Allocator, const COOP_PREFERRED: bool>
where
F: FnMut(&mut T) -> bool,
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
{
- drain: &'b mut DrainFilter<'a, T, F, A>,
+ drain: &'b mut DrainFilter<'a, T, F, A, COOP_PREFERRED>,
}
- impl<'a, 'b, T, F, A: Allocator> Drop for BackshiftOnDrop<'a, 'b, T, F, A>
+ impl<'a, 'b, T, F, A: Allocator, const COOP_PREFERRED: bool> Drop
+ for BackshiftOnDrop<'a, 'b, T, F, A, COOP_PREFERRED>
where
F: FnMut(&mut T) -> bool,
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
{
fn drop(&mut self) {
unsafe {
diff --git a/library/alloc/src/vec/in_place_collect.rs b/library/alloc/src/vec/in_place_collect.rs
index 87d61deb1eb2f..69f8ea9a61d3b 100644
--- a/library/alloc/src/vec/in_place_collect.rs
+++ b/library/alloc/src/vec/in_place_collect.rs
@@ -137,6 +137,8 @@
//! }
//! vec.truncate(write_idx);
//! ```
+use core::alloc;
+use crate::alloc::Global;
use core::iter::{InPlaceIterable, SourceIter, TrustedRandomAccessNoCoerce};
use core::mem::{self, ManuallyDrop, SizedTypeProperties};
use core::ptr::{self};
@@ -150,9 +152,12 @@ pub(super) trait InPlaceIterableMarker {}
impl<T> InPlaceIterableMarker for T where T: InPlaceIterable {}
-impl<T, I> SpecFromIter<T, I> for Vec<T>
+#[allow(unused_braces)]
+impl<T, I, const COOP_PREFERRED: bool> SpecFromIter<T, I> for Vec<T, Global, COOP_PREFERRED>
where
I: Iterator<Item = T> + SourceIter<Source: AsVecIntoIter> + InPlaceIterableMarker,
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+
{
default fn from_iter(mut iterator: I) -> Self {
// See "Layout constraints" section in the module documentation. We rely on const
diff --git a/library/alloc/src/vec/in_place_drop.rs b/library/alloc/src/vec/in_place_drop.rs
index 25ca33c6a7bf0..871fd08b1f6b1 100644
--- a/library/alloc/src/vec/in_place_drop.rs
+++ b/library/alloc/src/vec/in_place_drop.rs
@@ -1,5 +1,6 @@
use core::ptr::{self};
use core::slice::{self};
+use crate::alloc::Global;
// A helper struct for in-place iteration that drops the destination slice of iteration,
// i.e. the head. The source slice (the tail) is dropped by IntoIter.
@@ -34,6 +35,7 @@ pub(super) struct InPlaceDstBufDrop<T> {
impl<T> Drop for InPlaceDstBufDrop<T> {
#[inline]
fn drop(&mut self) {
- unsafe { super::Vec::from_raw_parts(self.ptr, self.len, self.cap) };
+ // false = no need for co-alloc metadata, since it would get lost once converted to Box.
+ unsafe { super::Vec::<T, Global, false>::from_raw_parts(self.ptr, self.len, self.cap) };
}
}
diff --git a/library/alloc/src/vec/into_iter.rs b/library/alloc/src/vec/into_iter.rs
index 37966007eb7e4..f4d5676f01e55 100644
--- a/library/alloc/src/vec/into_iter.rs
+++ b/library/alloc/src/vec/into_iter.rs
@@ -4,8 +4,6 @@ use crate::alloc::{Allocator, Global};
#[cfg(not(no_global_oom_handling))]
use crate::collections::VecDeque;
use crate::raw_vec::RawVec;
-use core::array;
-use core::fmt;
use core::iter::{
FusedIterator, InPlaceIterable, SourceIter, TrustedLen, TrustedRandomAccessNoCoerce,
};
@@ -15,6 +13,7 @@ use core::mem::{self, ManuallyDrop, MaybeUninit, SizedTypeProperties};
use core::ops::Deref;
use core::ptr::{self, NonNull};
use core::slice::{self};
+use core::{alloc, array, fmt};
/// An iterator that moves out of a vector.
///
@@ -29,10 +28,14 @@ use core::slice::{self};
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_insignificant_dtor]
+#[allow(unused_braces)]
pub struct IntoIter<
T,
#[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
-> {
+ const COOP_PREFERRED: bool = { SHORT_TERM_VEC_PREFERS_COOP!() },
+> where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
pub(super) buf: NonNull<T>,
pub(super) phantom: PhantomData<T>,
pub(super) cap: usize,
@@ -46,13 +49,20 @@ pub struct IntoIter<
}
#[stable(feature = "vec_intoiter_debug", since = "1.13.0")]
-impl<T: fmt::Debug, A: Allocator> fmt::Debug for IntoIter<T, A> {
+impl<T: fmt::Debug, A: Allocator, const COOP_PREFERRED: bool> fmt::Debug
+ for IntoIter<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_tuple("IntoIter").field(&self.as_slice()).finish()
}
}
-impl<T, A: Allocator> IntoIter<T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> IntoIter<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
/// Returns the remaining items of this iterator as a slice.
///
/// # Examples
@@ -121,7 +131,17 @@ impl<T, A: Allocator> IntoIter<T, A> {
// struct and then overwriting &mut self.
// this creates less assembly
self.cap = 0;
- self.buf = unsafe { NonNull::new_unchecked(RawVec::NEW.ptr()) };
+ self.buf = unsafe {
+ // @FIXME The below if COOP_PREFERRED {..} else {..}
+ // branching exists, because the following fails. Otherwise we'd have a snowball effect of wide spread of where...Global...
+ //
+ // NonNull::new_unchecked(RawVec::<T, Global, COOP_PREFERRED>::NEW.ptr())
+ if COOP_PREFERRED {
+ NonNull::new_unchecked(RawVec::<T, Global, true>::NEW.ptr())
+ } else {
+ NonNull::new_unchecked(RawVec::<T, Global, false>::NEW.ptr())
+ }
+ };
self.ptr = self.buf.as_ptr();
self.end = self.buf.as_ptr();
@@ -141,7 +161,7 @@ impl<T, A: Allocator> IntoIter<T, A> {
#[cfg(not(no_global_oom_handling))]
#[inline]
- pub(crate) fn into_vecdeque(self) -> VecDeque<T, A> {
+ pub(crate) fn into_vecdeque(self) -> VecDeque<T, A, COOP_PREFERRED> {
// Keep our `Drop` impl from dropping the elements and the allocator
let mut this = ManuallyDrop::new(self);
@@ -168,19 +188,35 @@ impl<T, A: Allocator> IntoIter<T, A> {
}
#[stable(feature = "vec_intoiter_as_ref", since = "1.46.0")]
-impl<T, A: Allocator> AsRef<[T]> for IntoIter<T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> AsRef<[T]> for IntoIter<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
fn as_ref(&self) -> &[T] {
self.as_slice()
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-unsafe impl<T: Send, A: Allocator + Send> Send for IntoIter<T, A> {}
+unsafe impl<T: Send, A: Allocator + Send, const COOP_PREFERRED: bool> Send
+ for IntoIter<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
+}
#[stable(feature = "rust1", since = "1.0.0")]
-unsafe impl<T: Sync, A: Allocator + Sync> Sync for IntoIter<T, A> {}
+unsafe impl<T: Sync, A: Allocator + Sync, const COOP_PREFERRED: bool> Sync
+ for IntoIter<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
+}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T, A: Allocator> Iterator for IntoIter<T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> Iterator for IntoIter<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
type Item = T;
#[inline]
@@ -294,7 +330,11 @@ impl<T, A: Allocator> Iterator for IntoIter<T, A> {
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T, A: Allocator> DoubleEndedIterator for IntoIter<T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> DoubleEndedIterator
+ for IntoIter<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
#[inline]
fn next_back(&mut self) -> Option<T> {
if self.end == self.ptr {
@@ -335,17 +375,29 @@ impl<T, A: Allocator> DoubleEndedIterator for IntoIter<T, A> {
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T, A: Allocator> ExactSizeIterator for IntoIter<T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> ExactSizeIterator
+ for IntoIter<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
fn is_empty(&self) -> bool {
self.ptr == self.end
}
}
#[stable(feature = "fused", since = "1.26.0")]
-impl<T, A: Allocator> FusedIterator for IntoIter<T, A> {}
+impl<T, A: Allocator, const COOP_PREFERRED: bool> FusedIterator for IntoIter<T, A, COOP_PREFERRED> where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:
+{
+}
#[unstable(feature = "trusted_len", issue = "37572")]
-unsafe impl<T, A: Allocator> TrustedLen for IntoIter<T, A> {}
+unsafe impl<T, A: Allocator, const COOP_PREFERRED: bool> TrustedLen
+ for IntoIter<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
+}
#[doc(hidden)]
#[unstable(issue = "none", feature = "std_internals")]
@@ -361,19 +413,31 @@ impl<T: Copy> NonDrop for T {}
#[unstable(issue = "none", feature = "std_internals")]
// TrustedRandomAccess (without NoCoerce) must not be implemented because
// subtypes/supertypes of `T` might not be `NonDrop`
-unsafe impl<T, A: Allocator> TrustedRandomAccessNoCoerce for IntoIter<T, A>
+unsafe impl<T, A: Allocator, const COOP_PREFERRED: bool> TrustedRandomAccessNoCoerce
+ for IntoIter<T, A, COOP_PREFERRED>
where
T: NonDrop,
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
{
const MAY_HAVE_SIDE_EFFECT: bool = false;
}
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "vec_into_iter_clone", since = "1.8.0")]
-impl<T: Clone, A: Allocator + Clone> Clone for IntoIter<T, A> {
+impl<T: Clone, A: Allocator + Clone, const COOP_PREFERRED: bool> Clone
+ for IntoIter<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
#[cfg(not(test))]
fn clone(&self) -> Self {
- self.as_slice().to_vec_in(self.alloc.deref().clone()).into_iter()
+ // @FIXME Remove the following extras - used for type checks only
+ let slice = self.as_slice();
+ let vec: crate::vec::Vec<T, A, COOP_PREFERRED> = slice.to_vec_in::<A, COOP_PREFERRED>(self.alloc.deref().clone());
+ let _iter: IntoIter<T, A, COOP_PREFERRED> = vec.into_iter();
+
+ //self.as_slice().to_vec_in::<A, COOP_PREFERRED>(self.alloc.deref().clone()).into_iter()
+ loop {}
}
#[cfg(test)]
fn clone(&self) -> Self {
@@ -382,17 +446,33 @@ impl<T: Clone, A: Allocator + Clone> Clone for IntoIter<T, A> {
}
#[stable(feature = "rust1", since = "1.0.0")]
-unsafe impl<#[may_dangle] T, A: Allocator> Drop for IntoIter<T, A> {
+unsafe impl<#[may_dangle] T, A: Allocator, const COOP_PREFERRED: bool> Drop
+ for IntoIter<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
fn drop(&mut self) {
- struct DropGuard<'a, T, A: Allocator>(&'a mut IntoIter<T, A>);
-
- impl<T, A: Allocator> Drop for DropGuard<'_, T, A> {
+ struct DropGuard<'a, T, A: Allocator, const COOP_PREFERRED: bool>(
+ &'a mut IntoIter<T, A, COOP_PREFERRED>,
+ )
+ where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:;
+
+ impl<T, A: Allocator, const COOP_PREFERRED: bool> Drop for DropGuard<'_, T, A, COOP_PREFERRED>
+ where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+ {
fn drop(&mut self) {
unsafe {
// `IntoIter::alloc` is not used anymore after this and will be dropped by RawVec
let alloc = ManuallyDrop::take(&mut self.0.alloc);
// RawVec handles deallocation
- let _ = RawVec::from_raw_parts_in(self.0.buf.as_ptr(), self.0.cap, alloc);
+ // @FIXME pass true instead of COOP_PREFERRED - use e.g.: if COOP_PREFERRED {let _ = RawVec::<T, A, COOP_PREFERRED>::from_raw_parts_in(..) } else { let _ = from_raw_parts_in_coop(...)} }
+ let _ = RawVec::<T, A, COOP_PREFERRED>::from_raw_parts_in(
+ self.0.buf.as_ptr(),
+ self.0.cap,
+ alloc,
+ );
}
}
}
@@ -410,11 +490,20 @@ unsafe impl<#[may_dangle] T, A: Allocator> Drop for IntoIter<T, A> {
// also refer to the vec::in_place_collect module documentation to get an overview
#[unstable(issue = "none", feature = "inplace_iteration")]
#[doc(hidden)]
-unsafe impl<T, A: Allocator> InPlaceIterable for IntoIter<T, A> {}
+unsafe impl<T, A: Allocator, const COOP_PREFERRED: bool> InPlaceIterable
+ for IntoIter<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
+}
#[unstable(issue = "none", feature = "inplace_iteration")]
#[doc(hidden)]
-unsafe impl<T, A: Allocator> SourceIter for IntoIter<T, A> {
+unsafe impl<T, A: Allocator, const COOP_PREFERRED: bool> SourceIter
+ for IntoIter<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
type Source = Self;
#[inline]
diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs
index 36b0b3c9e7cc0..6abf1d820ec1a 100644
--- a/library/alloc/src/vec/mod.rs
+++ b/library/alloc/src/vec/mod.rs
@@ -54,6 +54,7 @@
#![stable(feature = "rust1", since = "1.0.0")]
#[cfg(not(no_global_oom_handling))]
+use core::alloc;
use core::cmp;
use core::cmp::Ordering;
use core::convert::TryFrom;
@@ -148,6 +149,14 @@ use self::spec_extend::SpecExtend;
#[cfg(not(no_global_oom_handling))]
mod spec_extend;
+/// Default `Vec`, `DefVec`, `DecVeque`, `DefDecVeq` "cooperation" (`COOP_PREFERRED`) generic parameter.
+#[unstable(feature = "global_co_alloc_def", issue = "none")]
+// pub const DEFAULT_COOP_PREFERRED: bool = true;
+#[macro_export]
+macro_rules! DEFAULT_COOP_PREFERRED {
+ () => {true}
+}
+
/// A contiguous growable array type, written as `Vec<T>`, short for 'vector'.
///
/// # Examples
@@ -397,14 +406,43 @@ mod spec_extend;
#[stable(feature = "rust1", since = "1.0.0")]
#[cfg_attr(not(test), rustc_diagnostic_item = "Vec")]
#[rustc_insignificant_dtor]
-pub struct Vec<T, #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global> {
- buf: RawVec<T, A>,
+#[allow(unused_braces)]
+pub struct Vec<
+ T,
+ #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+ //@FIXME: #[unstable(feature ="global_co_alloc_vec", issue="none")]
+ const COOP_PREFERRED: bool = {DEFAULT_COOP_PREFERRED!()},
+> where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
+ buf: RawVec<T, A, COOP_PREFERRED>,
len: usize,
}
-////////////////////////////////////////////////////////////////////////////////
-// Inherent methods
-////////////////////////////////////////////////////////////////////////////////
+/// "Cooperative" Vector. Preferring co-alloc API (if Global alloc supports it).
+#[unstable(feature = "global_co_alloc_covec", issue = "none")]
+pub type CoVec<T, A = Global> =
+ Vec<T, A, true>;
+
+/// "Plain" Vec. Not "cooperative" - not carrying extra data to assist the allocator.
+/// FIXME after cleanup, see if we still use this in core:: and/or alloc::
+#[unstable(feature = "global_co_alloc_plvec", issue = "none")]
+pub type PlVec<T, A = Global> =
+ Vec<T, A, false>;
+
+/// "Default" Vec. Either "cooperative" or not - as specified by `DEFAULT_COOP_PREFERRED`. The
+/// difference to `Vec` (used without specifying `COOP_PREFERRED`): `DefVec` indicates that the
+/// author considered using `CoVec` or `PlVec`, but left it to default instead.
+#[unstable(feature = "global_co_alloc_defvec", issue = "none")]
+#[allow(unused_braces)]
+pub type DefVec<T, A = Global> =
+ Vec<T, A, {DEFAULT_COOP_PREFERRED!()}>;
+
+/// "Weighted cooperative" Vec. Weight means how much it wants to cooperate (with the allocator). 0
+/// = always pack; u8::MAX = always cooperate (if `Global` supports it).
+/// @FIXME A `pub const` threshold.
+#[unstable(feature = "global_co_alloc_vec", issue = "none")]
+pub type WeVec<T, const WEIGHT: u8> = Vec<T, Global, { WEIGHT > 127 }>;
impl<T> Vec<T> {
/// Constructs a new, empty `Vec<T>`.
@@ -422,6 +460,25 @@ impl<T> Vec<T> {
#[stable(feature = "rust1", since = "1.0.0")]
#[must_use]
pub const fn new() -> Self {
+ #[allow(unused_braces)]
+ Vec::<T, Global, {DEFAULT_COOP_PREFERRED!()}>::new_co()
+ }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Inherent methods
+////////////////////////////////////////////////////////////////////////////////
+
+impl<T, const COOP_PREFERRED: bool> Vec<T, Global, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
+ /// Like new(), but it respects COOP_PREFERRED.
+ #[inline]
+ #[rustc_const_stable(feature = "const_vec_new_co", since = "1.60.0")] //@FIXME This is `rustc_const_stable`, so that String::new() can be const and can call this.
+ #[unstable(feature = "vec_new_co", reason = "confirm_or_fix_the_function_name", issue = "none")]
+ #[must_use]
+ pub const fn new_co() -> Self {
Vec { buf: RawVec::NEW, len: 0 }
}
@@ -593,7 +650,10 @@ impl<T> Vec<T> {
}
}
-impl<T, A: Allocator> Vec<T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> Vec<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
/// Constructs a new, empty `Vec<T, A>`.
///
/// The vector will not allocate until elements are pushed onto it.
@@ -1606,14 +1666,24 @@ impl<T, A: Allocator> Vec<T, A> {
// This drop guard will be invoked when predicate or `drop` of element panicked.
// It shifts unchecked elements to cover holes and `set_len` to the correct length.
// In cases when predicate and `drop` never panick, it will be optimized out.
- struct BackshiftOnDrop<'a, T, A: Allocator> {
- v: &'a mut Vec<T, A>,
+ struct BackshiftOnDrop<'a, T, A: Allocator, const VEC_IS_COOP: bool = true>
+ where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(
+ VEC_IS_COOP,
+ )]:,
+ {
+ v: &'a mut Vec<T, A, VEC_IS_COOP>,
processed_len: usize,
deleted_cnt: usize,
original_len: usize,
}
- impl<T, A: Allocator> Drop for BackshiftOnDrop<'_, T, A> {
+ impl<T, A: Allocator, const VEC_IS_COOP: bool> Drop for BackshiftOnDrop<'_, T, A, VEC_IS_COOP>
+ where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(
+ VEC_IS_COOP,
+ )]:,
+ {
fn drop(&mut self) {
if self.deleted_cnt > 0 {
// SAFETY: Trailing unchecked items must be valid since we never touch them.
@@ -1632,14 +1702,22 @@ impl<T, A: Allocator> Vec<T, A> {
}
}
- let mut g = BackshiftOnDrop { v: self, processed_len: 0, deleted_cnt: 0, original_len };
+ let mut g = BackshiftOnDrop::<T, A, COOP_PREFERRED> {
+ v: self,
+ processed_len: 0,
+ deleted_cnt: 0,
+ original_len,
+ };
- fn process_loop<F, T, A: Allocator, const DELETED: bool>(
+ fn process_loop<F, T, A: Allocator, const DELETED: bool, const VEC_IS_COOP: bool>(
original_len: usize,
f: &mut F,
- g: &mut BackshiftOnDrop<'_, T, A>,
+ g: &mut BackshiftOnDrop<'_, T, A, VEC_IS_COOP>,
) where
F: FnMut(&mut T) -> bool,
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(
+ VEC_IS_COOP,
+ )]:,
{
while g.processed_len != original_len {
// SAFETY: Unchecked element must be valid.
@@ -1670,10 +1748,10 @@ impl<T, A: Allocator> Vec<T, A> {
}
// Stage 1: Nothing was deleted.
- process_loop::<F, T, A, false>(original_len, &mut f, &mut g);
+ process_loop::<F, T, A, false, COOP_PREFERRED>(original_len, &mut f, &mut g);
// Stage 2: Some elements were deleted.
- process_loop::<F, T, A, true>(original_len, &mut f, &mut g);
+ process_loop::<F, T, A, true, COOP_PREFERRED>(original_len, &mut f, &mut g);
// All item are processed. This can be optimized to `set_len` by LLVM.
drop(g);
@@ -1732,7 +1810,12 @@ impl<T, A: Allocator> Vec<T, A> {
}
/* INVARIANT: vec.len() > read >= write > write-1 >= 0 */
- struct FillGapOnDrop<'a, T, A: core::alloc::Allocator> {
+ struct FillGapOnDrop<'a, T, A: core::alloc::Allocator, const COOP_PREFERRED: bool>
+ where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(
+ COOP_PREFERRED,
+ )]:,
+ {
/* Offset of the element we want to check if it is duplicate */
read: usize,
@@ -1741,10 +1824,16 @@ impl<T, A: Allocator> Vec<T, A> {
write: usize,
/* The Vec that would need correction if `same_bucket` panicked */
- vec: &'a mut Vec<T, A>,
+ vec: &'a mut Vec<T, A, COOP_PREFERRED>,
}
- impl<'a, T, A: core::alloc::Allocator> Drop for FillGapOnDrop<'a, T, A> {
+ impl<'a, T, A: core::alloc::Allocator, const COOP_PREFERRED: bool> Drop
+ for FillGapOnDrop<'a, T, A, COOP_PREFERRED>
+ where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(
+ COOP_PREFERRED,
+ )]:,
+ {
fn drop(&mut self) {
/* This code gets executed when `same_bucket` panics */
@@ -1986,7 +2075,7 @@ impl<T, A: Allocator> Vec<T, A> {
/// assert_eq!(v, &[]);
/// ```
#[stable(feature = "drain", since = "1.6.0")]
- pub fn drain<R>(&mut self, range: R) -> Drain<'_, T, A>
+ pub fn drain<R>(&mut self, range: R) -> Drain<'_, T, A, COOP_PREFERRED>
where
R: RangeBounds<usize>,
{
@@ -2337,7 +2426,10 @@ impl<T, A: Allocator> Vec<T, A> {
}
}
-impl<T: Clone, A: Allocator> Vec<T, A> {
+impl<T: Clone, A: Allocator, const COOP_PREFERRED: bool> Vec<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
/// Resizes the `Vec` in-place so that `len` is equal to `new_len`.
///
/// If `new_len` is greater than `len`, the `Vec` is extended by the
@@ -2436,7 +2528,10 @@ impl<T: Clone, A: Allocator> Vec<T, A> {
}
}
-impl<T, A: Allocator, const N: usize> Vec<[T; N], A> {
+impl<T, A: Allocator, const N: usize, const COOP_PREFERRED: bool> Vec<[T; N], A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
/// Takes a `Vec<[T; N]>` and flattens it into a `Vec<T>`.
///
/// # Panics
@@ -2459,7 +2554,7 @@ impl<T, A: Allocator, const N: usize> Vec<[T; N], A> {
/// assert_eq!(flattened.pop(), Some(6));
/// ```
#[unstable(feature = "slice_flatten", issue = "95629")]
- pub fn into_flattened(self) -> Vec<T, A> {
+ pub fn into_flattened(self) -> Vec<T, A, COOP_PREFERRED> {
let (ptr, len, cap, alloc) = self.into_raw_parts_with_alloc();
let (new_len, new_cap) = if T::IS_ZST {
(len.checked_mul(N).expect("vec len overflow"), usize::MAX)
@@ -2477,7 +2572,7 @@ impl<T, A: Allocator, const N: usize> Vec<[T; N], A> {
// - `new_cap` refers to the same sized allocation as `cap` because
// `new_cap * size_of::<T>()` == `cap * size_of::<[T; N]>()`
// - `len` <= `cap`, so `len * N` <= `cap * N`.
- unsafe { Vec::<T, A>::from_raw_parts_in(ptr.cast(), new_len, new_cap, alloc) }
+ unsafe { Vec::<T, A, COOP_PREFERRED>::from_raw_parts_in(ptr.cast(), new_len, new_cap, alloc) }
}
}
@@ -2497,7 +2592,10 @@ impl<T: Clone> ExtendWith<T> for ExtendElement<T> {
}
}
-impl<T, A: Allocator> Vec<T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> Vec<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
#[cfg(not(no_global_oom_handling))]
/// Extend the vector by `n` values, using the given generator.
fn extend_with<E: ExtendWith<T>>(&mut self, n: usize, mut value: E) {
@@ -2529,7 +2627,10 @@ impl<T, A: Allocator> Vec<T, A> {
}
}
-impl<T: PartialEq, A: Allocator> Vec<T, A> {
+impl<T: PartialEq, A: Allocator, const COOP_PREFERRED: bool> Vec<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
/// Removes consecutive repeated elements in the vector according to the
/// [`PartialEq`] trait implementation.
///
@@ -2565,7 +2666,14 @@ pub fn from_elem<T: Clone>(elem: T, n: usize) -> Vec<T> {
#[doc(hidden)]
#[cfg(not(no_global_oom_handling))]
#[unstable(feature = "allocator_api", issue = "32838")]
-pub fn from_elem_in<T: Clone, A: Allocator>(elem: T, n: usize, alloc: A) -> Vec<T, A> {
+pub fn from_elem_in<T: Clone, A: Allocator, const COOP_PREFERRED: bool>(
+ elem: T,
+ n: usize,
+ alloc: A,
+) -> Vec<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
<T as SpecFromElem>::from_elem(elem, n, alloc)
}
@@ -2577,7 +2685,11 @@ trait ExtendFromWithinSpec {
unsafe fn spec_extend_from_within(&mut self, src: Range<usize>);
}
-impl<T: Clone, A: Allocator> ExtendFromWithinSpec for Vec<T, A> {
+impl<T: Clone, A: Allocator, const COOP_PREFERRED: bool> ExtendFromWithinSpec
+ for Vec<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
default unsafe fn spec_extend_from_within(&mut self, src: Range<usize>) {
// SAFETY:
// - len is increased only after initializing elements
@@ -2596,7 +2708,11 @@ impl<T: Clone, A: Allocator> ExtendFromWithinSpec for Vec<T, A> {
}
}
-impl<T: Copy, A: Allocator> ExtendFromWithinSpec for Vec<T, A> {
+impl<T: Copy, A: Allocator, const COOP_PREFERRED: bool> ExtendFromWithinSpec
+ for Vec<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
unsafe fn spec_extend_from_within(&mut self, src: Range<usize>) {
let count = src.len();
{
@@ -2629,7 +2745,10 @@ impl<T: Copy, A: Allocator> ExtendFromWithinSpec for Vec<T, A> {
////////////////////////////////////////////////////////////////////////////////
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T, A: Allocator> ops::Deref for Vec<T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> ops::Deref for Vec<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
type Target = [T];
#[inline]
@@ -2639,7 +2758,10 @@ impl<T, A: Allocator> ops::Deref for Vec<T, A> {
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T, A: Allocator> ops::DerefMut for Vec<T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> ops::DerefMut for Vec<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
#[inline]
fn deref_mut(&mut self) -> &mut [T] {
unsafe { slice::from_raw_parts_mut(self.as_mut_ptr(), self.len) }
@@ -2652,7 +2774,10 @@ trait SpecCloneFrom {
}
#[cfg(not(no_global_oom_handling))]
-impl<T: Clone, A: Allocator> SpecCloneFrom for Vec<T, A> {
+impl<T: Clone, A: Allocator, const COOP_PREFERRED: bool> SpecCloneFrom for Vec<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
default fn clone_from(this: &mut Self, other: &Self) {
// drop anything that will not be overwritten
this.truncate(other.len());
@@ -2668,7 +2793,10 @@ impl<T: Clone, A: Allocator> SpecCloneFrom for Vec<T, A> {
}
#[cfg(not(no_global_oom_handling))]
-impl<T: Copy, A: Allocator> SpecCloneFrom for Vec<T, A> {
+impl<T: Copy, A: Allocator, const COOP_PREFERRED: bool> SpecCloneFrom for Vec<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
fn clone_from(this: &mut Self, other: &Self) {
this.clear();
this.extend_from_slice(other);
@@ -2677,7 +2805,10 @@ impl<T: Copy, A: Allocator> SpecCloneFrom for Vec<T, A> {
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Clone, A: Allocator + Clone> Clone for Vec<T, A> {
+impl<T: Clone, A: Allocator + Clone, const COOP_PREFERRED: bool> Clone for Vec<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
#[cfg(not(test))]
fn clone(&self) -> Self {
let alloc = self.allocator().clone();
@@ -2712,7 +2843,10 @@ impl<T: Clone, A: Allocator + Clone> Clone for Vec<T, A> {
/// assert_eq!(b.hash_one(v), b.hash_one(s));
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Hash, A: Allocator> Hash for Vec<T, A> {
+impl<T: Hash, A: Allocator, const COOP_PREFERRED: bool> Hash for Vec<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
#[inline]
fn hash<H: Hasher>(&self, state: &mut H) {
Hash::hash(&**self, state)
@@ -2724,7 +2858,11 @@ impl<T: Hash, A: Allocator> Hash for Vec<T, A> {
message = "vector indices are of type `usize` or ranges of `usize`",
label = "vector indices are of type `usize` or ranges of `usize`"
)]
-impl<T, I: SliceIndex<[T]>, A: Allocator> Index<I> for Vec<T, A> {
+impl<T, I: SliceIndex<[T]>, A: Allocator, const COOP_PREFERRED: bool> Index<I>
+ for Vec<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
type Output = I::Output;
#[inline]
@@ -2738,7 +2876,11 @@ impl<T, I: SliceIndex<[T]>, A: Allocator> Index<I> for Vec<T, A> {
message = "vector indices are of type `usize` or ranges of `usize`",
label = "vector indices are of type `usize` or ranges of `usize`"
)]
-impl<T, I: SliceIndex<[T]>, A: Allocator> IndexMut<I> for Vec<T, A> {
+impl<T, I: SliceIndex<[T]>, A: Allocator, const COOP_PREFERRED: bool> IndexMut<I>
+ for Vec<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
#[inline]
fn index_mut(&mut self, index: I) -> &mut Self::Output {
IndexMut::index_mut(&mut **self, index)
@@ -2747,17 +2889,24 @@ impl<T, I: SliceIndex<[T]>, A: Allocator> IndexMut<I> for Vec<T, A> {
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> FromIterator<T> for Vec<T> {
+#[allow(unused_braces)]
+impl<T, const COOP_PREFERRED: bool> FromIterator<T> for Vec<T, Global, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+ {
#[inline]
- fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Vec<T> {
+ fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Vec<T, Global, COOP_PREFERRED> {
<Self as SpecFromIter<T, I::IntoIter>>::from_iter(iter.into_iter())
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T, A: Allocator> IntoIterator for Vec<T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> IntoIterator for Vec<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
type Item = T;
- type IntoIter = IntoIter<T, A>;
+ type IntoIter = IntoIter<T, A, COOP_PREFERRED>;
/// Creates a consuming iterator, that is, one that moves each value out of
/// the vector (from start to end). The vector cannot be used after calling
@@ -2800,7 +2949,10 @@ impl<T, A: Allocator> IntoIterator for Vec<T, A> {
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T, A: Allocator> IntoIterator for &'a Vec<T, A> {
+impl<'a, T, A: Allocator, const COOP_PREFERRED: bool> IntoIterator for &'a Vec<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
type Item = &'a T;
type IntoIter = slice::Iter<'a, T>;
@@ -2810,7 +2962,11 @@ impl<'a, T, A: Allocator> IntoIterator for &'a Vec<T, A> {
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T, A: Allocator> IntoIterator for &'a mut Vec<T, A> {
+impl<'a, T, A: Allocator, const COOP_PREFERRED: bool> IntoIterator
+ for &'a mut Vec<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
type Item = &'a mut T;
type IntoIter = slice::IterMut<'a, T>;
@@ -2821,7 +2977,10 @@ impl<'a, T, A: Allocator> IntoIterator for &'a mut Vec<T, A> {
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T, A: Allocator> Extend<T> for Vec<T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> Extend<T> for Vec<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
#[inline]
fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
<Self as SpecExtend<T, I::IntoIter>>::spec_extend(self, iter.into_iter())
@@ -2838,7 +2997,10 @@ impl<T, A: Allocator> Extend<T> for Vec<T, A> {
}
}
-impl<T, A: Allocator> Vec<T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> Vec<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
// leaf method to which various SpecFrom/SpecExtend implementations delegate when
// they have no further optimizations to apply
#[cfg(not(no_global_oom_handling))]
@@ -2936,10 +3098,11 @@ impl<T, A: Allocator> Vec<T, A> {
#[cfg(not(no_global_oom_handling))]
#[inline]
#[stable(feature = "vec_splice", since = "1.21.0")]
- pub fn splice<R, I>(&mut self, range: R, replace_with: I) -> Splice<'_, I::IntoIter, A>
+ pub fn splice<R, I>(&mut self, range: R, replace_with: I) -> Splice<'_, I::IntoIter, A, COOP_PREFERRED>
where
R: RangeBounds<usize>,
I: IntoIterator<Item = T>,
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(true)]:,
{
Splice { drain: self.drain(range), replace_with: replace_with.into_iter() }
}
@@ -2989,9 +3152,10 @@ impl<T, A: Allocator> Vec<T, A> {
/// assert_eq!(odds, vec![1, 3, 5, 9, 11, 13, 15]);
/// ```
#[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")]
- pub fn drain_filter<F>(&mut self, filter: F) -> DrainFilter<'_, T, F, A>
+ pub fn drain_filter<F>(&mut self, filter: F) -> DrainFilter<'_, T, F, A, COOP_PREFERRED>
where
F: FnMut(&mut T) -> bool,
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(true)]:,
{
let old_len = self.len();
@@ -3012,7 +3176,11 @@ impl<T, A: Allocator> Vec<T, A> {
/// [`copy_from_slice`]: slice::copy_from_slice
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "extend_ref", since = "1.2.0")]
-impl<'a, T: Copy + 'a, A: Allocator + 'a> Extend<&'a T> for Vec<T, A> {
+impl<'a, T: Copy + 'a, A: Allocator + 'a, const COOP_PREFERRED: bool> Extend<&'a T>
+ for Vec<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
self.spec_extend(iter.into_iter())
}
@@ -3030,7 +3198,11 @@ impl<'a, T: Copy + 'a, A: Allocator + 'a> Extend<&'a T> for Vec<T, A> {
/// Implements comparison of vectors, [lexicographically](core::cmp::Ord#lexicographical-comparison).
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: PartialOrd, A: Allocator> PartialOrd for Vec<T, A> {
+impl<T: PartialOrd, A: Allocator, const COOP_PREFERRED: bool> PartialOrd
+ for Vec<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
#[inline]
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
PartialOrd::partial_cmp(&**self, &**other)
@@ -3038,11 +3210,17 @@ impl<T: PartialOrd, A: Allocator> PartialOrd for Vec<T, A> {
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Eq, A: Allocator> Eq for Vec<T, A> {}
+impl<T: Eq, A: Allocator, const COOP_PREFERRED: bool> Eq for Vec<T, A, COOP_PREFERRED> where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:
+{
+}
/// Implements ordering of vectors, [lexicographically](core::cmp::Ord#lexicographical-comparison).
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Ord, A: Allocator> Ord for Vec<T, A> {
+impl<T: Ord, A: Allocator, const COOP_PREFERRED: bool> Ord for Vec<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
#[inline]
fn cmp(&self, other: &Self) -> Ordering {
Ord::cmp(&**self, &**other)
@@ -3050,7 +3228,11 @@ impl<T: Ord, A: Allocator> Ord for Vec<T, A> {
}
#[stable(feature = "rust1", since = "1.0.0")]
-unsafe impl<#[may_dangle] T, A: Allocator> Drop for Vec<T, A> {
+unsafe impl<#[may_dangle] T, A: Allocator, const COOP_PREFERRED: bool> Drop
+ for Vec<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
fn drop(&mut self) {
unsafe {
// use drop for [T]
@@ -3064,45 +3246,66 @@ unsafe impl<#[may_dangle] T, A: Allocator> Drop for Vec<T, A> {
#[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_default_impls", issue = "87864")]
-impl<T> const Default for Vec<T> {
+impl<T, const COOP_PREFERRED: bool> const Default for Vec<T, Global, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
/// Creates an empty `Vec<T>`.
///
/// The vector will not allocate until elements are pushed onto it.
- fn default() -> Vec<T> {
- Vec::new()
+ fn default() -> Vec<T, Global, COOP_PREFERRED> {
+ Vec::new_co()
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: fmt::Debug, A: Allocator> fmt::Debug for Vec<T, A> {
+impl<T: fmt::Debug, A: Allocator, const COOP_PREFERRED: bool> fmt::Debug
+ for Vec<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
fmt::Debug::fmt(&**self, f)
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T, A: Allocator> AsRef<Vec<T, A>> for Vec<T, A> {
- fn as_ref(&self) -> &Vec<T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> AsRef<Vec<T, A, COOP_PREFERRED>>
+ for Vec<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
+ fn as_ref(&self) -> &Vec<T, A, COOP_PREFERRED> {
self
}
}
#[stable(feature = "vec_as_mut", since = "1.5.0")]
-impl<T, A: Allocator> AsMut<Vec<T, A>> for Vec<T, A> {
- fn as_mut(&mut self) -> &mut Vec<T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> AsMut<Vec<T, A, COOP_PREFERRED>>
+ for Vec<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
+ fn as_mut(&mut self) -> &mut Vec<T, A, COOP_PREFERRED> {
self
}
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T, A: Allocator> AsRef<[T]> for Vec<T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> AsRef<[T]> for Vec<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
fn as_ref(&self) -> &[T] {
self
}
}
#[stable(feature = "vec_as_mut", since = "1.5.0")]
-impl<T, A: Allocator> AsMut<[T]> for Vec<T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> AsMut<[T]> for Vec<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
fn as_mut(&mut self) -> &mut [T] {
self
}
@@ -3110,7 +3313,8 @@ impl<T, A: Allocator> AsMut<[T]> for Vec<T, A> {
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Clone> From<&[T]> for Vec<T> {
+#[allow(unused_braces)]
+impl<T: Clone> From<&[T]> for Vec<T, Global, {DEFAULT_COOP_PREFERRED!()}> {
/// Allocate a `Vec<T>` and fill it by cloning `s`'s items.
///
/// # Examples
@@ -3130,7 +3334,8 @@ impl<T: Clone> From<&[T]> for Vec<T> {
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "vec_from_mut", since = "1.19.0")]
-impl<T: Clone> From<&mut [T]> for Vec<T> {
+#[allow(unused_braces)]
+impl<T: Clone> From<&mut [T]> for Vec<T, Global, {DEFAULT_COOP_PREFERRED!()}> {
/// Allocate a `Vec<T>` and fill it by cloning `s`'s items.
///
/// # Examples
@@ -3150,7 +3355,8 @@ impl<T: Clone> From<&mut [T]> for Vec<T> {
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "vec_from_array", since = "1.44.0")]
-impl<T, const N: usize> From<[T; N]> for Vec<T> {
+#[allow(unused_braces)]
+impl<T, const N: usize> From<[T; N]> for Vec<T, Global, {DEFAULT_COOP_PREFERRED!()}> {
/// Allocate a `Vec<T>` and move `s`'s items into it.
///
/// # Examples
@@ -3173,7 +3379,8 @@ impl<T, const N: usize> From<[T; N]> for Vec<T> {
}
#[stable(feature = "vec_from_cow_slice", since = "1.14.0")]
-impl<'a, T> From<Cow<'a, [T]>> for Vec<T>
+#[allow(unused_braces)]
+impl<'a, T> From<Cow<'a, [T]>> for Vec<T, Global, {DEFAULT_COOP_PREFERRED!()}>
where
[T]: ToOwned<Owned = Vec<T>>,
{
@@ -3199,7 +3406,10 @@ where
// note: test pulls in std, which causes errors here
#[cfg(not(test))]
#[stable(feature = "vec_from_box", since = "1.18.0")]
-impl<T, A: Allocator> From<Box<[T], A>> for Vec<T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> From<Box<[T], A>> for Vec<T, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
/// Convert a boxed slice into a vector by transferring ownership of
/// the existing heap allocation.
///
@@ -3218,7 +3428,10 @@ impl<T, A: Allocator> From<Box<[T], A>> for Vec<T, A> {
#[cfg(not(no_global_oom_handling))]
#[cfg(not(test))]
#[stable(feature = "box_from_vec", since = "1.20.0")]
-impl<T, A: Allocator> From<Vec<T, A>> for Box<[T], A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> From<Vec<T, A, COOP_PREFERRED>> for Box<[T], A>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
/// Convert a vector into a boxed slice.
///
/// If `v` has excess capacity, its items will be moved into a
@@ -3237,14 +3450,15 @@ impl<T, A: Allocator> From<Vec<T, A>> for Box<[T], A> {
///
/// assert_eq!(Box::from(vec), vec![1, 2, 3].into_boxed_slice());
/// ```
- fn from(v: Vec<T, A>) -> Self {
+ fn from(v: Vec<T, A, COOP_PREFERRED>) -> Self {
v.into_boxed_slice()
}
}
#[cfg(not(no_global_oom_handling))]
#[stable(feature = "rust1", since = "1.0.0")]
-impl From<&str> for Vec<u8> {
+#[allow(unused_braces)]
+impl From<&str> for Vec<u8, Global, {DEFAULT_COOP_PREFERRED!()}> {
/// Allocate a `Vec<u8>` and fill it with a UTF-8 string.
///
/// # Examples
@@ -3258,8 +3472,12 @@ impl From<&str> for Vec<u8> {
}
#[stable(feature = "array_try_from_vec", since = "1.48.0")]
-impl<T, A: Allocator, const N: usize> TryFrom<Vec<T, A>> for [T; N] {
- type Error = Vec<T, A>;
+impl<T, A: Allocator, const N: usize, const COOP_PREFERRED: bool> TryFrom<Vec<T, A, COOP_PREFERRED>>
+ for [T; N]
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
+ type Error = Vec<T, A, COOP_PREFERRED>;
/// Gets the entire contents of the `Vec<T>` as an array,
/// if its size exactly matches that of the requested array.
@@ -3287,7 +3505,7 @@ impl<T, A: Allocator, const N: usize> TryFrom<Vec<T, A>> for [T; N] {
/// assert_eq!(a, b' ');
/// assert_eq!(b, b'd');
/// ```
- fn try_from(mut vec: Vec<T, A>) -> Result<[T; N], Vec<T, A>> {
+ fn try_from(mut vec: Vec<T, A, COOP_PREFERRED>) -> Result<[T; N], Vec<T, A, COOP_PREFERRED>> {
if vec.len() != N {
return Err(vec);
}
diff --git a/library/alloc/src/vec/partial_eq.rs b/library/alloc/src/vec/partial_eq.rs
index b0cf72577a1be..bcf52b7333218 100644
--- a/library/alloc/src/vec/partial_eq.rs
+++ b/library/alloc/src/vec/partial_eq.rs
@@ -1,3 +1,4 @@
+//use core::alloc;
use crate::alloc::Allocator;
#[cfg(not(no_global_oom_handling))]
use crate::borrow::Cow;
@@ -5,12 +6,12 @@ use crate::borrow::Cow;
use super::Vec;
macro_rules! __impl_slice_eq1 {
- ([$($vars:tt)*] $lhs:ty, $rhs:ty $(where $ty:ty: $bound:ident)?, #[$stability:meta]) => {
+ ([$($vars:tt)*] $lhs:ty, $rhs:ty, #[$stability:meta], $($constraints:tt)*) => {
#[$stability]
impl<T, U, $($vars)*> PartialEq<$rhs> for $lhs
where
T: PartialEq<U>,
- $($ty: $bound)?
+ $($constraints)*
{
#[inline]
fn eq(&self, other: &$rhs) -> bool { self[..] == other[..] }
@@ -20,21 +21,21 @@ macro_rules! __impl_slice_eq1 {
}
}
-__impl_slice_eq1! { [A1: Allocator, A2: Allocator] Vec<T, A1>, Vec<U, A2>, #[stable(feature = "rust1", since = "1.0.0")] }
-__impl_slice_eq1! { [A: Allocator] Vec<T, A>, &[U], #[stable(feature = "rust1", since = "1.0.0")] }
-__impl_slice_eq1! { [A: Allocator] Vec<T, A>, &mut [U], #[stable(feature = "rust1", since = "1.0.0")] }
-__impl_slice_eq1! { [A: Allocator] &[T], Vec<U, A>, #[stable(feature = "partialeq_vec_for_ref_slice", since = "1.46.0")] }
-__impl_slice_eq1! { [A: Allocator] &mut [T], Vec<U, A>, #[stable(feature = "partialeq_vec_for_ref_slice", since = "1.46.0")] }
-__impl_slice_eq1! { [A: Allocator] Vec<T, A>, [U], #[stable(feature = "partialeq_vec_for_slice", since = "1.48.0")] }
-__impl_slice_eq1! { [A: Allocator] [T], Vec<U, A>, #[stable(feature = "partialeq_vec_for_slice", since = "1.48.0")] }
+__impl_slice_eq1! { [A1: Allocator, A2: Allocator, const COOP_PREFERRED1: bool, const COOP_PREFERRED2: bool] Vec<T, A1, COOP_PREFERRED1>, Vec<U, A2, COOP_PREFERRED2>, #[stable(feature = "rust1", since = "1.0.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A1>(COOP_PREFERRED1)]:, [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A2>(COOP_PREFERRED2)]: }
+__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] Vec<T, A, COOP_PREFERRED>, &[U], #[stable(feature = "rust1", since = "1.0.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]: }
+__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] Vec<T, A, COOP_PREFERRED>, &mut [U], #[stable(feature = "rust1", since = "1.0.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]: }
+__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] &[T], Vec<U, A, COOP_PREFERRED>, #[stable(feature = "partialeq_vec_for_ref_slice", since = "1.46.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]: }
+__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] &mut [T], Vec<U, A, COOP_PREFERRED>, #[stable(feature = "partialeq_vec_for_ref_slice", since = "1.46.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]: }
+__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] Vec<T, A, COOP_PREFERRED>, [U], #[stable(feature = "partialeq_vec_for_slice", since = "1.48.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]: }
+__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] [T], Vec<U, A, COOP_PREFERRED>, #[stable(feature = "partialeq_vec_for_slice", since = "1.48.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]: }
#[cfg(not(no_global_oom_handling))]
-__impl_slice_eq1! { [A: Allocator] Cow<'_, [T]>, Vec<U, A> where T: Clone, #[stable(feature = "rust1", since = "1.0.0")] }
+__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] Cow<'_, [T]>, Vec<U, A, COOP_PREFERRED>, #[stable(feature = "rust1", since = "1.0.0")], T: Clone, [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]: }
#[cfg(not(no_global_oom_handling))]
-__impl_slice_eq1! { [] Cow<'_, [T]>, &[U] where T: Clone, #[stable(feature = "rust1", since = "1.0.0")] }
+__impl_slice_eq1! { [] Cow<'_, [T]>, &[U], #[stable(feature = "rust1", since = "1.0.0")], T: Clone }
#[cfg(not(no_global_oom_handling))]
-__impl_slice_eq1! { [] Cow<'_, [T]>, &mut [U] where T: Clone, #[stable(feature = "rust1", since = "1.0.0")] }
-__impl_slice_eq1! { [A: Allocator, const N: usize] Vec<T, A>, [U; N], #[stable(feature = "rust1", since = "1.0.0")] }
-__impl_slice_eq1! { [A: Allocator, const N: usize] Vec<T, A>, &[U; N], #[stable(feature = "rust1", since = "1.0.0")] }
+__impl_slice_eq1! { [] Cow<'_, [T]>, &mut [U], #[stable(feature = "rust1", since = "1.0.0")], T: Clone }
+__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool, const N: usize] Vec<T, A, COOP_PREFERRED>, [U; N], #[stable(feature = "rust1", since = "1.0.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]: }
+__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool, const N: usize] Vec<T, A, COOP_PREFERRED>, &[U; N], #[stable(feature = "rust1", since = "1.0.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]: }
// NOTE: some less important impls are omitted to reduce code bloat
// FIXME(Centril): Reconsider this?
diff --git a/library/alloc/src/vec/spec_extend.rs b/library/alloc/src/vec/spec_extend.rs
index 56065ce565bfc..73cf325889290 100644
--- a/library/alloc/src/vec/spec_extend.rs
+++ b/library/alloc/src/vec/spec_extend.rs
@@ -1,4 +1,5 @@
use crate::alloc::Allocator;
+use core::alloc;
use core::iter::TrustedLen;
use core::slice::{self};
@@ -9,25 +10,31 @@ pub(super) trait SpecExtend<T, I> {
fn spec_extend(&mut self, iter: I);
}
-impl<T, I, A: Allocator> SpecExtend<T, I> for Vec<T, A>
+impl<T, I, A: Allocator, const COOP_PREFERRED: bool> SpecExtend<T, I> for Vec<T, A, COOP_PREFERRED>
where
I: Iterator<Item = T>,
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
{
default fn spec_extend(&mut self, iter: I) {
self.extend_desugared(iter)
}
}
-impl<T, I, A: Allocator> SpecExtend<T, I> for Vec<T, A>
+impl<T, I, A: Allocator, const COOP_PREFERRED: bool> SpecExtend<T, I> for Vec<T, A, COOP_PREFERRED>
where
I: TrustedLen<Item = T>,
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
{
default fn spec_extend(&mut self, iterator: I) {
self.extend_trusted(iterator)
}
}
-impl<T, A: Allocator> SpecExtend<T, IntoIter<T>> for Vec<T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> SpecExtend<T, IntoIter<T>>
+ for Vec<T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
fn spec_extend(&mut self, mut iterator: IntoIter<T>) {
unsafe {
self.append_elements(iterator.as_slice() as _);
@@ -36,19 +43,23 @@ impl<T, A: Allocator> SpecExtend<T, IntoIter<T>> for Vec<T, A> {
}
}
-impl<'a, T: 'a, I, A: Allocator + 'a> SpecExtend<&'a T, I> for Vec<T, A>
+impl<'a, T: 'a, I, A: Allocator + 'a, const COOP_PREFERRED: bool> SpecExtend<&'a T, I>
+ for Vec<T, A, COOP_PREFERRED>
where
I: Iterator<Item = &'a T>,
T: Clone,
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
{
default fn spec_extend(&mut self, iterator: I) {
self.spec_extend(iterator.cloned())
}
}
-impl<'a, T: 'a, A: Allocator + 'a> SpecExtend<&'a T, slice::Iter<'a, T>> for Vec<T, A>
+impl<'a, T: 'a, A: Allocator + 'a, const COOP_PREFERRED: bool> SpecExtend<&'a T, slice::Iter<'a, T>>
+ for Vec<T, A, COOP_PREFERRED>
where
T: Copy,
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
{
fn spec_extend(&mut self, iterator: slice::Iter<'a, T>) {
let slice = iterator.as_slice();
diff --git a/library/alloc/src/vec/spec_from_elem.rs b/library/alloc/src/vec/spec_from_elem.rs
index ff364c033ee98..bc4169a24f0b2 100644
--- a/library/alloc/src/vec/spec_from_elem.rs
+++ b/library/alloc/src/vec/spec_from_elem.rs
@@ -2,16 +2,30 @@ use core::ptr;
use crate::alloc::Allocator;
use crate::raw_vec::RawVec;
+use core::alloc;
use super::{ExtendElement, IsZero, Vec};
// Specialization trait used for Vec::from_elem
pub(super) trait SpecFromElem: Sized {
- fn from_elem<A: Allocator>(elem: Self, n: usize, alloc: A) -> Vec<Self, A>;
+ fn from_elem<A: Allocator, const COOP_PREFERRED: bool>(
+ elem: Self,
+ n: usize,
+ alloc: A,
+ ) -> Vec<Self, A, COOP_PREFERRED>
+ where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:;
}
impl<T: Clone> SpecFromElem for T {
- default fn from_elem<A: Allocator>(elem: Self, n: usize, alloc: A) -> Vec<Self, A> {
+ default fn from_elem<A: Allocator, const COOP_PREFERRED: bool>(
+ elem: Self,
+ n: usize,
+ alloc: A,
+ ) -> Vec<Self, A, COOP_PREFERRED>
+ where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+ {
let mut v = Vec::with_capacity_in(n, alloc);
v.extend_with(n, ExtendElement(elem));
v
@@ -20,7 +34,14 @@ impl<T: Clone> SpecFromElem for T {
impl<T: Clone + IsZero> SpecFromElem for T {
#[inline]
- default fn from_elem<A: Allocator>(elem: T, n: usize, alloc: A) -> Vec<T, A> {
+ default fn from_elem<A: Allocator, const COOP_PREFERRED: bool>(
+ elem: T,
+ n: usize,
+ alloc: A,
+ ) -> Vec<T, A, COOP_PREFERRED>
+ where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+ {
if elem.is_zero() {
return Vec { buf: RawVec::with_capacity_zeroed_in(n, alloc), len: n };
}
@@ -32,7 +53,14 @@ impl<T: Clone + IsZero> SpecFromElem for T {
impl SpecFromElem for i8 {
#[inline]
- fn from_elem<A: Allocator>(elem: i8, n: usize, alloc: A) -> Vec<i8, A> {
+ fn from_elem<A: Allocator, const COOP_PREFERRED: bool>(
+ elem: i8,
+ n: usize,
+ alloc: A,
+ ) -> Vec<i8, A, COOP_PREFERRED>
+ where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+ {
if elem == 0 {
return Vec { buf: RawVec::with_capacity_zeroed_in(n, alloc), len: n };
}
@@ -47,7 +75,14 @@ impl SpecFromElem for i8 {
impl SpecFromElem for u8 {
#[inline]
- fn from_elem<A: Allocator>(elem: u8, n: usize, alloc: A) -> Vec<u8, A> {
+ fn from_elem<A: Allocator, const COOP_PREFERRED: bool>(
+ elem: u8,
+ n: usize,
+ alloc: A,
+ ) -> Vec<u8, A, COOP_PREFERRED>
+ where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+ {
if elem == 0 {
return Vec { buf: RawVec::with_capacity_zeroed_in(n, alloc), len: n };
}
diff --git a/library/alloc/src/vec/spec_from_iter.rs b/library/alloc/src/vec/spec_from_iter.rs
index efa6868473e49..e0befdb22962d 100644
--- a/library/alloc/src/vec/spec_from_iter.rs
+++ b/library/alloc/src/vec/spec_from_iter.rs
@@ -1,3 +1,5 @@
+use core::alloc;
+use crate::alloc::Global;
use core::mem::ManuallyDrop;
use core::ptr::{self};
@@ -25,16 +27,22 @@ pub(super) trait SpecFromIter<T, I> {
fn from_iter(iter: I) -> Self;
}
-impl<T, I> SpecFromIter<T, I> for Vec<T>
+#[allow(unused_braces)]
+impl<T, I, const COOP_PREFERRED: bool> SpecFromIter<T, I> for Vec<T, Global, COOP_PREFERRED>
where
I: Iterator<Item = T>,
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
{
default fn from_iter(iterator: I) -> Self {
SpecFromIterNested::from_iter(iterator)
}
}
-impl<T> SpecFromIter<T, IntoIter<T>> for Vec<T> {
+#[allow(unused_braces)]
+impl<T, const COOP_PREFERRED: bool> SpecFromIter<T, IntoIter<T>> for Vec<T, Global, COOP_PREFERRED>
+where
+[(); alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
fn from_iter(iterator: IntoIter<T>) -> Self {
// A common case is passing a vector into a function which immediately
// re-collects into a vector. We can short circuit this if the IntoIter
@@ -55,7 +63,7 @@ impl<T> SpecFromIter<T, IntoIter<T>> for Vec<T> {
}
}
- let mut vec = Vec::new();
+ let mut vec = Vec::<T, Global, COOP_PREFERRED>::new_co();
// must delegate to spec_extend() since extend() itself delegates
// to spec_from for empty Vecs
vec.spec_extend(iterator);
diff --git a/library/alloc/src/vec/spec_from_iter_nested.rs b/library/alloc/src/vec/spec_from_iter_nested.rs
index f915ebb86e5a5..ff774e4534bf7 100644
--- a/library/alloc/src/vec/spec_from_iter_nested.rs
+++ b/library/alloc/src/vec/spec_from_iter_nested.rs
@@ -1,8 +1,11 @@
+use core::alloc;
use core::cmp;
use core::iter::TrustedLen;
use core::ptr;
use crate::raw_vec::RawVec;
+use crate::alloc::Global;
+use crate::DEFAULT_COOP_PREFERRED;
use super::{SpecExtend, Vec};
@@ -13,9 +16,11 @@ pub(super) trait SpecFromIterNested<T, I> {
fn from_iter(iter: I) -> Self;
}
-impl<T, I> SpecFromIterNested<T, I> for Vec<T>
+#[allow(unused_braces)]
+impl<T, I, const COOP_PREFERRED: bool> SpecFromIterNested<T, I> for Vec<T, Global, COOP_PREFERRED>
where
I: Iterator<Item = T>,
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
{
default fn from_iter(mut iterator: I) -> Self {
// Unroll the first iteration, as the vector is going to be
@@ -24,7 +29,7 @@ where
// vector being full in the few subsequent loop iterations.
// So we get better branch prediction.
let mut vector = match iterator.next() {
- None => return Vec::new(),
+ None => return Vec::new_co(),
Some(element) => {
let (lower, _) = iterator.size_hint();
let initial_capacity =
@@ -40,12 +45,13 @@ where
};
// must delegate to spec_extend() since extend() itself delegates
// to spec_from for empty Vecs
- <Vec<T> as SpecExtend<T, I>>::spec_extend(&mut vector, iterator);
+ <Vec<T, Global, COOP_PREFERRED> as SpecExtend<T, I>>::spec_extend(&mut vector, iterator);
vector
}
}
-impl<T, I> SpecFromIterNested<T, I> for Vec<T>
+#[allow(unused_braces)]
+impl<T, I> SpecFromIterNested<T, I> for Vec<T, Global, {DEFAULT_COOP_PREFERRED!()}>
where
I: TrustedLen<Item = T>,
{
diff --git a/library/alloc/src/vec/splice.rs b/library/alloc/src/vec/splice.rs
index 1861147fe72fb..92fcaf4382dca 100644
--- a/library/alloc/src/vec/splice.rs
+++ b/library/alloc/src/vec/splice.rs
@@ -1,4 +1,5 @@
use crate::alloc::{Allocator, Global};
+use core::alloc;
use core::ptr::{self};
use core::slice::{self};
@@ -22,13 +23,19 @@ pub struct Splice<
'a,
I: Iterator + 'a,
#[unstable(feature = "allocator_api", issue = "32838")] A: Allocator + 'a = Global,
-> {
- pub(super) drain: Drain<'a, I::Item, A>,
+ const COOP_PREFERRED: bool = false
+> where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
+ pub(super) drain: Drain<'a, I::Item, A, COOP_PREFERRED>,
pub(super) replace_with: I,
}
#[stable(feature = "vec_splice", since = "1.21.0")]
-impl<I: Iterator, A: Allocator> Iterator for Splice<'_, I, A> {
+impl<I: Iterator, A: Allocator, const COOP_PREFERRED: bool> Iterator for Splice<'_, I, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
type Item = I::Item;
fn next(&mut self) -> Option<Self::Item> {
@@ -41,17 +48,26 @@ impl<I: Iterator, A: Allocator> Iterator for Splice<'_, I, A> {
}
#[stable(feature = "vec_splice", since = "1.21.0")]
-impl<I: Iterator, A: Allocator> DoubleEndedIterator for Splice<'_, I, A> {
+impl<I: Iterator, A: Allocator, const COOP_PREFERRED: bool> DoubleEndedIterator for Splice<'_, I, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
fn next_back(&mut self) -> Option<Self::Item> {
self.drain.next_back()
}
}
#[stable(feature = "vec_splice", since = "1.21.0")]
-impl<I: Iterator, A: Allocator> ExactSizeIterator for Splice<'_, I, A> {}
+impl<I: Iterator, A: Allocator, const COOP_PREFERRED: bool> ExactSizeIterator for Splice<'_, I, A, COOP_PREFERRED> where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:
+{
+}
#[stable(feature = "vec_splice", since = "1.21.0")]
-impl<I: Iterator, A: Allocator> Drop for Splice<'_, I, A> {
+impl<I: Iterator, A: Allocator, const COOP_PREFERRED: bool> Drop for Splice<'_, I, A, COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
fn drop(&mut self) {
self.drain.by_ref().for_each(drop);
// At this point draining is done and the only remaining tasks are splicing
@@ -98,7 +114,10 @@ impl<I: Iterator, A: Allocator> Drop for Splice<'_, I, A> {
}
/// Private helper methods for `Splice::drop`
-impl<T, A: Allocator> Drain<'_, T, A> {
+impl<T, A: Allocator, const COOP_PREFERRED: bool> Drain<'_, T, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
/// The range from `self.vec.len` to `self.tail_start` contains elements
/// that have been moved out.
/// Fill that range as much as possible with new elements from the `replace_with` iterator.
diff --git a/library/alloc/tests/boxed.rs b/library/alloc/tests/boxed.rs
index af49826ff30a3..656e079f9c61c 100644
--- a/library/alloc/tests/boxed.rs
+++ b/library/alloc/tests/boxed.rs
@@ -61,6 +61,7 @@ fn box_deref_lval() {
pub struct ConstAllocator;
+//@FIXME
unsafe impl const Allocator for ConstAllocator {
fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
match layout.size() {
diff --git a/library/alloc/tests/string.rs b/library/alloc/tests/string.rs
index 99d1296a4c925..4adbef3b21332 100644
--- a/library/alloc/tests/string.rs
+++ b/library/alloc/tests/string.rs
@@ -15,7 +15,10 @@ where
fn into_cow(self) -> Cow<'a, B>;
}
-impl<'a> IntoCow<'a, str> for String {
+impl<'a, const COOP_PREFERRED: bool> IntoCow<'a, str> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
fn into_cow(self) -> Cow<'a, str> {
Cow::Owned(self)
}
diff --git a/library/core/src/alloc/global.rs b/library/core/src/alloc/global.rs
index 1d80b8bf9ec76..a7251328c128b 100644
--- a/library/core/src/alloc/global.rs
+++ b/library/core/src/alloc/global.rs
@@ -1,7 +1,16 @@
+use crate::alloc::GlobalCoAllocMeta;
use crate::alloc::Layout;
use crate::cmp;
use crate::ptr;
+#[unstable(feature = "global_co_alloc_meta", issue = "none")]
+#[allow(missing_debug_implementations)]
+/// Used for parameters and results (to/from `GlobalCoAllocator`'s functions, where applicable).
+pub struct RawAndMeta {
+ pub ptr: *mut u8,
+ pub meta: GlobalCoAllocMeta,
+}
+
/// A memory allocator that can be registered as the standard library’s default
/// through the `#[global_allocator]` attribute.
///
@@ -156,6 +165,11 @@ pub unsafe trait GlobalAlloc {
#[stable(feature = "global_alloc", since = "1.28.0")]
unsafe fn alloc(&self, layout: Layout) -> *mut u8;
+ #[unstable(feature = "global_co_alloc", issue = "none")]
+ unsafe fn co_alloc(&self, _layout: Layout, mut _result: &mut RawAndMeta) {
+ panic!("@FIXME")
+ }
+
/// Deallocate the block of memory at the given `ptr` pointer with the given `layout`.
///
/// # Safety
@@ -171,6 +185,11 @@ pub unsafe trait GlobalAlloc {
#[stable(feature = "global_alloc", since = "1.28.0")]
unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout);
+ #[unstable(feature = "global_co_alloc", issue = "none")]
+ unsafe fn co_dealloc(&self, _ptr_and_meta: RawAndMeta, _layout: Layout) {
+ panic!("@FIXME")
+ }
+
/// Behaves like `alloc`, but also ensures that the contents
/// are set to zero before being returned.
///
@@ -198,11 +217,23 @@ pub unsafe trait GlobalAlloc {
if !ptr.is_null() {
// SAFETY: as allocation succeeded, the region from `ptr`
// of size `size` is guaranteed to be valid for writes.
- unsafe { ptr::write_bytes(ptr, 0, size) };
+ unsafe { ptr::write_bytes(ptr, 0u8, size) };
}
ptr
}
+ #[unstable(feature = "global_co_alloc", issue = "none")]
+ unsafe fn co_alloc_zeroed(&self, layout: Layout, mut result: &mut RawAndMeta) {
+ let size = layout.size();
+ // SAFETY: the safety contract for `alloc` must be upheld by the caller.
+ unsafe { self.co_alloc(layout, &mut result) };
+ if !result.ptr.is_null() {
+ // SAFETY: as allocation succeeded, the region from `ptr_and_meta.ptr` of size `size` is
+ // guaranteed to be valid for writes.
+ unsafe { ptr::write_bytes(result.ptr, 0u8, size) };
+ }
+ }
+
/// Shrink or grow a block of memory to the given `new_size`.
/// The block is described by the given `ptr` pointer and `layout`.
///
@@ -274,4 +305,31 @@ pub unsafe trait GlobalAlloc {
}
new_ptr
}
+
+ #[unstable(feature = "global_co_alloc", issue = "none")]
+ unsafe fn co_realloc(
+ &self,
+ ptr_and_meta: RawAndMeta,
+ layout: Layout,
+ new_size: usize,
+ mut result: &mut RawAndMeta,
+ ) {
+ // SAFETY: the caller must ensure that the `new_size` does not overflow.
+ // `layout.align()` comes from a `Layout` and is thus guaranteed to be valid.
+ let new_layout = unsafe { Layout::from_size_align_unchecked(new_size, layout.align()) };
+ // SAFETY: the caller must ensure that `new_layout` is greater than zero.
+ unsafe { self.co_alloc(new_layout, &mut result) };
+ if !result.ptr.is_null() {
+ // SAFETY: the previously allocated block cannot overlap the newly allocated block.
+ // The safety contract for `dealloc` must be upheld by the caller.
+ unsafe {
+ ptr::copy_nonoverlapping(
+ ptr_and_meta.ptr,
+ result.ptr,
+ cmp::min(layout.size(), new_size),
+ );
+ self.co_dealloc(ptr_and_meta, layout);
+ }
+ }
+ }
}
diff --git a/library/core/src/alloc/mod.rs b/library/core/src/alloc/mod.rs
index a6082455fac8d..0f4ede7468f32 100644
--- a/library/core/src/alloc/mod.rs
+++ b/library/core/src/alloc/mod.rs
@@ -3,6 +3,7 @@
#![stable(feature = "alloc_module", since = "1.28.0")]
mod global;
+//mod global_co;
mod layout;
#[stable(feature = "global_alloc", since = "1.28.0")]
@@ -25,6 +26,23 @@ use crate::error::Error;
use crate::fmt;
use crate::ptr::{self, NonNull};
+// @FIXME Make this target-specific
+/// Metadata for `Vec/VecDeque/RawVec` to assist the allocator. Make sure its
+/// alignment is not bigger than alignment of `usize`. Otherwise, even if (a
+/// particular) `Vec/VecDeque/RawVec` generic instance doesn't use cooperation,
+/// it would increase size of that `Vec/VecDeque/RawVec` because of alignment
+/// rules! @FIXME compile time test that `GlobalCoAllocMeta` alignment <=
+/// `usize` alignment.
+#[unstable(feature = "global_co_alloc_meta", issue = "none")]
+#[allow(missing_debug_implementations)]
+#[derive(Clone, Copy)]
+pub struct GlobalCoAllocMeta {
+ //pub one: usize,
+ /*pub two: usize,
+ pub three: usize,
+ pub four: usize,*/
+}
+
/// The `AllocError` error indicates an allocation failure
/// that may be due to resource exhaustion or to
/// something wrong when combining the given input arguments with this
@@ -48,6 +66,50 @@ impl fmt::Display for AllocError {
}
}
+#[unstable(feature = "global_co_alloc_meta", issue = "none")]
+#[allow(missing_debug_implementations)]
+pub struct PtrAndMeta {
+ pub ptr: NonNull<u8>,
+ pub meta: GlobalCoAllocMeta,
+}
+
+#[unstable(feature = "global_co_alloc_meta", issue = "none")]
+#[allow(missing_debug_implementations)]
+/// Used for results (from `CoAllocator`'s functions, where applicable).
+pub struct SliceAndMeta {
+ pub slice: NonNull<[u8]>,
+ pub meta: GlobalCoAllocMeta,
+}
+
+#[unstable(feature = "global_co_alloc_short_term_pref", issue = "none")]
+//pub const SHORT_TERM_VEC_PREFERS_COOP: bool = true;
+#[macro_export]
+macro_rules! SHORT_TERM_VEC_PREFERS_COOP {
+ () => {true}
+}
+
+#[unstable(feature = "global_co_alloc_meta", issue = "none")]
+#[allow(missing_debug_implementations)]
+pub type SliceAndMetaResult = Result<SliceAndMeta, AllocError>;
+
+#[unstable(feature = "global_co_alloc", issue = "none")]
+pub const fn co_alloc_metadata_num_slots<A: Allocator>() -> usize {
+ // @FIXME later
+ if false {
+ panic!("FIXME - consider replacing co_alloc_metadata_num_slots() with co_alloc_metadata_num_slots_with_preference(bool), and adding const flags as appropriate.");
+ }
+ if A::IS_CO_ALLOCATOR { 1 } else { 0 }
+}
+
+#[unstable(feature = "global_co_alloc", issue = "none")]
+/// Param `coop_preferred` - if false, then this returns `0`, regardless of
+/// whether allocator `A` is cooperative.
+pub const fn co_alloc_metadata_num_slots_with_preference<A: Allocator>(
+ coop_preferred: bool,
+) -> usize {
+ if A::IS_CO_ALLOCATOR && coop_preferred { 1 } else { 0 }
+}
+
/// An implementation of `Allocator` can allocate, grow, shrink, and deallocate arbitrary blocks of
/// data described via [`Layout`][].
///
@@ -107,6 +169,14 @@ impl fmt::Display for AllocError {
#[unstable(feature = "allocator_api", issue = "32838")]
#[const_trait]
pub unsafe trait Allocator {
+ //const fn is_co_allocator() -> bool {false}
+ // Can't have: const type Xyz;
+ /// If this is any type with non-zero size, then the actual `Allocator` implementation supports cooperative functions (`co_*`) as first class citizens.
+ //type IsCoAllocator = ();
+ // It applies to the global (default) allocator only. And/or System allocator?! @FIXME
+ // @FIXME make false by default
+ const IS_CO_ALLOCATOR: bool = true;
+
/// Attempts to allocate a block of memory.
///
/// On success, returns a [`NonNull<[u8]>`][NonNull] meeting the size and alignment guarantees of `layout`.
@@ -129,6 +199,10 @@ pub unsafe trait Allocator {
/// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html
fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError>;
+ fn co_allocate(&self, _layout: Layout, _result: &mut SliceAndMetaResult) {
+ panic!("FIXME")
+ }
+
/// Behaves like `allocate`, but also ensures that the returned memory is zero-initialized.
///
/// # Errors
@@ -151,6 +225,14 @@ pub unsafe trait Allocator {
Ok(ptr)
}
+ fn co_allocate_zeroed(&self, layout: Layout, mut result: &mut SliceAndMetaResult) {
+ self.co_allocate(layout, &mut result);
+ if let Ok(SliceAndMeta { slice, .. }) = result {
+ // SAFETY: `alloc` returns a valid memory block
+ unsafe { slice.as_non_null_ptr().as_ptr().write_bytes(0, slice.len()) }
+ }
+ }
+
/// Deallocates the memory referenced by `ptr`.
///
/// # Safety
@@ -162,6 +244,10 @@ pub unsafe trait Allocator {
/// [*fit*]: #memory-fitting
unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout);
+ unsafe fn co_deallocate(&self, _ptr_and_meta: PtrAndMeta, _layout: Layout) {
+ panic!("FIXME")
+ }
+
/// Attempts to extend the memory block.
///
/// Returns a new [`NonNull<[u8]>`][NonNull] containing a pointer and the actual size of the allocated
@@ -226,6 +312,37 @@ pub unsafe trait Allocator {
Ok(new_ptr)
}
+ unsafe fn co_grow(
+ &self,
+ ptr_and_meta: PtrAndMeta,
+ old_layout: Layout,
+ new_layout: Layout,
+ mut result: &mut SliceAndMetaResult,
+ ) {
+ debug_assert!(
+ new_layout.size() >= old_layout.size(),
+ "`new_layout.size()` must be greater than or equal to `old_layout.size()`"
+ );
+
+ self.co_allocate(new_layout, &mut result);
+
+ if let Ok(SliceAndMeta { slice, .. }) = result {
+ // SAFETY: because `new_layout.size()` must be greater than or equal to
+ // `old_layout.size()`, both the old and new memory allocation are valid for reads and
+ // writes for `old_layout.size()` bytes. Also, because the old allocation wasn't yet
+ // deallocated, it cannot overlap `new_slice_and_meta.slice`. Thus, the call to `copy_nonoverlapping` is
+ // safe. The safety contract for `dealloc` must be upheld by the caller.
+ unsafe {
+ ptr::copy_nonoverlapping(
+ ptr_and_meta.ptr.as_ptr(),
+ slice.as_mut_ptr(),
+ old_layout.size(),
+ );
+ self.co_deallocate(ptr_and_meta, old_layout);
+ }
+ }
+ }
+
/// Behaves like `grow`, but also ensures that the new contents are set to zero before being
/// returned.
///
@@ -289,6 +406,37 @@ pub unsafe trait Allocator {
Ok(new_ptr)
}
+ unsafe fn co_grow_zeroed(
+ &self,
+ ptr_and_meta: PtrAndMeta,
+ old_layout: Layout,
+ new_layout: Layout,
+ mut result: &mut SliceAndMetaResult,
+ ) {
+ debug_assert!(
+ new_layout.size() >= old_layout.size(),
+ "`new_layout.size()` must be greater than or equal to `old_layout.size()`"
+ );
+
+ self.co_allocate_zeroed(new_layout, &mut result);
+
+ if let Ok(SliceAndMeta { slice, .. }) = result {
+ // SAFETY: because `new_layout.size()` must be greater than or equal to
+ // `old_layout.size()`, both the old and new memory allocation are valid for reads and
+ // writes for `old_layout.size()` bytes. Also, because the old allocation wasn't yet
+ // deallocated, it cannot overlap `new_slice_and_meta.slice`. Thus, the call to `copy_nonoverlapping` is
+ // safe. The safety contract for `dealloc` must be upheld by the caller.
+ unsafe {
+ ptr::copy_nonoverlapping(
+ ptr_and_meta.ptr.as_ptr(),
+ slice.as_mut_ptr(),
+ old_layout.size(),
+ );
+ self.co_deallocate(ptr_and_meta, old_layout);
+ }
+ }
+ }
+
/// Attempts to shrink the memory block.
///
/// Returns a new [`NonNull<[u8]>`][NonNull] containing a pointer and the actual size of the allocated
@@ -353,6 +501,37 @@ pub unsafe trait Allocator {
Ok(new_ptr)
}
+ unsafe fn co_shrink(
+ &self,
+ ptr_and_meta: PtrAndMeta,
+ old_layout: Layout,
+ new_layout: Layout,
+ mut result: &mut SliceAndMetaResult,
+ ) {
+ debug_assert!(
+ new_layout.size() <= old_layout.size(),
+ "`new_layout.size()` must be smaller than or equal to `old_layout.size()`"
+ );
+
+ self.co_allocate(new_layout, &mut result);
+
+ if let Ok(SliceAndMeta { slice, .. }) = result {
+ // SAFETY: because `new_layout.size()` must be lower than or equal to
+ // `old_layout.size()`, both the old and new memory allocation are valid for reads and
+ // writes for `new_layout.size()` bytes. Also, because the old allocation wasn't yet
+ // deallocated, it cannot overlap `new_slice_and_meta.slice`. Thus, the call to `copy_nonoverlapping` is
+ // safe. The safety contract for `dealloc` must be upheld by the caller.
+ unsafe {
+ ptr::copy_nonoverlapping(
+ ptr_and_meta.ptr.as_ptr(),
+ slice.as_mut_ptr(),
+ new_layout.size(),
+ );
+ self.co_deallocate(ptr_and_meta, old_layout);
+ }
+ }
+ }
+
/// Creates a "by reference" adapter for this instance of `Allocator`.
///
/// The returned adapter also implements `Allocator` and will simply borrow this.
@@ -365,6 +544,7 @@ pub unsafe trait Allocator {
}
}
+// @FIXME
#[unstable(feature = "allocator_api", issue = "32838")]
unsafe impl<A> Allocator for &A
where
diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs
index 8790649abe6f1..b62da0571aec3 100644
--- a/library/core/src/lib.rs
+++ b/library/core/src/lib.rs
@@ -97,6 +97,7 @@
#![allow(incomplete_features)]
//
// Library features:
+#![feature(associated_type_defaults)]
#![feature(const_align_offset)]
#![feature(const_align_of_val)]
#![feature(const_align_of_val_raw)]
diff --git a/library/proc_macro/src/bridge/mod.rs b/library/proc_macro/src/bridge/mod.rs
index 4c1e196b5ad16..aae141dc2a118 100644
--- a/library/proc_macro/src/bridge/mod.rs
+++ b/library/proc_macro/src/bridge/mod.rs
@@ -252,14 +252,14 @@ impl<'a, T, M> Unmark for &'a mut Marked<T, M> {
}
}
-impl<T: Mark> Mark for Vec<T> {
+impl<T: Mark> Mark for Vec<T, Global, DEFAULT_COOP_PREFERRED> {
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> {
+impl<T: Unmark> Unmark for Vec<T, Global, DEFAULT_COOP_PREFERRED> {
type Unmarked = Vec<T::Unmarked>;
fn unmark(self) -> Self::Unmarked {
// Should be a no-op due to std's in-place collect optimizations.
diff --git a/library/proc_macro/src/bridge/rpc.rs b/library/proc_macro/src/bridge/rpc.rs
index e9d7a46c06f6d..c50eb9c620626 100644
--- a/library/proc_macro/src/bridge/rpc.rs
+++ b/library/proc_macro/src/bridge/rpc.rs
@@ -225,7 +225,7 @@ impl<S> DecodeMut<'_, '_, S> for String {
}
}
-impl<S, T: Encode<S>> Encode<S> for Vec<T> {
+impl<S, T: Encode<S>> Encode<S> for Vec<T, Global, DEFAULT_COOP_PREFERRED> {
fn encode(self, w: &mut Writer, s: &mut S) {
self.len().encode(w, s);
for x in self {
@@ -234,7 +234,7 @@ impl<S, T: Encode<S>> Encode<S> for Vec<T> {
}
}
-impl<'a, S, T: for<'s> DecodeMut<'a, 's, S>> DecodeMut<'a, '_, S> for Vec<T> {
+impl<'a, S, T: for<'s> DecodeMut<'a, 's, S>> DecodeMut<'a, '_, S> for Vec<T, Global, DEFAULT_COOP_PREFERRED> {
fn decode(r: &mut Reader<'a>, s: &mut S) -> Self {
let len = usize::decode(r, s);
let mut vec = Vec::with_capacity(len);
diff --git a/library/proc_macro/src/diagnostic.rs b/library/proc_macro/src/diagnostic.rs
index 5a209f7c7aa18..41a11b1003b84 100644
--- a/library/proc_macro/src/diagnostic.rs
+++ b/library/proc_macro/src/diagnostic.rs
@@ -30,7 +30,7 @@ impl MultiSpan for Span {
}
#[unstable(feature = "proc_macro_diagnostic", issue = "54140")]
-impl MultiSpan for Vec<Span> {
+impl MultiSpan for Vec<Span, Global, DEFAULT_COOP_PREFERRED> {
fn into_spans(self) -> Vec<Span> {
self
}
diff --git a/library/std/src/alloc.rs b/library/std/src/alloc.rs
index c5a5991cc81c4..6969c7d81dd5e 100644
--- a/library/std/src/alloc.rs
+++ b/library/std/src/alloc.rs
@@ -197,10 +197,13 @@ impl System {
}
}
+// @FIXME
// The Allocator impl checks the layout size to be non-zero and forwards to the GlobalAlloc impl,
// which is in `std::sys::*::alloc`.
#[unstable(feature = "allocator_api", issue = "32838")]
unsafe impl Allocator for System {
+ const IS_CO_ALLOCATOR: bool = false;
+
#[inline]
fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
self.alloc_impl(layout, false)
diff --git a/library/std/src/ffi/os_str.rs b/library/std/src/ffi/os_str.rs
index 80ed34157e6dc..75693df5053af 100644
--- a/library/std/src/ffi/os_str.rs
+++ b/library/std/src/ffi/os_str.rs
@@ -1,6 +1,7 @@
#[cfg(test)]
mod tests;
+use crate::alloc::Global;
use crate::borrow::{Borrow, Cow};
use crate::cmp;
use crate::collections::TryReserveError;
@@ -1324,7 +1325,10 @@ impl AsRef<OsStr> for str {
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl AsRef<OsStr> for String {
+impl<const COOP_PREFERRED: bool> AsRef<OsStr> for String<COOP_PREFERRED>
+where
+ [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
#[inline]
fn as_ref(&self) -> &OsStr {
(&**self).as_ref()
diff --git a/library/std/src/io/cursor.rs b/library/std/src/io/cursor.rs
index d98ab021cadb1..63045ebcb8157 100644
--- a/library/std/src/io/cursor.rs
+++ b/library/std/src/io/cursor.rs
@@ -6,6 +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;
/// A `Cursor` wraps an in-memory buffer and provides it with a
/// [`Seek`] implementation.
@@ -397,11 +398,14 @@ fn slice_write_vectored(
}
/// Reserves the required space, and pads the vec with 0s if necessary.
-fn reserve_and_pad<A: Allocator>(
+fn reserve_and_pad<A: Allocator, const COOP_PREFERRED: bool>(
pos_mut: &mut u64,
- vec: &mut Vec<u8, A>,
+ vec: &mut Vec<u8, A, COOP_PREFERRED>,
buf_len: usize,
-) -> io::Result<usize> {
+) -> io::Result<usize>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
let pos: usize = (*pos_mut).try_into().map_err(|_| {
io::const_io_error!(
ErrorKind::InvalidInput,
@@ -440,9 +444,14 @@ fn reserve_and_pad<A: Allocator>(
/// Writes the slice to the vec without allocating
/// # Safety: vec must have buf.len() spare capacity
-unsafe fn vec_write_unchecked<A>(pos: usize, vec: &mut Vec<u8, A>, buf: &[u8]) -> usize
+unsafe fn vec_write_unchecked<A, const COOP_PREFERRED: bool>(
+ pos: usize,
+ vec: &mut Vec<u8, A, COOP_PREFERRED>,
+ buf: &[u8],
+) -> usize
where
A: Allocator,
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
{
debug_assert!(vec.capacity() >= pos + buf.len());
vec.as_mut_ptr().add(pos).copy_from(buf.as_ptr(), buf.len());
@@ -458,9 +467,14 @@ 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
-fn vec_write<A>(pos_mut: &mut u64, vec: &mut Vec<u8, A>, buf: &[u8]) -> io::Result<usize>
+fn vec_write<A, const COOP_PREFERRED: bool>(
+ pos_mut: &mut u64,
+ vec: &mut Vec<u8, A, COOP_PREFERRED>,
+ buf: &[u8],
+) -> io::Result<usize>
where
A: Allocator,
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
{
let buf_len = buf.len();
let mut pos = reserve_and_pad(pos_mut, vec, buf_len)?;
@@ -489,13 +503,14 @@ 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
-fn vec_write_vectored<A>(
+fn vec_write_vectored<A, const COOP_PREFERRED: bool>(
pos_mut: &mut u64,
- vec: &mut Vec<u8, A>,
+ vec: &mut Vec<u8, A, COOP_PREFERRED>,
bufs: &[IoSlice<'_>],
) -> io::Result<usize>
where
A: Allocator,
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
{
// For safety reasons, we don't want this sum to overflow ever.
// If this saturates, the reserve should panic to avoid any unsound writing.
@@ -543,9 +558,10 @@ impl Write for Cursor<&mut [u8]> {
}
#[stable(feature = "cursor_mut_vec", since = "1.25.0")]
-impl<A> Write for Cursor<&mut Vec<u8, A>>
+impl<A, const COOP_PREFERRED: bool> Write for Cursor<&mut Vec<u8, A, COOP_PREFERRED>>
where
A: Allocator,
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
{
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
vec_write(&mut self.pos, self.inner, buf)
@@ -567,9 +583,10 @@ where
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl<A> Write for Cursor<Vec<u8, A>>
+impl<A, const COOP_PREFERRED: bool> Write for Cursor<Vec<u8, A, COOP_PREFERRED>>
where
A: Allocator,
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
{
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
vec_write(&mut self.pos, &mut self.inner, buf)
diff --git a/library/std/src/io/impls.rs b/library/std/src/io/impls.rs
index e5048dcc8acd9..64efd793b8c20 100644
--- a/library/std/src/io/impls.rs
+++ b/library/std/src/io/impls.rs
@@ -1,7 +1,7 @@
#[cfg(test)]
mod tests;
-use crate::alloc::Allocator;
+use crate::alloc::{Allocator, self};
use crate::cmp;
use crate::collections::VecDeque;
use crate::fmt;
@@ -378,7 +378,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")]
-impl<A: Allocator> Write for Vec<u8, A> {
+impl<A: Allocator, const COOP_PREFERRED: bool> Write for Vec<u8, A, COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(COOP_PREFERRED)]:,
+{
#[inline]
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
self.extend_from_slice(buf);
@@ -414,7 +417,10 @@ impl<A: Allocator> Write for Vec<u8, A> {
/// 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> Read for VecDeque<u8, A> {
+impl<A: Allocator, const _COOP_PREFERRED: bool> Read for VecDeque<u8, A, _COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(_COOP_PREFERRED)]:,
+{
/// 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
/// discontiguous, multiple calls to `read` will be needed to read the entire content.
@@ -438,7 +444,10 @@ impl<A: Allocator> Read for VecDeque<u8, A> {
/// 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> Write for VecDeque<u8, A> {
+impl<A: Allocator, const _COOP_PREFERRED: bool> Write for VecDeque<u8, A, _COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<A>(_COOP_PREFERRED)]:,
+{
#[inline]
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
self.extend(buf);
diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs
index a7e13f5b866b5..4d6c5e0968cdc 100644
--- a/library/std/src/lib.rs
+++ b/library/std/src/lib.rs
@@ -214,6 +214,10 @@
#![needs_panic_runtime]
//
// Lints:
+#![allow(incomplete_features)]
+#![feature(generic_const_exprs)]
+#![feature(global_co_alloc)]
+#![feature(global_co_alloc_plvec)]
#![warn(deprecated_in_future)]
#![warn(missing_docs)]
#![warn(missing_debug_implementations)]
diff --git a/library/std/src/path.rs b/library/std/src/path.rs
index c3593264e520b..f39d912970aca 100644
--- a/library/std/src/path.rs
+++ b/library/std/src/path.rs
@@ -70,6 +70,7 @@
#[cfg(test)]
mod tests;
+use crate::alloc::{Global, self};
use crate::borrow::{Borrow, Cow};
use crate::cmp;
use crate::collections::TryReserveError;
@@ -3141,7 +3142,10 @@ impl AsRef<Path> for str {
}
#[stable(feature = "rust1", since = "1.0.0")]
-impl AsRef<Path> for String {
+impl<const COOP_PREFERRED: bool> AsRef<Path> for String<COOP_PREFERRED>
+where
+ [(); alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
#[inline]
fn as_ref(&self) -> &Path {
Path::new(self)
diff --git a/library/std/src/sys/hermit/thread_local_dtor.rs b/library/std/src/sys/hermit/thread_local_dtor.rs
index 9b683fce15748..7f0c2b0b180cb 100644
--- a/library/std/src/sys/hermit/thread_local_dtor.rs
+++ b/library/std/src/sys/hermit/thread_local_dtor.rs
@@ -1,5 +1,6 @@
#![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
@@ -7,11 +8,12 @@
use crate::cell::Cell;
use crate::ptr;
+use core::alloc::PlVec;
#[thread_local]
static DTORS: Cell<*mut List> = Cell::new(ptr::null_mut());
-type List = Vec<(*mut u8, unsafe extern "C" fn(*mut u8))>;
+type List = PlVec<(*mut u8, unsafe extern "C" fn(*mut u8))>;
pub unsafe fn register_dtor(t: *mut u8, dtor: unsafe extern "C" fn(*mut u8)) {
if DTORS.get().is_null() {
diff --git a/library/std/src/sys/solid/thread_local_dtor.rs b/library/std/src/sys/solid/thread_local_dtor.rs
index 9735645705776..c7cf2f02ebbd1 100644
--- a/library/std/src/sys/solid/thread_local_dtor.rs
+++ b/library/std/src/sys/solid/thread_local_dtor.rs
@@ -1,16 +1,18 @@
#![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.
use super::{abi, itron::task};
use crate::cell::Cell;
use crate::ptr;
+use core::alloc::PlVec;
#[thread_local]
static DTORS: Cell<*mut List> = Cell::new(ptr::null_mut());
-type List = Vec<(*mut u8, unsafe extern "C" fn(*mut u8))>;
+type List = PlVec<(*mut u8, unsafe extern "C" fn(*mut u8))>;
pub unsafe fn register_dtor(t: *mut u8, dtor: unsafe extern "C" fn(*mut u8)) {
if DTORS.get().is_null() {
diff --git a/library/std/src/sys/unix/thread_local_dtor.rs b/library/std/src/sys/unix/thread_local_dtor.rs
index d7fd2130f7cce..157e09359bd61 100644
--- a/library/std/src/sys/unix/thread_local_dtor.rs
+++ b/library/std/src/sys/unix/thread_local_dtor.rs
@@ -66,7 +66,7 @@ pub unsafe fn register_dtor(t: *mut u8, dtor: unsafe extern "C" fn(*mut u8)) {
REGISTERED.set(true);
}
- type List = Vec<(*mut u8, unsafe extern "C" fn(*mut u8))>;
+ 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());
diff --git a/library/std/src/sys/windows/mod.rs b/library/std/src/sys/windows/mod.rs
index 77359abe42995..0296c2dab5552 100644
--- a/library/std/src/sys/windows/mod.rs
+++ b/library/std/src/sys/windows/mod.rs
@@ -204,6 +204,7 @@ where
// incorrect size hints for some short paths:
// https://github.com/dylni/normpath/issues/5
let mut stack_buf: [MaybeUninit<u16>; 512] = MaybeUninit::uninit_array();
+ // @FIXME Use CoVec?
let mut heap_buf: Vec<MaybeUninit<u16>> = Vec::new();
unsafe {
let mut n = stack_buf.len();
diff --git a/library/std/src/sys/windows/thread_local_dtor.rs b/library/std/src/sys/windows/thread_local_dtor.rs
index 9707a95dff21b..cbadd2dd23aea 100644
--- a/library/std/src/sys/windows/thread_local_dtor.rs
+++ b/library/std/src/sys/windows/thread_local_dtor.rs
@@ -3,10 +3,13 @@
#![unstable(feature = "thread_local_internals", issue = "none")]
#![cfg(target_thread_local)]
+#![feature(global_co_alloc_plvec)]
+
+use core::alloc::PlVec;
// Using a per-thread list avoids the problems in synchronizing global state.
#[thread_local]
-static mut DESTRUCTORS: Vec<(*mut u8, unsafe extern "C" fn(*mut u8))> = Vec::new();
+static mut DESTRUCTORS: PlVec<(*mut u8, unsafe extern "C" fn(*mut u8))> = Vec::new();
// Ensure this can never be inlined because otherwise this may break in dylibs.
// See #44391.
diff --git a/library/std/src/sys_common/thread_local_dtor.rs b/library/std/src/sys_common/thread_local_dtor.rs
index 1d13a7171b035..21cd817d2d8f6 100644
--- a/library/std/src/sys_common/thread_local_dtor.rs
+++ b/library/std/src/sys_common/thread_local_dtor.rs
@@ -15,6 +15,7 @@
use crate::ptr;
use crate::sys_common::thread_local_key::StaticKey;
+use alloc::vec::PlVec;
pub unsafe fn register_dtor_fallback(t: *mut u8, dtor: unsafe extern "C" fn(*mut u8)) {
// The fallback implementation uses a vanilla OS-based TLS key to track
@@ -28,7 +29,7 @@ pub unsafe fn register_dtor_fallback(t: *mut u8, dtor: unsafe extern "C" fn(*mut
// flagged for destruction.
static DTORS: StaticKey = StaticKey::new(Some(run_dtors));
- type List = Vec<(*mut u8, unsafe extern "C" fn(*mut u8))>;
+ type List = PlVec<(*mut u8, unsafe extern "C" fn(*mut u8))>;
if DTORS.get().is_null() {
let v: Box<List> = box Vec::new();
DTORS.set(Box::into_raw(v) as *mut u8);
diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index 87de41fde63c5..33fc804968883 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -1,6 +1,8 @@
+use std::alloc::GlobalCoAllocMeta;
use std::cell::RefCell;
use std::default::Default;
use std::hash::Hash;
+use std::mem;
use std::path::PathBuf;
use std::rc::Rc;
use std::sync::Arc;
@@ -2594,13 +2596,13 @@ mod size_asserts {
// tidy-alphabetical-start
static_assert_size!(Crate, 64); // frequently moved by-value
static_assert_size!(DocFragment, 32);
- static_assert_size!(GenericArg, 32);
+ static_assert_size!(GenericArg, 32 + mem::size_of::<GlobalCoAllocMeta>());
static_assert_size!(GenericArgs, 32);
- static_assert_size!(GenericParamDef, 56);
+ static_assert_size!(GenericParamDef, 56 + mem::size_of::<GlobalCoAllocMeta>());
static_assert_size!(Generics, 16);
static_assert_size!(Item, 56);
- static_assert_size!(ItemKind, 64);
+ static_assert_size!(ItemKind, 64 + mem::size_of::<GlobalCoAllocMeta>());
static_assert_size!(PathSegment, 40);
- static_assert_size!(Type, 32);
+ static_assert_size!(Type, 32 + mem::size_of::<GlobalCoAllocMeta>());
// tidy-alphabetical-end
}
diff --git a/src/librustdoc/html/render/context.rs b/src/librustdoc/html/render/context.rs
index 5cefe9475e775..6e974fc701e87 100644
--- a/src/librustdoc/html/render/context.rs
+++ b/src/librustdoc/html/render/context.rs
@@ -1,6 +1,8 @@
+use std::alloc::GlobalCoAllocMeta;
use std::cell::RefCell;
use std::collections::BTreeMap;
use std::io;
+use std::mem;
use std::path::{Path, PathBuf};
use std::rc::Rc;
use std::sync::mpsc::{channel, Receiver};
@@ -75,7 +77,10 @@ pub(crate) struct Context<'tcx> {
// `Context` is cloned a lot, so we don't want the size to grow unexpectedly.
#[cfg(all(not(windows), target_arch = "x86_64", target_pointer_width = "64"))]
-rustc_data_structures::static_assert_size!(Context<'_>, 160);
+rustc_data_structures::static_assert_size!(
+ Context<'_>,
+ 160 + 2 * mem::size_of::<GlobalCoAllocMeta>()
+);
/// Shared mutable state used in [`Context`] and elsewhere.
pub(crate) struct SharedContext<'tcx> {
diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs
index 86454e1f2eb73..3a2eaab102b6b 100644
--- a/src/librustdoc/lib.rs
+++ b/src/librustdoc/lib.rs
@@ -8,6 +8,7 @@
#![feature(box_patterns)]
#![feature(control_flow_enum)]
#![feature(drain_filter)]
+#![feature(global_co_alloc_meta)]
#![feature(is_terminal)]
#![feature(let_chains)]
#![feature(test)]