From 05b7b1896b90cc2a9ebd7688db6d133bd52fed73 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sat, 21 Jan 2023 15:37:26 -0800 Subject: [PATCH 01/80] START CoAlloc API --- library/core/src/alloc/global.rs | 56 +++++++++++++++++++++++++++++++- library/core/src/alloc/mod.rs | 10 ++++++ 2 files changed, 65 insertions(+), 1 deletion(-) diff --git a/library/core/src/alloc/global.rs b/library/core/src/alloc/global.rs index 1d80b8bf9ec76..030e1bc110c5e 100644 --- a/library/core/src/alloc/global.rs +++ b/library/core/src/alloc/global.rs @@ -1,6 +1,15 @@ use crate::alloc::Layout; use crate::cmp; use crate::ptr; +use crate::alloc::GlobalCoAllocMeta; + +#[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 PtrAndMeta { + 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,9 @@ 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 PtrAndMeta) {panic!("TODO")} + /// Deallocate the block of memory at the given `ptr` pointer with the given `layout`. /// /// # Safety @@ -171,6 +183,9 @@ 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: PtrAndMeta, _layout: Layout) {panic!("TODO")} + /// Behaves like `alloc`, but also ensures that the contents /// are set to zero before being returned. /// @@ -198,11 +213,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 PtrAndMeta) { + 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 +301,31 @@ pub unsafe trait GlobalAlloc { } new_ptr } + + #[unstable(feature = "global_co_alloc", issue = "none")] + unsafe fn co_realloc( + &self, + ptr_and_meta: PtrAndMeta, + layout: Layout, + new_size: usize, + mut result: &mut PtrAndMeta + ) { + // 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..6e7b54ffb8612 100644 --- a/library/core/src/alloc/mod.rs +++ b/library/core/src/alloc/mod.rs @@ -25,6 +25,16 @@ use crate::error::Error; use crate::fmt; use crate::ptr::{self, NonNull}; +// @TODO Make this target-specific +#[unstable(feature = "global_co_alloc_meta", issue = "none")] +#[allow(missing_debug_implementations)] +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 From 406e8a323ac4580a829005a3b6f53aa097694b3a Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sat, 21 Jan 2023 15:39:15 -0800 Subject: [PATCH 02/80] CoAlloc: RawVec + compiler 'tests' --- compiler/rustc_ast/src/ast.rs | 24 +++++++++---------- compiler/rustc_ast/src/lib.rs | 1 + compiler/rustc_middle/src/lib.rs | 1 + compiler/rustc_middle/src/mir/mod.rs | 3 ++- compiler/rustc_middle/src/mir/syntax.rs | 4 +++- compiler/rustc_parse/src/lib.rs | 1 + .../rustc_parse/src/parser/attr_wrapper.rs | 4 +++- compiler/rustc_parse/src/parser/mod.rs | 3 ++- compiler/rustc_trait_selection/src/lib.rs | 1 + .../src/traits/fulfill.rs | 5 +++- library/alloc/src/lib.rs | 2 ++ library/alloc/src/raw_vec.rs | 19 ++++++++++++--- src/librustdoc/clean/types.rs | 10 ++++---- src/librustdoc/html/render/context.rs | 4 +++- src/librustdoc/lib.rs | 1 + 15 files changed, 58 insertions(+), 25 deletions(-) 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::()); + static_assert_size!(Expr, 72 + mem::size_of::()); + static_assert_size!(ExprKind, 40 + mem::size_of::()); + static_assert_size!(Fn, 184 + 2 * mem::size_of::()); 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::()); + static_assert_size!(Generics, 72 + 2 * mem::size_of::()); + static_assert_size!(Impl, 184 + 3 * mem::size_of::()); + static_assert_size!(Item, 184 + 3 * mem::size_of::()); + static_assert_size!(ItemKind, 112 + 3 * mem::size_of::()); 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::()); static_assert_size!(Path, 24); static_assert_size!(PathSegment, 24); - static_assert_size!(PatKind, 64); + static_assert_size!(PatKind, 64 + mem::size_of::()); 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 4da893e4c0716..1d9c893500a7f 100644 --- a/compiler/rustc_middle/src/mir/mod.rs +++ b/compiler/rustc_middle/src/mir/mod.rs @@ -2,6 +2,7 @@ //! //! [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/mir/index.html +use core::alloc::GlobalCoAllocMeta; use crate::mir::interpret::{ AllocRange, ConstAllocation, ConstValue, ErrorHandled, GlobalAlloc, LitToConstInput, Scalar, }; @@ -3057,7 +3058,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::()); 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..cfaecf0775ff4 100644 --- a/compiler/rustc_middle/src/mir/syntax.rs +++ b/compiler/rustc_middle/src/mir/syntax.rs @@ -3,6 +3,8 @@ //! This is in a dedicated file so that changes to this file can be reviewed more carefully. //! The intention is that this file only contains datatype declarations, no code. +use core::alloc::GlobalCoAllocMeta; +use core::mem; use super::{BasicBlock, Constant, Field, Local, SwitchTargets, UserTypeProjection}; use crate::mir::coverage::{CodeRegion, CoverageKind}; @@ -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::()); // 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..a8c2d8c2c59d3 100644 --- a/compiler/rustc_parse/src/parser/attr_wrapper.rs +++ b/compiler/rustc_parse/src/parser/attr_wrapper.rs @@ -1,3 +1,5 @@ +use core::alloc::GlobalCoAllocMeta; +use core::mem; use super::{Capturing, FlatToken, ForceCollect, Parser, ReplaceRange, TokenCursor, TrailingToken}; use rustc_ast::token::{self, Delimiter, Token, TokenKind}; use rustc_ast::tokenstream::{AttrTokenStream, AttributesData, ToAttrTokenStream}; @@ -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::()); // tidy-alphabetical-end } diff --git a/compiler/rustc_parse/src/parser/mod.rs b/compiler/rustc_parse/src/parser/mod.rs index ffb23b50a160d..e8567a650d85f 100644 --- a/compiler/rustc_parse/src/parser/mod.rs +++ b/compiler/rustc_parse/src/parser/mod.rs @@ -11,6 +11,7 @@ mod stmt; mod ty; use crate::lexer::UnmatchedBrace; +use core::alloc::GlobalCoAllocMeta; pub use attr_wrapper::AttrWrapper; pub use diagnostics::AttemptLocalParseRecovery; pub(crate) use item::FnParseMode; @@ -168,7 +169,7 @@ 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::()); /// 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 5a58d37e18362..d2fc5dc7a269e 100644 --- a/compiler/rustc_trait_selection/src/traits/fulfill.rs +++ b/compiler/rustc_trait_selection/src/traits/fulfill.rs @@ -1,4 +1,7 @@ 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}; use rustc_data_structures::obligation_forest::{ObligationForest, ObligationProcessor}; @@ -77,7 +80,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::()); impl<'a, 'tcx> FulfillmentContext<'tcx> { /// Creates a new fulfillment context. diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs index ca75c3895f41f..3e6ab0cfcbd64 100644 --- a/library/alloc/src/lib.rs +++ b/library/alloc/src/lib.rs @@ -123,6 +123,7 @@ #![feature(extend_one)] #![feature(fmt_internals)] #![feature(fn_traits)] +#![feature(global_co_alloc_meta)] #![feature(hasher_prefixfree_extras)] #![feature(inline_const)] #![feature(inplace_iteration)] @@ -178,6 +179,7 @@ #![feature(exclusive_range_pattern)] #![feature(fundamental)] #![cfg_attr(not(test), feature(generator_trait))] +#![feature(global_co_alloc)] #![feature(hashmap_internals)] #![feature(lang_items)] #![feature(min_specialization)] diff --git a/library/alloc/src/raw_vec.rs b/library/alloc/src/raw_vec.rs index 5a10121bbbe4b..9129d3f0f7cab 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::{LayoutError, GlobalCoAllocMeta}; use core::cmp; use core::intrinsics; use core::mem::{self, ManuallyDrop, MaybeUninit, SizedTypeProperties}; @@ -53,6 +53,8 @@ pub(crate) struct RawVec { ptr: Unique, cap: usize, alloc: A, + #[allow(dead_code)] + pub(crate) meta: GlobalCoAllocMeta, } impl RawVec { @@ -120,7 +122,7 @@ impl RawVec { /// 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, meta: GlobalCoAllocMeta {/*one: 1*/ /* , two: 2, three: 3, four: 4*/} } } /// Like `with_capacity`, but parameterized over the choice of @@ -197,6 +199,7 @@ impl RawVec { ptr: unsafe { Unique::new_unchecked(ptr.cast().as_ptr()) }, cap: capacity, alloc, + meta: GlobalCoAllocMeta {/*one: 1*/ /*, two: 2, three: 3, four: 4*/} } } } @@ -213,7 +216,7 @@ impl RawVec { /// 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, meta: GlobalCoAllocMeta {/*one: 1*/ /*, two: 2, three: 3, four: 4*/} } } /// Gets a raw pointer to the start of the allocation. Note that this is @@ -473,8 +476,18 @@ where } unsafe impl<#[may_dangle] T, A: Allocator> Drop for RawVec { + /// Frees the memory owned by the `RawVec` *without* trying to drop its contents. + default fn drop(&mut self) { + if let Some((ptr, layout)) = self.current_memory() { + unsafe { self.alloc.deallocate(ptr, layout) } + } + } +} + +unsafe impl<#[may_dangle] T> Drop for RawVec { /// Frees the memory owned by the `RawVec` *without* trying to drop its contents. fn drop(&mut self) { + // @TODO if let Some((ptr, layout)) = self.current_memory() { unsafe { self.alloc.deallocate(ptr, layout) } } diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs index a020ccd53b842..770365759da20 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; @@ -2587,13 +2589,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::()); static_assert_size!(GenericArgs, 32); - static_assert_size!(GenericParamDef, 56); + static_assert_size!(GenericParamDef, 56 + mem::size_of::()); static_assert_size!(Generics, 16); static_assert_size!(Item, 56); - static_assert_size!(ItemKind, 64); + static_assert_size!(ItemKind, 64 + mem::size_of::()); static_assert_size!(PathSegment, 40); - static_assert_size!(Type, 32); + static_assert_size!(Type, 32 + mem::size_of::()); // tidy-alphabetical-end } diff --git a/src/librustdoc/html/render/context.rs b/src/librustdoc/html/render/context.rs index 15258a467a228..16137c49fb22d 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,7 @@ 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::()); /// 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)] From 7de7affc98b37208aeb1ad0d47bab3cff68bd8cf Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sat, 10 Dec 2022 10:44:27 -0800 Subject: [PATCH 03/80] CoAlloc: GlobalAlloc API --- library/core/src/alloc/global.rs | 12 +-- library/core/src/alloc/mod.rs | 129 +++++++++++++++++++++++++++++++ 2 files changed, 135 insertions(+), 6 deletions(-) diff --git a/library/core/src/alloc/global.rs b/library/core/src/alloc/global.rs index 030e1bc110c5e..fd47d6cf88025 100644 --- a/library/core/src/alloc/global.rs +++ b/library/core/src/alloc/global.rs @@ -6,7 +6,7 @@ use crate::alloc::GlobalCoAllocMeta; #[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 PtrAndMeta { +pub struct RawAndMeta { pub ptr: *mut u8, pub meta: GlobalCoAllocMeta, } @@ -166,7 +166,7 @@ pub unsafe trait GlobalAlloc { 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 PtrAndMeta) {panic!("TODO")} + unsafe fn co_alloc(&self, _layout: Layout, mut _result: &mut RawAndMeta) {panic!("TODO")} /// Deallocate the block of memory at the given `ptr` pointer with the given `layout`. /// @@ -184,7 +184,7 @@ pub unsafe trait GlobalAlloc { unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout); #[unstable(feature = "global_co_alloc", issue = "none")] - unsafe fn co_dealloc(&self, _ptr_and_meta: PtrAndMeta, _layout: Layout) {panic!("TODO")} + unsafe fn co_dealloc(&self, _ptr_and_meta: RawAndMeta, _layout: Layout) {panic!("TODO")} /// Behaves like `alloc`, but also ensures that the contents /// are set to zero before being returned. @@ -219,7 +219,7 @@ pub unsafe trait GlobalAlloc { } #[unstable(feature = "global_co_alloc", issue = "none")] - unsafe fn co_alloc_zeroed(&self, layout: Layout, mut result: &mut PtrAndMeta) { + 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) }; @@ -305,10 +305,10 @@ pub unsafe trait GlobalAlloc { #[unstable(feature = "global_co_alloc", issue = "none")] unsafe fn co_realloc( &self, - ptr_and_meta: PtrAndMeta, + ptr_and_meta: RawAndMeta, layout: Layout, new_size: usize, - mut result: &mut PtrAndMeta + 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. diff --git a/library/core/src/alloc/mod.rs b/library/core/src/alloc/mod.rs index 6e7b54ffb8612..53be91801e0cf 100644 --- a/library/core/src/alloc/mod.rs +++ b/library/core/src/alloc/mod.rs @@ -58,6 +58,25 @@ impl fmt::Display for AllocError { } } +#[unstable(feature = "global_co_alloc_meta", issue = "none")] +#[allow(missing_debug_implementations)] +pub struct PtrAndMeta { + pub ptr: NonNull, + 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_meta", issue = "none")] +#[allow(missing_debug_implementations)] +pub type SliceAndMetaResult = Result; + /// An implementation of `Allocator` can allocate, grow, shrink, and deallocate arbitrary blocks of /// data described via [`Layout`][]. /// @@ -139,6 +158,8 @@ pub unsafe trait Allocator { /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html fn allocate(&self, layout: Layout) -> Result, AllocError>; + fn co_allocate(&self, _layout: Layout, _result: &mut SliceAndMetaResult) {panic!("TODO")} + /// Behaves like `allocate`, but also ensures that the returned memory is zero-initialized. /// /// # Errors @@ -161,6 +182,19 @@ 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 @@ -172,6 +206,8 @@ pub unsafe trait Allocator { /// [*fit*]: #memory-fitting unsafe fn deallocate(&self, ptr: NonNull, layout: Layout); + unsafe fn co_deallocate(&self, _ptr_and_meta: PtrAndMeta, _layout: Layout) {panic!("TODO")} + /// Attempts to extend the memory block. /// /// Returns a new [`NonNull<[u8]>`][NonNull] containing a pointer and the actual size of the allocated @@ -236,6 +272,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. /// @@ -299,6 +366,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 @@ -363,6 +461,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. From 4a72a966bd97c4da14a25e4b2c21e72567262b42 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sat, 21 Jan 2023 15:55:48 -0800 Subject: [PATCH 04/80] CoAlloc: Alloc API --- library/core/src/alloc/mod.rs | 13 +++++++++++++ library/core/src/lib.rs | 1 + library/std/src/alloc.rs | 3 +++ 3 files changed, 17 insertions(+) diff --git a/library/core/src/alloc/mod.rs b/library/core/src/alloc/mod.rs index 53be91801e0cf..23bfdc732557e 100644 --- a/library/core/src/alloc/mod.rs +++ b/library/core/src/alloc/mod.rs @@ -77,6 +77,11 @@ pub struct SliceAndMeta { #[allow(missing_debug_implementations)] pub type SliceAndMetaResult = Result; +#[unstable(feature = "global_co_alloc", issue = "none")] +pub const fn co_alloc_metadata_num_slots() -> usize { + if A::IS_CO_ALLOCATOR { 1 } else { 0 } +} + /// An implementation of `Allocator` can allocate, grow, shrink, and deallocate arbitrary blocks of /// data described via [`Layout`][]. /// @@ -136,6 +141,13 @@ pub type SliceAndMetaResult = Result; #[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?! TODO + 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`. @@ -504,6 +516,7 @@ pub unsafe trait Allocator { } } +// @TODO #[unstable(feature = "allocator_api", issue = "32838")] unsafe impl 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/std/src/alloc.rs b/library/std/src/alloc.rs index c5a5991cc81c4..bee6edbc40731 100644 --- a/library/std/src/alloc.rs +++ b/library/std/src/alloc.rs @@ -197,10 +197,13 @@ impl System { } } +// @TODO // 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, AllocError> { self.alloc_impl(layout, false) From e1114cc182eba366f2681497d75fe30508e113a5 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sat, 21 Jan 2023 15:58:34 -0800 Subject: [PATCH 05/80] CoAlloc: RawVec includes GlobalCoAllocMeta based on allocator; related bounds - NOT COMPILING (no ICE, but standard compiler error) --- library/alloc/src/lib.rs | 2 + library/alloc/src/raw_vec.rs | 44 ++++++++++++++------ library/alloc/src/slice.rs | 25 ++++++++---- library/alloc/src/vec/mod.rs | 78 ++++++++++++++++++++++++++---------- library/alloc/tests/boxed.rs | 1 + 5 files changed, 108 insertions(+), 42 deletions(-) diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs index 3e6ab0cfcbd64..5f98be5219384 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,7 @@ #![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)] diff --git a/library/alloc/src/raw_vec.rs b/library/alloc/src/raw_vec.rs index 9129d3f0f7cab..9cf96ac700f55 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, GlobalCoAllocMeta}; +use core::alloc::{self, LayoutError, GlobalCoAllocMeta}; use core::cmp; use core::intrinsics; use core::mem::{self, ManuallyDrop, MaybeUninit, SizedTypeProperties}; @@ -49,12 +49,19 @@ 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 { +// @TODO +// 1. make const generic _coop come from the target specification +// 2. apply `_coop` with logical && to `A::IsCoAllocator` +pub(crate) struct RawVec +where [(); alloc::co_alloc_metadata_num_slots::()]: +{ ptr: Unique, cap: usize, alloc: A, - #[allow(dead_code)] - pub(crate) meta: GlobalCoAllocMeta, + // As of v1.67.0, `cmp` for `TypeId` is not `const`, unfortunately: + //pub(crate) meta: [GlobalCoAllocMeta; {if core::any::TypeId::of::()==core::any::TypeId::of::() {1} else {0}}], + //pub(crate) meta: [GlobalCoAllocMeta; mem::size_of::()], + pub(crate) meta: [GlobalCoAllocMeta; alloc::co_alloc_metadata_num_slots::()], } impl RawVec { @@ -104,7 +111,9 @@ impl RawVec { } } -impl RawVec { +impl RawVec +where [(); alloc::co_alloc_metadata_num_slots::()]: +{ // 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. @@ -284,7 +293,9 @@ impl RawVec { slf: &mut RawVec, len: usize, additional: usize, - ) { + ) + where [(); alloc::co_alloc_metadata_num_slots::()]: + { handle_reserve(slf.grow_amortized(len, additional)); } @@ -357,14 +368,18 @@ impl RawVec { } } -impl RawVec { +impl RawVec +where [(); alloc::co_alloc_metadata_num_slots::()]: +{ /// 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 { + fn needs_to_grow(&self, len: usize, additional: usize) -> bool + { additional > self.capacity().wrapping_sub(len) } - fn set_ptr_and_cap(&mut self, ptr: NonNull<[u8]>, cap: usize) { + fn set_ptr_and_cap(&mut self, ptr: NonNull<[u8]>, cap: usize) + { // Allocators currently return a `NonNull<[u8]>` whose length matches // the size requested. If that ever changes, the capacity here should // change to `ptr.len() / mem::size_of::()`. @@ -475,16 +490,19 @@ where memory.map_err(|_| AllocError { layout: new_layout, non_exhaustive: () }.into()) } -unsafe impl<#[may_dangle] T, A: Allocator> Drop for RawVec { +unsafe impl<#[may_dangle] T, A: Allocator> Drop for RawVec +where [(); alloc::co_alloc_metadata_num_slots::()]: +{ /// Frees the memory owned by the `RawVec` *without* trying to drop its contents. default fn drop(&mut self) { if let Some((ptr, layout)) = self.current_memory() { - unsafe { self.alloc.deallocate(ptr, layout) } + unsafe { self.alloc.co_deallocate(ptr, layout) } } } } -unsafe impl<#[may_dangle] T> Drop for RawVec { +// @TODO Custom +/*unsafe impl<#[may_dangle] T> Drop for RawVec { /// Frees the memory owned by the `RawVec` *without* trying to drop its contents. fn drop(&mut self) { // @TODO @@ -492,7 +510,7 @@ unsafe impl<#[may_dangle] T> Drop for RawVec { unsafe { self.alloc.deallocate(ptr, layout) } } } -} +}*/ // Central function for reserve error handling. #[cfg(not(no_global_oom_handling))] diff --git a/library/alloc/src/slice.rs b/library/alloc/src/slice.rs index fecacc2bb6395..f73e72b9c8360 100644 --- a/library/alloc/src/slice.rs +++ b/library/alloc/src/slice.rs @@ -97,7 +97,8 @@ 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(b: Box<[T], A>) -> Vec { + pub fn into_vec(b: Box<[T], A>) -> Vec + where [(); core::alloc::co_alloc_metadata_num_slots::()]: { unsafe { let len = b.len(); let (b, alloc) = Box::into_raw_with_allocator(b); @@ -107,7 +108,8 @@ pub(crate) mod hack { #[cfg(not(no_global_oom_handling))] #[inline] - pub fn to_vec(s: &[T], alloc: A) -> Vec { + pub fn to_vec(s: &[T], alloc: A) -> Vec + where [(); core::alloc::co_alloc_metadata_num_slots::()]: { T::to_vec(s, alloc) } @@ -115,13 +117,15 @@ pub(crate) mod hack { pub trait ConvertVec { fn to_vec(s: &[Self], alloc: A) -> Vec where - Self: Sized; + Self: Sized, + [(); core::alloc::co_alloc_metadata_num_slots::()]:; } #[cfg(not(no_global_oom_handling))] impl ConvertVec for T { #[inline] - default fn to_vec(s: &[Self], alloc: A) -> Vec { + default fn to_vec(s: &[Self], alloc: A) -> Vec + where [(); core::alloc::co_alloc_metadata_num_slots::()]: { struct DropGuard<'a, T, A: Allocator> { vec: &'a mut Vec, num_init: usize, @@ -158,7 +162,8 @@ pub(crate) mod hack { #[cfg(not(no_global_oom_handling))] impl ConvertVec for T { #[inline] - fn to_vec(s: &[Self], alloc: A) -> Vec { + fn to_vec(s: &[Self], alloc: A) -> Vec + where [(); core::alloc::co_alloc_metadata_num_slots::()]: { let mut v = Vec::with_capacity_in(s.len(), alloc); // SAFETY: // allocated above with the capacity of `s`, and initialize to `s.len()` in @@ -436,6 +441,7 @@ impl [T] { pub fn to_vec_in(&self, alloc: A) -> Vec where T: Clone, + [(); core::alloc::co_alloc_metadata_num_slots::()]: { // N.B., see the `hack` module in this file for more details. hack::to_vec(self, alloc) @@ -458,7 +464,8 @@ impl [T] { #[rustc_allow_incoherent_impl] #[stable(feature = "rust1", since = "1.0.0")] #[inline] - pub fn into_vec(self: Box) -> Vec { + pub fn into_vec(self: Box) -> Vec + where [(); core::alloc::co_alloc_metadata_num_slots::()]: { // N.B., see the `hack` module in this file for more details. hack::into_vec(self) } @@ -769,14 +776,16 @@ impl> Join<&[T]> for [V] { //////////////////////////////////////////////////////////////////////////////// #[stable(feature = "rust1", since = "1.0.0")] -impl Borrow<[T]> for Vec { +impl Borrow<[T]> for Vec +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { fn borrow(&self) -> &[T] { &self[..] } } #[stable(feature = "rust1", since = "1.0.0")] -impl BorrowMut<[T]> for Vec { +impl BorrowMut<[T]> for Vec +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { fn borrow_mut(&mut self) -> &mut [T] { &mut self[..] } diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs index 36b0b3c9e7cc0..bc3b223272007 100644 --- a/library/alloc/src/vec/mod.rs +++ b/library/alloc/src/vec/mod.rs @@ -397,11 +397,27 @@ mod spec_extend; #[stable(feature = "rust1", since = "1.0.0")] #[cfg_attr(not(test), rustc_diagnostic_item = "Vec")] #[rustc_insignificant_dtor] -pub struct Vec { - buf: RawVec, +// @TODO _coop +pub struct Vec +where [(); core::alloc::co_alloc_metadata_num_slots::()]: +{ + buf: RawVec, len: usize, } +#[unstable(feature = "global_co_alloc_vec", issue = "none")] +pub type CoVec = Vec; + +/// "Plain" Vec. +#[unstable(feature = "global_co_alloc_vec", issue = "none")] +pub type PlVec = Vec; + +/// "Weighted" Vec. +/// weight means how much it wants to cooperate. 0 = always pack; u8::MAX = always coop (if `Global` supports it). +/// @TODO Weighing on the side of Allocator - const fn. +#[unstable(feature = "global_co_alloc_vec", issue = "none")] +pub type WeVec = Vec1}>; + //////////////////////////////////////////////////////////////////////////////// // Inherent methods //////////////////////////////////////////////////////////////////////////////// @@ -593,7 +609,8 @@ impl Vec { } } -impl Vec { +impl Vec +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { /// Constructs a new, empty `Vec`. /// /// The vector will not allocate until elements are pushed onto it. @@ -1606,14 +1623,16 @@ impl Vec { // 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> { + struct BackshiftOnDrop<'a, T, A: Allocator> + where [(); core::alloc::co_alloc_metadata_num_slots::()]: { v: &'a mut Vec, processed_len: usize, deleted_cnt: usize, original_len: usize, } - impl Drop for BackshiftOnDrop<'_, T, A> { + impl Drop for BackshiftOnDrop<'_, T, A> + where [(); core::alloc::co_alloc_metadata_num_slots::()]: { fn drop(&mut self) { if self.deleted_cnt > 0 { // SAFETY: Trailing unchecked items must be valid since we never touch them. @@ -1640,6 +1659,7 @@ impl Vec { g: &mut BackshiftOnDrop<'_, T, A>, ) where F: FnMut(&mut T) -> bool, + [(); core::alloc::co_alloc_metadata_num_slots::()]: { while g.processed_len != original_len { // SAFETY: Unchecked element must be valid. @@ -1732,7 +1752,8 @@ impl Vec { } /* INVARIANT: vec.len() > read >= write > write-1 >= 0 */ - struct FillGapOnDrop<'a, T, A: core::alloc::Allocator> { + struct FillGapOnDrop<'a, T, A: core::alloc::Allocator> + where [(); core::alloc::co_alloc_metadata_num_slots::()]: { /* Offset of the element we want to check if it is duplicate */ read: usize, @@ -1744,7 +1765,8 @@ impl Vec { vec: &'a mut Vec, } - impl<'a, T, A: core::alloc::Allocator> Drop for FillGapOnDrop<'a, T, A> { + impl<'a, T, A: core::alloc::Allocator> Drop for FillGapOnDrop<'a, T, A> + where [(); core::alloc::co_alloc_metadata_num_slots::()]: { fn drop(&mut self) { /* This code gets executed when `same_bucket` panics */ @@ -2337,7 +2359,8 @@ impl Vec { } } -impl Vec { +impl Vec +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { /// 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 +2459,8 @@ impl Vec { } } -impl Vec<[T; N], A> { +impl Vec<[T; N], A> +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { /// Takes a `Vec<[T; N]>` and flattens it into a `Vec`. /// /// # Panics @@ -2497,7 +2521,8 @@ impl ExtendWith for ExtendElement { } } -impl Vec { +impl Vec +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { #[cfg(not(no_global_oom_handling))] /// Extend the vector by `n` values, using the given generator. fn extend_with>(&mut self, n: usize, mut value: E) { @@ -2529,7 +2554,8 @@ impl Vec { } } -impl Vec { +impl Vec +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { /// Removes consecutive repeated elements in the vector according to the /// [`PartialEq`] trait implementation. /// @@ -2565,7 +2591,8 @@ pub fn from_elem(elem: T, n: usize) -> Vec { #[doc(hidden)] #[cfg(not(no_global_oom_handling))] #[unstable(feature = "allocator_api", issue = "32838")] -pub fn from_elem_in(elem: T, n: usize, alloc: A) -> Vec { +pub fn from_elem_in(elem: T, n: usize, alloc: A) -> Vec +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { ::from_elem(elem, n, alloc) } @@ -2577,7 +2604,8 @@ trait ExtendFromWithinSpec { unsafe fn spec_extend_from_within(&mut self, src: Range); } -impl ExtendFromWithinSpec for Vec { +impl ExtendFromWithinSpec for Vec +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { default unsafe fn spec_extend_from_within(&mut self, src: Range) { // SAFETY: // - len is increased only after initializing elements @@ -2596,7 +2624,8 @@ impl ExtendFromWithinSpec for Vec { } } -impl ExtendFromWithinSpec for Vec { +impl ExtendFromWithinSpec for Vec +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { unsafe fn spec_extend_from_within(&mut self, src: Range) { let count = src.len(); { @@ -2629,7 +2658,8 @@ impl ExtendFromWithinSpec for Vec { //////////////////////////////////////////////////////////////////////////////// #[stable(feature = "rust1", since = "1.0.0")] -impl ops::Deref for Vec { +impl ops::Deref for Vec +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { type Target = [T]; #[inline] @@ -2639,7 +2669,8 @@ impl ops::Deref for Vec { } #[stable(feature = "rust1", since = "1.0.0")] -impl ops::DerefMut for Vec { +impl ops::DerefMut for Vec +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { #[inline] fn deref_mut(&mut self) -> &mut [T] { unsafe { slice::from_raw_parts_mut(self.as_mut_ptr(), self.len) } @@ -2652,7 +2683,8 @@ trait SpecCloneFrom { } #[cfg(not(no_global_oom_handling))] -impl SpecCloneFrom for Vec { +impl SpecCloneFrom for Vec +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { default fn clone_from(this: &mut Self, other: &Self) { // drop anything that will not be overwritten this.truncate(other.len()); @@ -2668,7 +2700,8 @@ impl SpecCloneFrom for Vec { } #[cfg(not(no_global_oom_handling))] -impl SpecCloneFrom for Vec { +impl SpecCloneFrom for Vec +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { fn clone_from(this: &mut Self, other: &Self) { this.clear(); this.extend_from_slice(other); @@ -2677,7 +2710,8 @@ impl SpecCloneFrom for Vec { #[cfg(not(no_global_oom_handling))] #[stable(feature = "rust1", since = "1.0.0")] -impl Clone for Vec { +impl Clone for Vec +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { #[cfg(not(test))] fn clone(&self) -> Self { let alloc = self.allocator().clone(); @@ -2712,7 +2746,8 @@ impl Clone for Vec { /// assert_eq!(b.hash_one(v), b.hash_one(s)); /// ``` #[stable(feature = "rust1", since = "1.0.0")] -impl Hash for Vec { +impl Hash for Vec +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { #[inline] fn hash(&self, state: &mut H) { Hash::hash(&**self, state) @@ -2724,7 +2759,8 @@ impl Hash for Vec { message = "vector indices are of type `usize` or ranges of `usize`", label = "vector indices are of type `usize` or ranges of `usize`" )] -impl, A: Allocator> Index for Vec { +impl, A: Allocator> Index for Vec +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { type Output = I::Output; #[inline] diff --git a/library/alloc/tests/boxed.rs b/library/alloc/tests/boxed.rs index af49826ff30a3..c34e7a558061d 100644 --- a/library/alloc/tests/boxed.rs +++ b/library/alloc/tests/boxed.rs @@ -61,6 +61,7 @@ fn box_deref_lval() { pub struct ConstAllocator; +//@TODO unsafe impl const Allocator for ConstAllocator { fn allocate(&self, layout: Layout) -> Result, AllocError> { match layout.size() { From 0db8c6f9069b9bb7663ded30a2d4381c7b367ae0 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sat, 21 Jan 2023 15:59:10 -0800 Subject: [PATCH 06/80] CoAlloc: VecDeque (PROBABLY NOT COMPILING, standard error) --- .../alloc/src/collections/vec_deque/macros.rs | 1 + .../alloc/src/collections/vec_deque/mod.rs | 72 +++++++++++++------ 2 files changed, 50 insertions(+), 23 deletions(-) diff --git a/library/alloc/src/collections/vec_deque/macros.rs b/library/alloc/src/collections/vec_deque/macros.rs index 5c7913073fe87..f7768f54c6225 100644 --- a/library/alloc/src/collections/vec_deque/macros.rs +++ b/library/alloc/src/collections/vec_deque/macros.rs @@ -4,6 +4,7 @@ macro_rules! __impl_slice_eq1 { impl PartialEq<$rhs> for $lhs where T: PartialEq, + [(); core::alloc::co_alloc_metadata_num_slots::()]:, $($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..f76cbb0b17904 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. -#![stable(feature = "rust1", since = "1.0.0")] +#![feature(global_co_alloc)] +#![stable(feature = "rust1", since = "1.0.0")] +use core::alloc; use core::cmp::{self, Ordering}; use core::fmt; use core::hash::{Hash, Hasher}; @@ -91,10 +93,13 @@ mod tests; #[cfg_attr(not(test), rustc_diagnostic_item = "VecDeque")] #[stable(feature = "rust1", since = "1.0.0")] #[rustc_insignificant_dtor] +// @TODO pub struct VecDeque< T, #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global, -> { +> +where [(); alloc::co_alloc_metadata_num_slots::()]: +{ // `self[0]`, if it exists, is `buf[head]`. // `head < buf.capacity()`, unless `buf.capacity() == 0` when `head == 0`. head: usize, @@ -106,7 +111,8 @@ pub struct VecDeque< } #[stable(feature = "rust1", since = "1.0.0")] -impl Clone for VecDeque { +impl Clone for VecDeque +where [(); alloc::co_alloc_metadata_num_slots::()]: { fn clone(&self) -> Self { let mut deq = Self::with_capacity_in(self.len(), self.allocator().clone()); deq.extend(self.iter().cloned()); @@ -120,7 +126,8 @@ impl Clone for VecDeque { } #[stable(feature = "rust1", since = "1.0.0")] -unsafe impl<#[may_dangle] T, A: Allocator> Drop for VecDeque { +unsafe impl<#[may_dangle] T, A: Allocator> Drop for VecDeque +where [(); alloc::co_alloc_metadata_num_slots::()]: { fn drop(&mut self) { /// Runs the destructor for all items in the slice when it gets dropped (normally or /// during unwinding). @@ -153,7 +160,8 @@ impl Default for VecDeque { } } -impl VecDeque { +impl VecDeque +where [(); alloc::co_alloc_metadata_num_slots::()]: { /// Marginally more convenient #[inline] fn ptr(&self) -> *mut T { @@ -442,7 +450,8 @@ impl VecDeque { mut iter: impl Iterator, len: usize, ) -> usize { - struct Guard<'a, T, A: Allocator> { + struct Guard<'a, T, A: Allocator> + where [(); alloc::co_alloc_metadata_num_slots::()]: { deque: &'a mut VecDeque, written: usize, } @@ -561,7 +570,8 @@ impl VecDeque { } } -impl VecDeque { +impl VecDeque +where [(); alloc::co_alloc_metadata_num_slots::()]: { /// Creates an empty deque. /// /// # Examples @@ -2596,7 +2606,8 @@ impl VecDeque { } } -impl VecDeque { +impl VecDeque +where [(); alloc::co_alloc_metadata_num_slots::()]: { /// 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 +2652,8 @@ fn wrap_index(logical_index: usize, capacity: usize) -> usize { } #[stable(feature = "rust1", since = "1.0.0")] -impl PartialEq for VecDeque { +impl PartialEq for VecDeque +where [(); alloc::co_alloc_metadata_num_slots::()]: { fn eq(&self, other: &Self) -> bool { if self.len != other.len() { return false; @@ -2680,7 +2692,8 @@ impl PartialEq for VecDeque { } #[stable(feature = "rust1", since = "1.0.0")] -impl Eq for VecDeque {} +impl Eq for VecDeque +where [(); alloc::co_alloc_metadata_num_slots::()]: {} __impl_slice_eq1! { [] VecDeque, Vec, } __impl_slice_eq1! { [] VecDeque, &[U], } @@ -2690,14 +2703,16 @@ __impl_slice_eq1! { [const N: usize] VecDeque, &[U; N], } __impl_slice_eq1! { [const N: usize] VecDeque, &mut [U; N], } #[stable(feature = "rust1", since = "1.0.0")] -impl PartialOrd for VecDeque { +impl PartialOrd for VecDeque +where [(); alloc::co_alloc_metadata_num_slots::()]: { fn partial_cmp(&self, other: &Self) -> Option { self.iter().partial_cmp(other.iter()) } } #[stable(feature = "rust1", since = "1.0.0")] -impl Ord for VecDeque { +impl Ord for VecDeque +where [(); alloc::co_alloc_metadata_num_slots::()]: { #[inline] fn cmp(&self, other: &Self) -> Ordering { self.iter().cmp(other.iter()) @@ -2705,7 +2720,8 @@ impl Ord for VecDeque { } #[stable(feature = "rust1", since = "1.0.0")] -impl Hash for VecDeque { +impl Hash for VecDeque +where [(); alloc::co_alloc_metadata_num_slots::()]: { fn hash(&self, state: &mut H) { state.write_length_prefix(self.len); // It's not possible to use Hash::hash_slice on slices @@ -2719,7 +2735,8 @@ impl Hash for VecDeque { } #[stable(feature = "rust1", since = "1.0.0")] -impl Index for VecDeque { +impl Index for VecDeque +where [(); alloc::co_alloc_metadata_num_slots::()]: { type Output = T; #[inline] @@ -2729,7 +2746,8 @@ impl Index for VecDeque { } #[stable(feature = "rust1", since = "1.0.0")] -impl IndexMut for VecDeque { +impl IndexMut for VecDeque +where [(); alloc::co_alloc_metadata_num_slots::()]: { #[inline] fn index_mut(&mut self, index: usize) -> &mut T { self.get_mut(index).expect("Out of bounds access") @@ -2744,7 +2762,8 @@ impl FromIterator for VecDeque { } #[stable(feature = "rust1", since = "1.0.0")] -impl IntoIterator for VecDeque { +impl IntoIterator for VecDeque +where [(); alloc::co_alloc_metadata_num_slots::()]: { type Item = T; type IntoIter = IntoIter; @@ -2756,7 +2775,8 @@ impl IntoIterator for VecDeque { } #[stable(feature = "rust1", since = "1.0.0")] -impl<'a, T, A: Allocator> IntoIterator for &'a VecDeque { +impl<'a, T, A: Allocator> IntoIterator for &'a VecDeque +where [(); alloc::co_alloc_metadata_num_slots::()]: { type Item = &'a T; type IntoIter = Iter<'a, T>; @@ -2766,7 +2786,8 @@ impl<'a, T, A: Allocator> IntoIterator for &'a VecDeque { } #[stable(feature = "rust1", since = "1.0.0")] -impl<'a, T, A: Allocator> IntoIterator for &'a mut VecDeque { +impl<'a, T, A: Allocator> IntoIterator for &'a mut VecDeque +where [(); alloc::co_alloc_metadata_num_slots::()]: { type Item = &'a mut T; type IntoIter = IterMut<'a, T>; @@ -2776,7 +2797,8 @@ impl<'a, T, A: Allocator> IntoIterator for &'a mut VecDeque { } #[stable(feature = "rust1", since = "1.0.0")] -impl Extend for VecDeque { +impl Extend for VecDeque +where [(); alloc::co_alloc_metadata_num_slots::()]: { fn extend>(&mut self, iter: I) { >::spec_extend(self, iter.into_iter()); } @@ -2793,7 +2815,8 @@ impl Extend for VecDeque { } #[stable(feature = "extend_ref", since = "1.2.0")] -impl<'a, T: 'a + Copy, A: Allocator> Extend<&'a T> for VecDeque { +impl<'a, T: 'a + Copy, A: Allocator> Extend<&'a T> for VecDeque +where [(); alloc::co_alloc_metadata_num_slots::()]: { fn extend>(&mut self, iter: I) { self.spec_extend(iter.into_iter()); } @@ -2810,14 +2833,16 @@ impl<'a, T: 'a + Copy, A: Allocator> Extend<&'a T> for VecDeque { } #[stable(feature = "rust1", since = "1.0.0")] -impl fmt::Debug for VecDeque { +impl fmt::Debug for VecDeque +where [(); alloc::co_alloc_metadata_num_slots::()]: { 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 From> for VecDeque { +impl From> for VecDeque +where [(); alloc::co_alloc_metadata_num_slots::()]: { /// Turn a [`Vec`] into a [`VecDeque`]. /// /// [`Vec`]: crate::vec::Vec @@ -2834,7 +2859,8 @@ impl From> for VecDeque { } #[stable(feature = "vecdeque_vec_conversions", since = "1.10.0")] -impl From> for Vec { +impl From> for Vec +where [(); alloc::co_alloc_metadata_num_slots::()]: { /// Turn a [`VecDeque`] into a [`Vec`]. /// /// [`Vec`]: crate::vec::Vec From 1e4e3ee9a67a8e49d569c787bc000683733277cd Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sat, 21 Jan 2023 16:01:50 -0800 Subject: [PATCH 07/80] CoAlloc: RawVec + Vec with COOP_PREFERRED. PROBABLY NOT COMPILING, but no ICE. --- library/alloc/src/lib.rs | 7 ++- library/alloc/src/slice.rs | 6 ++- library/alloc/src/vec/drain.rs | 44 ++++++++++++------- library/alloc/src/vec/drain_filter.rs | 9 +++- library/alloc/src/vec/into_iter.rs | 58 ++++++++++++++++--------- library/alloc/src/vec/mod.rs | 57 ++++++++++++++++-------- library/alloc/src/vec/partial_eq.rs | 1 + library/alloc/src/vec/spec_extend.rs | 8 +++- library/alloc/src/vec/spec_from_elem.rs | 16 ++++--- library/alloc/src/vec/splice.rs | 19 +++++--- 10 files changed, 154 insertions(+), 71 deletions(-) diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs index 5f98be5219384..f592a1fbd865d 100644 --- a/library/alloc/src/lib.rs +++ b/library/alloc/src/lib.rs @@ -184,7 +184,12 @@ #![feature(global_co_alloc)] #![feature(hashmap_internals)] #![feature(lang_items)] -#![feature(min_specialization)] +// 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::()` can be evaluated` +// - cannot specialize on predicate `[(); _] well-formed` +// - cannot specialize on predicate `the constant `core::alloc::co_alloc_metadata_num_slots::()` can be evaluated` +//#![feature(min_specialization)] +#![feature(specialization)] #![feature(negative_impls)] #![feature(never_type)] #![feature(rustc_allow_const_fn_unstable)] diff --git a/library/alloc/src/slice.rs b/library/alloc/src/slice.rs index f73e72b9c8360..aabd7178e513b 100644 --- a/library/alloc/src/slice.rs +++ b/library/alloc/src/slice.rs @@ -126,11 +126,13 @@ pub(crate) mod hack { #[inline] default fn to_vec(s: &[Self], alloc: A) -> Vec where [(); core::alloc::co_alloc_metadata_num_slots::()]: { - struct DropGuard<'a, T, A: Allocator> { + struct DropGuard<'a, T, A: Allocator> + where [(); core::alloc::co_alloc_metadata_num_slots::()]: { vec: &'a mut Vec, num_init: usize, } - impl<'a, T, A: Allocator> Drop for DropGuard<'a, T, A> { + impl<'a, T, A: Allocator> Drop for DropGuard<'a, T, A> + where [(); core::alloc::co_alloc_metadata_num_slots::()]: { #[inline] fn drop(&mut self) { // SAFETY: diff --git a/library/alloc/src/vec/drain.rs b/library/alloc/src/vec/drain.rs index 2b1a787cc5499..279488fd03450 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; @@ -23,7 +23,8 @@ pub struct Drain< 'a, T: 'a, #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator + 'a = Global, -> { +> +where [(); alloc::co_alloc_metadata_num_slots::()]: { /// Index of tail to preserve pub(super) tail_start: usize, /// Length of tail @@ -34,13 +35,15 @@ pub struct Drain< } #[stable(feature = "collection_debug", since = "1.17.0")] -impl fmt::Debug for Drain<'_, T, A> { +impl fmt::Debug for Drain<'_, T, A> +where [(); alloc::co_alloc_metadata_num_slots::()]: { 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> Drain<'a, T, A> +where [(); alloc::co_alloc_metadata_num_slots::()]: { /// Returns the remaining items of this iterator as a slice. /// /// # Examples @@ -139,19 +142,23 @@ 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> AsRef<[T]> for Drain<'a, T, A> +where [(); alloc::co_alloc_metadata_num_slots::()]: { fn as_ref(&self) -> &[T] { self.as_slice() } } #[stable(feature = "drain", since = "1.6.0")] -unsafe impl Sync for Drain<'_, T, A> {} +unsafe impl Sync for Drain<'_, T, A> +where [(); alloc::co_alloc_metadata_num_slots::()]: {} #[stable(feature = "drain", since = "1.6.0")] -unsafe impl Send for Drain<'_, T, A> {} +unsafe impl Send for Drain<'_, T, A> +where [(); alloc::co_alloc_metadata_num_slots::()]: {} #[stable(feature = "drain", since = "1.6.0")] -impl Iterator for Drain<'_, T, A> { +impl Iterator for Drain<'_, T, A> +where [(); alloc::co_alloc_metadata_num_slots::()]: { type Item = T; #[inline] @@ -165,7 +172,8 @@ impl Iterator for Drain<'_, T, A> { } #[stable(feature = "drain", since = "1.6.0")] -impl DoubleEndedIterator for Drain<'_, T, A> { +impl DoubleEndedIterator for Drain<'_, T, A> +where [(); alloc::co_alloc_metadata_num_slots::()]: { #[inline] fn next_back(&mut self) -> Option { self.iter.next_back().map(|elt| unsafe { ptr::read(elt as *const _) }) @@ -173,12 +181,15 @@ impl DoubleEndedIterator for Drain<'_, T, A> { } #[stable(feature = "drain", since = "1.6.0")] -impl Drop for Drain<'_, T, A> { +impl Drop for Drain<'_, T, A> +where [(); alloc::co_alloc_metadata_num_slots::()]: { 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>); + struct DropGuard<'r, 'a, T, A: Allocator>(&'r mut Drain<'a, T, A>) + where [(); alloc::co_alloc_metadata_num_slots::()]: ; - impl<'r, 'a, T, A: Allocator> Drop for DropGuard<'r, 'a, T, A> { + impl<'r, 'a, T, A: Allocator> Drop for DropGuard<'r, 'a, T, A> + where [(); alloc::co_alloc_metadata_num_slots::()]: { fn drop(&mut self) { if self.0.tail_len > 0 { unsafe { @@ -242,14 +253,17 @@ impl Drop for Drain<'_, T, A> { } #[stable(feature = "drain", since = "1.6.0")] -impl ExactSizeIterator for Drain<'_, T, A> { +impl ExactSizeIterator for Drain<'_, T, A> +where [(); alloc::co_alloc_metadata_num_slots::()]: { fn is_empty(&self) -> bool { self.iter.is_empty() } } #[unstable(feature = "trusted_len", issue = "37572")] -unsafe impl TrustedLen for Drain<'_, T, A> {} +unsafe impl TrustedLen for Drain<'_, T, A> +where [(); alloc::co_alloc_metadata_num_slots::()]: {} #[stable(feature = "fused", since = "1.26.0")] -impl FusedIterator for Drain<'_, T, A> {} +impl FusedIterator for Drain<'_, T, A> +where [(); alloc::co_alloc_metadata_num_slots::()]: {} diff --git a/library/alloc/src/vec/drain_filter.rs b/library/alloc/src/vec/drain_filter.rs index 8c03f1692d940..d78a81b647d5b 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; @@ -27,6 +26,7 @@ pub struct DrainFilter< #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global, > where F: FnMut(&mut T) -> bool, + [(); alloc::co_alloc_metadata_num_slots::()]: { pub(super) vec: &'a mut Vec, /// The index of the item that will be inspected by the next call to `next`. @@ -48,6 +48,7 @@ pub struct DrainFilter< impl DrainFilter<'_, T, F, A> where F: FnMut(&mut T) -> bool, + [(); alloc::co_alloc_metadata_num_slots::()]: { /// Returns a reference to the underlying allocator. #[unstable(feature = "allocator_api", issue = "32838")] @@ -116,6 +117,7 @@ where impl Iterator for DrainFilter<'_, T, F, A> where F: FnMut(&mut T) -> bool, + [(); alloc::co_alloc_metadata_num_slots::()]: { type Item = T; @@ -154,11 +156,13 @@ where impl Drop for DrainFilter<'_, T, F, A> where F: FnMut(&mut T) -> bool, + [(); alloc::co_alloc_metadata_num_slots::()]: { fn drop(&mut self) { struct BackshiftOnDrop<'a, 'b, T, F, A: Allocator> where F: FnMut(&mut T) -> bool, + [(); alloc::co_alloc_metadata_num_slots::()]: { drain: &'b mut DrainFilter<'a, T, F, A>, } @@ -166,6 +170,7 @@ where impl<'a, 'b, T, F, A: Allocator> Drop for BackshiftOnDrop<'a, 'b, T, F, A> where F: FnMut(&mut T) -> bool, + [(); alloc::co_alloc_metadata_num_slots::()]: { fn drop(&mut self) { unsafe { diff --git a/library/alloc/src/vec/into_iter.rs b/library/alloc/src/vec/into_iter.rs index 37966007eb7e4..6c43afd3aeb0e 100644 --- a/library/alloc/src/vec/into_iter.rs +++ b/library/alloc/src/vec/into_iter.rs @@ -4,8 +4,7 @@ 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::{alloc, array, fmt}; use core::iter::{ FusedIterator, InPlaceIterable, SourceIter, TrustedLen, TrustedRandomAccessNoCoerce, }; @@ -32,7 +31,8 @@ use core::slice::{self}; pub struct IntoIter< T, #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global, -> { +> +where [(); alloc::co_alloc_metadata_num_slots::()]: { pub(super) buf: NonNull, pub(super) phantom: PhantomData, pub(super) cap: usize, @@ -46,13 +46,15 @@ pub struct IntoIter< } #[stable(feature = "vec_intoiter_debug", since = "1.13.0")] -impl fmt::Debug for IntoIter { +impl fmt::Debug for IntoIter +where [(); alloc::co_alloc_metadata_num_slots::()]: { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_tuple("IntoIter").field(&self.as_slice()).finish() } } -impl IntoIter { +impl IntoIter +where [(); alloc::co_alloc_metadata_num_slots::()]: { /// Returns the remaining items of this iterator as a slice. /// /// # Examples @@ -141,7 +143,8 @@ impl IntoIter { #[cfg(not(no_global_oom_handling))] #[inline] - pub(crate) fn into_vecdeque(self) -> VecDeque { + pub(crate) fn into_vecdeque(self) -> VecDeque + where [(); alloc::co_alloc_metadata_num_slots::()]: { // Keep our `Drop` impl from dropping the elements and the allocator let mut this = ManuallyDrop::new(self); @@ -168,19 +171,23 @@ impl IntoIter { } #[stable(feature = "vec_intoiter_as_ref", since = "1.46.0")] -impl AsRef<[T]> for IntoIter { +impl AsRef<[T]> for IntoIter +where [(); alloc::co_alloc_metadata_num_slots::()]: { fn as_ref(&self) -> &[T] { self.as_slice() } } #[stable(feature = "rust1", since = "1.0.0")] -unsafe impl Send for IntoIter {} +unsafe impl Send for IntoIter +where [(); alloc::co_alloc_metadata_num_slots::()]: {} #[stable(feature = "rust1", since = "1.0.0")] -unsafe impl Sync for IntoIter {} +unsafe impl Sync for IntoIter +where [(); alloc::co_alloc_metadata_num_slots::()]: {} #[stable(feature = "rust1", since = "1.0.0")] -impl Iterator for IntoIter { +impl Iterator for IntoIter +where [(); alloc::co_alloc_metadata_num_slots::()]: { type Item = T; #[inline] @@ -294,7 +301,8 @@ impl Iterator for IntoIter { } #[stable(feature = "rust1", since = "1.0.0")] -impl DoubleEndedIterator for IntoIter { +impl DoubleEndedIterator for IntoIter +where [(); alloc::co_alloc_metadata_num_slots::()]: { #[inline] fn next_back(&mut self) -> Option { if self.end == self.ptr { @@ -335,17 +343,20 @@ impl DoubleEndedIterator for IntoIter { } #[stable(feature = "rust1", since = "1.0.0")] -impl ExactSizeIterator for IntoIter { +impl ExactSizeIterator for IntoIter +where [(); alloc::co_alloc_metadata_num_slots::()]: { fn is_empty(&self) -> bool { self.ptr == self.end } } #[stable(feature = "fused", since = "1.26.0")] -impl FusedIterator for IntoIter {} +impl FusedIterator for IntoIter +where [(); alloc::co_alloc_metadata_num_slots::()]: {} #[unstable(feature = "trusted_len", issue = "37572")] -unsafe impl TrustedLen for IntoIter {} +unsafe impl TrustedLen for IntoIter +where [(); alloc::co_alloc_metadata_num_slots::()]: {} #[doc(hidden)] #[unstable(issue = "none", feature = "std_internals")] @@ -364,13 +375,15 @@ impl NonDrop for T {} unsafe impl TrustedRandomAccessNoCoerce for IntoIter where T: NonDrop, + [(); alloc::co_alloc_metadata_num_slots::()]: { const MAY_HAVE_SIDE_EFFECT: bool = false; } #[cfg(not(no_global_oom_handling))] #[stable(feature = "vec_into_iter_clone", since = "1.8.0")] -impl Clone for IntoIter { +impl Clone for IntoIter +where [(); alloc::co_alloc_metadata_num_slots::()]: { #[cfg(not(test))] fn clone(&self) -> Self { self.as_slice().to_vec_in(self.alloc.deref().clone()).into_iter() @@ -382,11 +395,14 @@ impl Clone for IntoIter { } #[stable(feature = "rust1", since = "1.0.0")] -unsafe impl<#[may_dangle] T, A: Allocator> Drop for IntoIter { +unsafe impl<#[may_dangle] T, A: Allocator> Drop for IntoIter +where [(); alloc::co_alloc_metadata_num_slots::()]: { fn drop(&mut self) { - struct DropGuard<'a, T, A: Allocator>(&'a mut IntoIter); + struct DropGuard<'a, T, A: Allocator>(&'a mut IntoIter) + where [(); alloc::co_alloc_metadata_num_slots::()]: ; - impl Drop for DropGuard<'_, T, A> { + impl Drop for DropGuard<'_, T, A> + where [(); alloc::co_alloc_metadata_num_slots::()]: { fn drop(&mut self) { unsafe { // `IntoIter::alloc` is not used anymore after this and will be dropped by RawVec @@ -410,11 +426,13 @@ unsafe impl<#[may_dangle] T, A: Allocator> Drop for IntoIter { // also refer to the vec::in_place_collect module documentation to get an overview #[unstable(issue = "none", feature = "inplace_iteration")] #[doc(hidden)] -unsafe impl InPlaceIterable for IntoIter {} +unsafe impl InPlaceIterable for IntoIter +where [(); alloc::co_alloc_metadata_num_slots::()]: {} #[unstable(issue = "none", feature = "inplace_iteration")] #[doc(hidden)] -unsafe impl SourceIter for IntoIter { +unsafe impl SourceIter for IntoIter +where [(); alloc::co_alloc_metadata_num_slots::()]: { type Source = Self; #[inline] diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs index bc3b223272007..9c7a278bf7207 100644 --- a/library/alloc/src/vec/mod.rs +++ b/library/alloc/src/vec/mod.rs @@ -2774,7 +2774,8 @@ where [(); core::alloc::co_alloc_metadata_num_slots::()]: { message = "vector indices are of type `usize` or ranges of `usize`", label = "vector indices are of type `usize` or ranges of `usize`" )] -impl, A: Allocator> IndexMut for Vec { +impl, A: Allocator> IndexMut for Vec +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { #[inline] fn index_mut(&mut self, index: I) -> &mut Self::Output { IndexMut::index_mut(&mut **self, index) @@ -2791,7 +2792,8 @@ impl FromIterator for Vec { } #[stable(feature = "rust1", since = "1.0.0")] -impl IntoIterator for Vec { +impl IntoIterator for Vec +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { type Item = T; type IntoIter = IntoIter; @@ -2836,7 +2838,8 @@ impl IntoIterator for Vec { } #[stable(feature = "rust1", since = "1.0.0")] -impl<'a, T, A: Allocator> IntoIterator for &'a Vec { +impl<'a, T, A: Allocator> IntoIterator for &'a Vec +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { type Item = &'a T; type IntoIter = slice::Iter<'a, T>; @@ -2846,7 +2849,8 @@ impl<'a, T, A: Allocator> IntoIterator for &'a Vec { } #[stable(feature = "rust1", since = "1.0.0")] -impl<'a, T, A: Allocator> IntoIterator for &'a mut Vec { +impl<'a, T, A: Allocator> IntoIterator for &'a mut Vec +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { type Item = &'a mut T; type IntoIter = slice::IterMut<'a, T>; @@ -2857,7 +2861,8 @@ impl<'a, T, A: Allocator> IntoIterator for &'a mut Vec { #[cfg(not(no_global_oom_handling))] #[stable(feature = "rust1", since = "1.0.0")] -impl Extend for Vec { +impl Extend for Vec +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { #[inline] fn extend>(&mut self, iter: I) { >::spec_extend(self, iter.into_iter()) @@ -2874,7 +2879,8 @@ impl Extend for Vec { } } -impl Vec { +impl Vec +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { // leaf method to which various SpecFrom/SpecExtend implementations delegate when // they have no further optimizations to apply #[cfg(not(no_global_oom_handling))] @@ -3048,7 +3054,8 @@ impl Vec { /// [`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 { +impl<'a, T: Copy + 'a, A: Allocator + 'a> Extend<&'a T> for Vec +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { fn extend>(&mut self, iter: I) { self.spec_extend(iter.into_iter()) } @@ -3066,7 +3073,8 @@ impl<'a, T: Copy + 'a, A: Allocator + 'a> Extend<&'a T> for Vec { /// Implements comparison of vectors, [lexicographically](core::cmp::Ord#lexicographical-comparison). #[stable(feature = "rust1", since = "1.0.0")] -impl PartialOrd for Vec { +impl PartialOrd for Vec +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { #[inline] fn partial_cmp(&self, other: &Self) -> Option { PartialOrd::partial_cmp(&**self, &**other) @@ -3074,11 +3082,13 @@ impl PartialOrd for Vec { } #[stable(feature = "rust1", since = "1.0.0")] -impl Eq for Vec {} +impl Eq for Vec +where [(); core::alloc::co_alloc_metadata_num_slots::()]: {} /// Implements ordering of vectors, [lexicographically](core::cmp::Ord#lexicographical-comparison). #[stable(feature = "rust1", since = "1.0.0")] -impl Ord for Vec { +impl Ord for Vec +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { #[inline] fn cmp(&self, other: &Self) -> Ordering { Ord::cmp(&**self, &**other) @@ -3086,7 +3096,8 @@ impl Ord for Vec { } #[stable(feature = "rust1", since = "1.0.0")] -unsafe impl<#[may_dangle] T, A: Allocator> Drop for Vec { +unsafe impl<#[may_dangle] T, A: Allocator> Drop for Vec +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { fn drop(&mut self) { unsafe { // use drop for [T] @@ -3110,35 +3121,40 @@ impl const Default for Vec { } #[stable(feature = "rust1", since = "1.0.0")] -impl fmt::Debug for Vec { +impl fmt::Debug for Vec +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fmt::Debug::fmt(&**self, f) } } #[stable(feature = "rust1", since = "1.0.0")] -impl AsRef> for Vec { +impl AsRef> for Vec +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { fn as_ref(&self) -> &Vec { self } } #[stable(feature = "vec_as_mut", since = "1.5.0")] -impl AsMut> for Vec { +impl AsMut> for Vec +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { fn as_mut(&mut self) -> &mut Vec { self } } #[stable(feature = "rust1", since = "1.0.0")] -impl AsRef<[T]> for Vec { +impl AsRef<[T]> for Vec +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { fn as_ref(&self) -> &[T] { self } } #[stable(feature = "vec_as_mut", since = "1.5.0")] -impl AsMut<[T]> for Vec { +impl AsMut<[T]> for Vec +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { fn as_mut(&mut self) -> &mut [T] { self } @@ -3235,7 +3251,8 @@ where // note: test pulls in std, which causes errors here #[cfg(not(test))] #[stable(feature = "vec_from_box", since = "1.18.0")] -impl From> for Vec { +impl From> for Vec +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { /// Convert a boxed slice into a vector by transferring ownership of /// the existing heap allocation. /// @@ -3254,7 +3271,8 @@ impl From> for Vec { #[cfg(not(no_global_oom_handling))] #[cfg(not(test))] #[stable(feature = "box_from_vec", since = "1.20.0")] -impl From> for Box<[T], A> { +impl From> for Box<[T], A> +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { /// Convert a vector into a boxed slice. /// /// If `v` has excess capacity, its items will be moved into a @@ -3294,7 +3312,8 @@ impl From<&str> for Vec { } #[stable(feature = "array_try_from_vec", since = "1.48.0")] -impl TryFrom> for [T; N] { +impl TryFrom> for [T; N] +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { type Error = Vec; /// Gets the entire contents of the `Vec` as an array, diff --git a/library/alloc/src/vec/partial_eq.rs b/library/alloc/src/vec/partial_eq.rs index b0cf72577a1be..b50b9673e1560 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; diff --git a/library/alloc/src/vec/spec_extend.rs b/library/alloc/src/vec/spec_extend.rs index 56065ce565bfc..81245a394b22e 100644 --- a/library/alloc/src/vec/spec_extend.rs +++ b/library/alloc/src/vec/spec_extend.rs @@ -1,3 +1,4 @@ +use core::alloc; use crate::alloc::Allocator; use core::iter::TrustedLen; use core::slice::{self}; @@ -12,6 +13,7 @@ pub(super) trait SpecExtend { impl SpecExtend for Vec where I: Iterator, + [(); alloc::co_alloc_metadata_num_slots::()]: { default fn spec_extend(&mut self, iter: I) { self.extend_desugared(iter) @@ -21,13 +23,15 @@ where impl SpecExtend for Vec where I: TrustedLen, + [(); alloc::co_alloc_metadata_num_slots::()]: { default fn spec_extend(&mut self, iterator: I) { self.extend_trusted(iterator) } } -impl SpecExtend> for Vec { +impl SpecExtend> for Vec +where [(); alloc::co_alloc_metadata_num_slots::()]: { fn spec_extend(&mut self, mut iterator: IntoIter) { unsafe { self.append_elements(iterator.as_slice() as _); @@ -40,6 +44,7 @@ impl<'a, T: 'a, I, A: Allocator + 'a> SpecExtend<&'a T, I> for Vec where I: Iterator, T: Clone, + [(); alloc::co_alloc_metadata_num_slots::()]: { default fn spec_extend(&mut self, iterator: I) { self.spec_extend(iterator.cloned()) @@ -49,6 +54,7 @@ where impl<'a, T: 'a, A: Allocator + 'a> SpecExtend<&'a T, slice::Iter<'a, T>> for Vec where T: Copy, + [(); alloc::co_alloc_metadata_num_slots::()]: { 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..7f95539b12d96 100644 --- a/library/alloc/src/vec/spec_from_elem.rs +++ b/library/alloc/src/vec/spec_from_elem.rs @@ -1,5 +1,6 @@ use core::ptr; +use core::alloc; use crate::alloc::Allocator; use crate::raw_vec::RawVec; @@ -7,11 +8,13 @@ use super::{ExtendElement, IsZero, Vec}; // Specialization trait used for Vec::from_elem pub(super) trait SpecFromElem: Sized { - fn from_elem(elem: Self, n: usize, alloc: A) -> Vec; + fn from_elem(elem: Self, n: usize, alloc: A) -> Vec + where [(); alloc::co_alloc_metadata_num_slots::()]: ; } impl SpecFromElem for T { - default fn from_elem(elem: Self, n: usize, alloc: A) -> Vec { + default fn from_elem(elem: Self, n: usize, alloc: A) -> Vec + where [(); alloc::co_alloc_metadata_num_slots::()]: { let mut v = Vec::with_capacity_in(n, alloc); v.extend_with(n, ExtendElement(elem)); v @@ -20,7 +23,8 @@ impl SpecFromElem for T { impl SpecFromElem for T { #[inline] - default fn from_elem(elem: T, n: usize, alloc: A) -> Vec { + default fn from_elem(elem: T, n: usize, alloc: A) -> Vec + where [(); alloc::co_alloc_metadata_num_slots::()]: { if elem.is_zero() { return Vec { buf: RawVec::with_capacity_zeroed_in(n, alloc), len: n }; } @@ -32,7 +36,8 @@ impl SpecFromElem for T { impl SpecFromElem for i8 { #[inline] - fn from_elem(elem: i8, n: usize, alloc: A) -> Vec { + fn from_elem(elem: i8, n: usize, alloc: A) -> Vec + where [(); alloc::co_alloc_metadata_num_slots::()]: { if elem == 0 { return Vec { buf: RawVec::with_capacity_zeroed_in(n, alloc), len: n }; } @@ -47,7 +52,8 @@ impl SpecFromElem for i8 { impl SpecFromElem for u8 { #[inline] - fn from_elem(elem: u8, n: usize, alloc: A) -> Vec { + fn from_elem(elem: u8, n: usize, alloc: A) -> Vec + where [(); alloc::co_alloc_metadata_num_slots::()]: { if elem == 0 { return Vec { buf: RawVec::with_capacity_zeroed_in(n, alloc), len: n }; } diff --git a/library/alloc/src/vec/splice.rs b/library/alloc/src/vec/splice.rs index 1861147fe72fb..631d9d5e3aa60 100644 --- a/library/alloc/src/vec/splice.rs +++ b/library/alloc/src/vec/splice.rs @@ -1,3 +1,4 @@ +use core::alloc; use crate::alloc::{Allocator, Global}; use core::ptr::{self}; use core::slice::{self}; @@ -22,13 +23,15 @@ pub struct Splice< 'a, I: Iterator + 'a, #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator + 'a = Global, -> { +> +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { pub(super) drain: Drain<'a, I::Item, A>, pub(super) replace_with: I, } #[stable(feature = "vec_splice", since = "1.21.0")] -impl Iterator for Splice<'_, I, A> { +impl Iterator for Splice<'_, I, A> +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { type Item = I::Item; fn next(&mut self) -> Option { @@ -41,17 +44,20 @@ impl Iterator for Splice<'_, I, A> { } #[stable(feature = "vec_splice", since = "1.21.0")] -impl DoubleEndedIterator for Splice<'_, I, A> { +impl DoubleEndedIterator for Splice<'_, I, A> +where [(); alloc::co_alloc_metadata_num_slots::()]: { fn next_back(&mut self) -> Option { self.drain.next_back() } } #[stable(feature = "vec_splice", since = "1.21.0")] -impl ExactSizeIterator for Splice<'_, I, A> {} +impl ExactSizeIterator for Splice<'_, I, A> +where [(); alloc::co_alloc_metadata_num_slots::()]: {} #[stable(feature = "vec_splice", since = "1.21.0")] -impl Drop for Splice<'_, I, A> { +impl Drop for Splice<'_, I, A> +where [(); alloc::co_alloc_metadata_num_slots::()]: { 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 +104,8 @@ impl Drop for Splice<'_, I, A> { } /// Private helper methods for `Splice::drop` -impl Drain<'_, T, A> { +impl Drain<'_, T, A> +where [(); alloc::co_alloc_metadata_num_slots::()]: { /// 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. From 8ae4cf055f9567a95a06969dffb790cb88e1080e Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sat, 21 Jan 2023 16:03:01 -0800 Subject: [PATCH 08/80] VecDeque with COOP_PREFERRED. PROBABLY NOT COMPILING, but no ICE. --- .../alloc/src/collections/vec_deque/drain.rs | 38 ++++++++++++------- .../src/collections/vec_deque/into_iter.rs | 26 ++++++++----- .../alloc/src/collections/vec_deque/mod.rs | 3 +- .../src/collections/vec_deque/spec_extend.rs | 13 ++++++- 4 files changed, 55 insertions(+), 25 deletions(-) diff --git a/library/alloc/src/collections/vec_deque/drain.rs b/library/alloc/src/collections/vec_deque/drain.rs index 89feb361ddc11..e4f2f80892504 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}; @@ -19,7 +19,8 @@ pub struct Drain< 'a, T: 'a, #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global, -> { +> +where [(); alloc::co_alloc_metadata_num_slots::()]: { // We can't just use a &mut VecDeque, as that would make Drain invariant over T // and we want it to be covariant instead deque: NonNull>, @@ -34,7 +35,8 @@ pub struct Drain< _marker: PhantomData<&'a T>, } -impl<'a, T, A: Allocator> Drain<'a, T, A> { +impl<'a, T, A: Allocator> Drain<'a, T, A> +where [(); alloc::co_alloc_metadata_num_slots::()]: { pub(super) unsafe fn new( deque: &'a mut VecDeque, drain_start: usize, @@ -88,7 +90,8 @@ impl<'a, T, A: Allocator> Drain<'a, T, A> { } #[stable(feature = "collection_debug", since = "1.17.0")] -impl fmt::Debug for Drain<'_, T, A> { +impl fmt::Debug for Drain<'_, T, A> +where [(); alloc::co_alloc_metadata_num_slots::()]: { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_tuple("Drain") .field(&self.drain_len) @@ -100,16 +103,21 @@ impl fmt::Debug for Drain<'_, T, A> { } #[stable(feature = "drain", since = "1.6.0")] -unsafe impl Sync for Drain<'_, T, A> {} +unsafe impl Sync for Drain<'_, T, A> +where [(); alloc::co_alloc_metadata_num_slots::()]: {} #[stable(feature = "drain", since = "1.6.0")] -unsafe impl Send for Drain<'_, T, A> {} +unsafe impl Send for Drain<'_, T, A> +where [(); alloc::co_alloc_metadata_num_slots::()]: {} #[stable(feature = "drain", since = "1.6.0")] -impl Drop for Drain<'_, T, A> { +impl Drop for Drain<'_, T, A> +where [(); alloc::co_alloc_metadata_num_slots::()]: { fn drop(&mut self) { - struct DropGuard<'r, 'a, T, A: Allocator>(&'r mut Drain<'a, T, A>); + struct DropGuard<'r, 'a, T, A: Allocator> (&'r mut Drain<'a, T, A>) + where [(); alloc::co_alloc_metadata_num_slots::()]:; - impl<'r, 'a, T, A: Allocator> Drop for DropGuard<'r, 'a, T, A> { + impl<'r, 'a, T, A: Allocator> Drop for DropGuard<'r, 'a, T, A> + where [(); alloc::co_alloc_metadata_num_slots::()]: { fn drop(&mut self) { if self.0.remaining != 0 { unsafe { @@ -190,7 +198,8 @@ impl Drop for Drain<'_, T, A> { } #[stable(feature = "drain", since = "1.6.0")] -impl Iterator for Drain<'_, T, A> { +impl Iterator for Drain<'_, T, A> +where [(); alloc::co_alloc_metadata_num_slots::()]: { type Item = T; #[inline] @@ -212,7 +221,8 @@ impl Iterator for Drain<'_, T, A> { } #[stable(feature = "drain", since = "1.6.0")] -impl DoubleEndedIterator for Drain<'_, T, A> { +impl DoubleEndedIterator for Drain<'_, T, A> +where [(); alloc::co_alloc_metadata_num_slots::()]: { #[inline] fn next_back(&mut self) -> Option { if self.remaining == 0 { @@ -225,7 +235,9 @@ impl DoubleEndedIterator for Drain<'_, T, A> { } #[stable(feature = "drain", since = "1.6.0")] -impl ExactSizeIterator for Drain<'_, T, A> {} +impl ExactSizeIterator for Drain<'_, T, A> +where [(); alloc::co_alloc_metadata_num_slots::()]: {} #[stable(feature = "fused", since = "1.26.0")] -impl FusedIterator for Drain<'_, T, A> {} +impl FusedIterator for Drain<'_, T, A> +where [(); alloc::co_alloc_metadata_num_slots::()]: {} diff --git a/library/alloc/src/collections/vec_deque/into_iter.rs b/library/alloc/src/collections/vec_deque/into_iter.rs index e54880e865230..18a1891a3f3ed 100644 --- a/library/alloc/src/collections/vec_deque/into_iter.rs +++ b/library/alloc/src/collections/vec_deque/into_iter.rs @@ -1,4 +1,4 @@ -use core::fmt; +use core::{alloc, fmt}; use core::iter::{FusedIterator, TrustedLen}; use crate::alloc::{Allocator, Global}; @@ -17,11 +17,13 @@ use super::VecDeque; pub struct IntoIter< T, #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global, -> { +> +where [(); alloc::co_alloc_metadata_num_slots::()]: { inner: VecDeque, } -impl IntoIter { +impl IntoIter +where [(); alloc::co_alloc_metadata_num_slots::()]: { pub(super) fn new(inner: VecDeque) -> Self { IntoIter { inner } } @@ -32,14 +34,16 @@ impl IntoIter { } #[stable(feature = "collection_debug", since = "1.17.0")] -impl fmt::Debug for IntoIter { +impl fmt::Debug for IntoIter +where [(); alloc::co_alloc_metadata_num_slots::()]: { 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 Iterator for IntoIter { +impl Iterator for IntoIter +where [(); alloc::co_alloc_metadata_num_slots::()]: { type Item = T; #[inline] @@ -55,7 +59,8 @@ impl Iterator for IntoIter { } #[stable(feature = "rust1", since = "1.0.0")] -impl DoubleEndedIterator for IntoIter { +impl DoubleEndedIterator for IntoIter +where [(); alloc::co_alloc_metadata_num_slots::()]: { #[inline] fn next_back(&mut self) -> Option { self.inner.pop_back() @@ -63,14 +68,17 @@ impl DoubleEndedIterator for IntoIter { } #[stable(feature = "rust1", since = "1.0.0")] -impl ExactSizeIterator for IntoIter { +impl ExactSizeIterator for IntoIter +where [(); alloc::co_alloc_metadata_num_slots::()]: { fn is_empty(&self) -> bool { self.inner.is_empty() } } #[stable(feature = "fused", since = "1.26.0")] -impl FusedIterator for IntoIter {} +impl FusedIterator for IntoIter +where [(); alloc::co_alloc_metadata_num_slots::()]: {} #[unstable(feature = "trusted_len", issue = "37572")] -unsafe impl TrustedLen for IntoIter {} +unsafe impl TrustedLen for IntoIter +where [(); alloc::co_alloc_metadata_num_slots::()]: {} diff --git a/library/alloc/src/collections/vec_deque/mod.rs b/library/alloc/src/collections/vec_deque/mod.rs index f76cbb0b17904..cd13039cf015f 100644 --- a/library/alloc/src/collections/vec_deque/mod.rs +++ b/library/alloc/src/collections/vec_deque/mod.rs @@ -456,7 +456,8 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { written: usize, } - impl<'a, T, A: Allocator> Drop for Guard<'a, T, A> { + impl<'a, T, A: Allocator> Drop for Guard<'a, T, A> + where [(); alloc::co_alloc_metadata_num_slots::()]: { fn drop(&mut self) { self.deque.len += self.written; } diff --git a/library/alloc/src/collections/vec_deque/spec_extend.rs b/library/alloc/src/collections/vec_deque/spec_extend.rs index dccf40ccb38aa..f6d957fdc03ba 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; @@ -13,6 +16,7 @@ pub(super) trait SpecExtend { impl SpecExtend for VecDeque where I: Iterator, + [(); alloc::co_alloc_metadata_num_slots::()]: { default fn spec_extend(&mut self, mut iter: I) { // This function should be the moral equivalent of: @@ -22,7 +26,8 @@ where // } // May only be called if `deque.len() < deque.capacity()` - unsafe fn push_unchecked(deque: &mut VecDeque, element: T) { + unsafe fn push_unchecked(deque: &mut VecDeque, element: T) + where [(); alloc::co_alloc_metadata_num_slots::()]: { // 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) }; @@ -52,6 +57,7 @@ where impl SpecExtend for VecDeque where I: TrustedLen, + [(); alloc::co_alloc_metadata_num_slots::()]: { default fn spec_extend(&mut self, iter: I) { // This is the case for a TrustedLen iterator. @@ -84,7 +90,8 @@ where } } -impl SpecExtend> for VecDeque { +impl SpecExtend> for VecDeque +where [(); alloc::co_alloc_metadata_num_slots::()]: { fn spec_extend(&mut self, mut iterator: vec::IntoIter) { let slice = iterator.as_slice(); self.reserve(slice.len()); @@ -101,6 +108,7 @@ impl<'a, T: 'a, I, A: Allocator> SpecExtend<&'a T, I> for VecDeque where I: Iterator, T: Copy, + [(); alloc::co_alloc_metadata_num_slots::()]: { default fn spec_extend(&mut self, iterator: I) { self.spec_extend(iterator.copied()) @@ -110,6 +118,7 @@ where impl<'a, T: 'a, A: Allocator> SpecExtend<&'a T, slice::Iter<'a, T>> for VecDeque where T: Copy, + [(); alloc::co_alloc_metadata_num_slots::()]: { fn spec_extend(&mut self, iterator: slice::Iter<'a, T>) { let slice = iterator.as_slice(); From 37a08479b839a2e960169225c6e6d3230b8bd8ec Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sat, 21 Jan 2023 16:12:17 -0800 Subject: [PATCH 09/80] CoAlloc: RawVec, Vec, Box uses bounds. ICE --- library/alloc/src/boxed.rs | 15 ++- library/alloc/src/lib.rs | 1 + library/alloc/src/raw_vec.rs | 49 ++++---- library/alloc/src/slice.rs | 8 +- library/alloc/src/vec/drain.rs | 55 ++++---- library/alloc/src/vec/drain_filter.rs | 27 ++-- library/alloc/src/vec/into_iter.rs | 76 +++++------ library/alloc/src/vec/mod.rs | 174 +++++++++++++------------- library/alloc/src/vec/partial_eq.rs | 28 ++--- library/core/src/alloc/mod.rs | 11 ++ 10 files changed, 233 insertions(+), 211 deletions(-) diff --git a/library/alloc/src/boxed.rs b/library/alloc/src/boxed.rs index a563b2587236c..9dc695559a80e 100644 --- a/library/alloc/src/boxed.rs +++ b/library/alloc/src/boxed.rs @@ -146,6 +146,7 @@ #![stable(feature = "rust1", since = "1.0.0")] +use core::alloc; use core::any::Any; use core::async_iter::AsyncIterator; use core::borrow; @@ -698,7 +699,7 @@ impl 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::::from_raw_parts_in(ptr.as_mut_ptr() as *mut _, len, Global).into_box(len)) } } @@ -730,12 +731,13 @@ impl 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::::from_raw_parts_in(ptr.as_mut_ptr() as *mut _, len, Global).into_box(len)) } } } -impl Box<[T], A> { +impl Box<[T], A> +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { /// Constructs a new boxed slice with uninitialized contents in the provided allocator. /// /// # Examples @@ -763,7 +765,7 @@ impl Box<[T], A> { // #[unstable(feature = "new_uninit", issue = "63291")] #[must_use] pub fn new_uninit_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit], A> { - unsafe { RawVec::with_capacity_in(len, alloc).into_box(len) } + unsafe { RawVec::::with_capacity_in(len, alloc).into_box(len) } } /// Constructs a new boxed slice with uninitialized contents in the provided allocator, @@ -791,7 +793,7 @@ impl Box<[T], A> { // #[unstable(feature = "new_uninit", issue = "63291")] #[must_use] pub fn new_zeroed_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit], A> { - unsafe { RawVec::with_capacity_zeroed_in(len, alloc).into_box(len) } + unsafe { RawVec::::with_capacity_zeroed_in(len, alloc).into_box(len) } } } @@ -2019,7 +2021,8 @@ impl FromIterator for Box<[I]> { #[cfg(not(no_global_oom_handling))] #[stable(feature = "box_slice_clone", since = "1.3.0")] -impl Clone for Box<[T], A> { +impl Clone for Box<[T], A> +where [(); core::alloc::co_alloc_metadata_num_slots::()]: { fn clone(&self) -> Self { let alloc = Box::allocator(self).clone(); self.to_vec_in(alloc).into_boxed_slice() diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs index f592a1fbd865d..5d856158c206c 100644 --- a/library/alloc/src/lib.rs +++ b/library/alloc/src/lib.rs @@ -182,6 +182,7 @@ #![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)] // When we used min_specialization instead of specialization, library/alloc/src/vec/mod.rs was failing with: diff --git a/library/alloc/src/raw_vec.rs b/library/alloc/src/raw_vec.rs index 9cf96ac700f55..19f1ef0ac06e1 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::{self, LayoutError, GlobalCoAllocMeta}; +use core::alloc::{self, LayoutError, GlobalCoAllocMeta, PtrAndMeta}; use core::cmp; use core::intrinsics; use core::mem::{self, ManuallyDrop, MaybeUninit, SizedTypeProperties}; @@ -49,11 +49,9 @@ 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)] -// @TODO -// 1. make const generic _coop come from the target specification -// 2. apply `_coop` with logical && to `A::IsCoAllocator` -pub(crate) struct RawVec -where [(); alloc::co_alloc_metadata_num_slots::()]: +// @TODO apply `_coop` with logical && to `A::IsCoAllocator` +pub(crate) struct RawVec +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { ptr: Unique, cap: usize, @@ -61,7 +59,7 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: // As of v1.67.0, `cmp` for `TypeId` is not `const`, unfortunately: //pub(crate) meta: [GlobalCoAllocMeta; {if core::any::TypeId::of::()==core::any::TypeId::of::() {1} else {0}}], //pub(crate) meta: [GlobalCoAllocMeta; mem::size_of::()], - pub(crate) meta: [GlobalCoAllocMeta; alloc::co_alloc_metadata_num_slots::()], + pub(crate) metas: [GlobalCoAllocMeta; alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)], } impl RawVec { @@ -111,8 +109,8 @@ impl RawVec { } } -impl RawVec -where [(); alloc::co_alloc_metadata_num_slots::()]: +impl RawVec +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { // Tiny Vecs are dumb. Skip to: // - 8 if the element size is 1, because any heap allocators is likely @@ -131,7 +129,8 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: /// 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, meta: GlobalCoAllocMeta {/*one: 1*/ /* , two: 2, three: 3, four: 4*/} } + 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::(COOP_PREFERRED)] } } /// Like `with_capacity`, but parameterized over the choice of @@ -208,7 +207,7 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: ptr: unsafe { Unique::new_unchecked(ptr.cast().as_ptr()) }, cap: capacity, alloc, - meta: GlobalCoAllocMeta {/*one: 1*/ /*, two: 2, three: 3, four: 4*/} + metas: [GlobalCoAllocMeta {/*one: 1*/ /*, two: 2, three: 3, four: 4*/}; alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)] } } } @@ -225,7 +224,7 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: /// 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, meta: GlobalCoAllocMeta {/*one: 1*/ /*, two: 2, three: 3, four: 4*/} } + 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::(COOP_PREFERRED)] } } /// Gets a raw pointer to the start of the allocation. Note that this is @@ -289,12 +288,12 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: // 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( - slf: &mut RawVec, + fn do_reserve_and_handle( + slf: &mut RawVec, len: usize, additional: usize, ) - where [(); alloc::co_alloc_metadata_num_slots::()]: + where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { handle_reserve(slf.grow_amortized(len, additional)); } @@ -368,8 +367,8 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: } } -impl RawVec -where [(); alloc::co_alloc_metadata_num_slots::()]: +impl RawVec +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(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`. @@ -490,19 +489,25 @@ where memory.map_err(|_| AllocError { layout: new_layout, non_exhaustive: () }.into()) } -unsafe impl<#[may_dangle] T, A: Allocator> Drop for RawVec -where [(); alloc::co_alloc_metadata_num_slots::()]: +unsafe impl<#[may_dangle] T, A: Allocator, const COOP_PREFERRED: bool> Drop for RawVec +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { /// Frees the memory owned by the `RawVec` *without* trying to drop its contents. default fn drop(&mut self) { if let Some((ptr, layout)) = self.current_memory() { - unsafe { self.alloc.co_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) } + } } } } // @TODO Custom -/*unsafe impl<#[may_dangle] T> Drop for RawVec { +unsafe impl<#[may_dangle] T, const COOP_PREFERRED: bool> Drop for RawVec +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { /// Frees the memory owned by the `RawVec` *without* trying to drop its contents. fn drop(&mut self) { // @TODO @@ -510,7 +515,7 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: unsafe { self.alloc.deallocate(ptr, layout) } } } -}*/ +} // Central function for reserve error handling. #[cfg(not(no_global_oom_handling))] diff --git a/library/alloc/src/slice.rs b/library/alloc/src/slice.rs index aabd7178e513b..00da725042141 100644 --- a/library/alloc/src/slice.rs +++ b/library/alloc/src/slice.rs @@ -778,16 +778,16 @@ impl> Join<&[T]> for [V] { //////////////////////////////////////////////////////////////////////////////// #[stable(feature = "rust1", since = "1.0.0")] -impl Borrow<[T]> for Vec -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +impl Borrow<[T]> for Vec +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { fn borrow(&self) -> &[T] { &self[..] } } #[stable(feature = "rust1", since = "1.0.0")] -impl BorrowMut<[T]> for Vec -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +impl BorrowMut<[T]> for Vec +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { fn borrow_mut(&mut self) -> &mut [T] { &mut self[..] } diff --git a/library/alloc/src/vec/drain.rs b/library/alloc/src/vec/drain.rs index 279488fd03450..6372333bda81d 100644 --- a/library/alloc/src/vec/drain.rs +++ b/library/alloc/src/vec/drain.rs @@ -23,8 +23,9 @@ pub struct Drain< 'a, T: 'a, #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator + 'a = Global, + const COOP_PREFERRED: bool = {alloc::SHORT_TERM_VEC_PREFERS_COOP} > -where [(); alloc::co_alloc_metadata_num_slots::()]: { +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { /// Index of tail to preserve pub(super) tail_start: usize, /// Length of tail @@ -35,15 +36,15 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { } #[stable(feature = "collection_debug", since = "1.17.0")] -impl fmt::Debug for Drain<'_, T, A> -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl fmt::Debug for Drain<'_, T, A, COOP_PREFERRED> +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(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> -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl<'a, T, A: Allocator, const COOP_PREFERRED: bool> Drain<'a, T, A, COOP_PREFERRED> +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { /// Returns the remaining items of this iterator as a slice. /// /// # Examples @@ -142,23 +143,23 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { } #[stable(feature = "vec_drain_as_slice", since = "1.46.0")] -impl<'a, T, A: Allocator> AsRef<[T]> for Drain<'a, T, A> -where [(); alloc::co_alloc_metadata_num_slots::()]: { +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::(COOP_PREFERRED)]: { fn as_ref(&self) -> &[T] { self.as_slice() } } #[stable(feature = "drain", since = "1.6.0")] -unsafe impl Sync for Drain<'_, T, A> -where [(); alloc::co_alloc_metadata_num_slots::()]: {} +unsafe impl Sync for Drain<'_, T, A, COOP_PREFERRED> +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: {} #[stable(feature = "drain", since = "1.6.0")] -unsafe impl Send for Drain<'_, T, A> -where [(); alloc::co_alloc_metadata_num_slots::()]: {} +unsafe impl Send for Drain<'_, T, A, COOP_PREFERRED> +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: {} #[stable(feature = "drain", since = "1.6.0")] -impl Iterator for Drain<'_, T, A> -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl Iterator for Drain<'_, T, A, COOP_PREFERRED> +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { type Item = T; #[inline] @@ -172,8 +173,8 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { } #[stable(feature = "drain", since = "1.6.0")] -impl DoubleEndedIterator for Drain<'_, T, A> -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl DoubleEndedIterator for Drain<'_, T, A, COOP_PREFERRED> +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { #[inline] fn next_back(&mut self) -> Option { self.iter.next_back().map(|elt| unsafe { ptr::read(elt as *const _) }) @@ -181,15 +182,15 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { } #[stable(feature = "drain", since = "1.6.0")] -impl Drop for Drain<'_, T, A> -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl Drop for Drain<'_, T, A, COOP_PREFERRED> +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(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>) - where [(); alloc::co_alloc_metadata_num_slots::()]: ; + 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::(COOP_PREFERRED)]: ; - impl<'r, 'a, T, A: Allocator> Drop for DropGuard<'r, 'a, T, A> - where [(); alloc::co_alloc_metadata_num_slots::()]: { + 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::(COOP_PREFERRED)]: { fn drop(&mut self) { if self.0.tail_len > 0 { unsafe { @@ -253,17 +254,17 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { } #[stable(feature = "drain", since = "1.6.0")] -impl ExactSizeIterator for Drain<'_, T, A> -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl ExactSizeIterator for Drain<'_, T, A, COOP_PREFERRED> +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { fn is_empty(&self) -> bool { self.iter.is_empty() } } #[unstable(feature = "trusted_len", issue = "37572")] -unsafe impl TrustedLen for Drain<'_, T, A> -where [(); alloc::co_alloc_metadata_num_slots::()]: {} +unsafe impl TrustedLen for Drain<'_, T, A, COOP_PREFERRED> +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: {} #[stable(feature = "fused", since = "1.26.0")] -impl FusedIterator for Drain<'_, T, A> -where [(); alloc::co_alloc_metadata_num_slots::()]: {} +impl FusedIterator for Drain<'_, T, A, COOP_PREFERRED> +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: {} diff --git a/library/alloc/src/vec/drain_filter.rs b/library/alloc/src/vec/drain_filter.rs index d78a81b647d5b..7be4abacbec96 100644 --- a/library/alloc/src/vec/drain_filter.rs +++ b/library/alloc/src/vec/drain_filter.rs @@ -24,11 +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::()]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { - pub(super) vec: &'a mut Vec, + pub(super) vec: &'a mut Vec, /// 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,10 +46,10 @@ pub struct DrainFilter< pub(super) panic_flag: bool, } -impl DrainFilter<'_, T, F, A> +impl DrainFilter<'_, T, F, A, COOP_PREFERRED> where F: FnMut(&mut T) -> bool, - [(); alloc::co_alloc_metadata_num_slots::()]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { /// Returns a reference to the underlying allocator. #[unstable(feature = "allocator_api", issue = "32838")] @@ -114,10 +115,10 @@ where } #[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")] -impl Iterator for DrainFilter<'_, T, F, A> +impl Iterator for DrainFilter<'_, T, F, A, COOP_PREFERRED> where F: FnMut(&mut T) -> bool, - [(); alloc::co_alloc_metadata_num_slots::()]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { type Item = T; @@ -153,24 +154,24 @@ where } #[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")] -impl Drop for DrainFilter<'_, T, F, A> +impl Drop for DrainFilter<'_, T, F, A, COOP_PREFERRED> where F: FnMut(&mut T) -> bool, - [(); alloc::co_alloc_metadata_num_slots::()]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(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::()]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(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::()]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { fn drop(&mut self) { unsafe { diff --git a/library/alloc/src/vec/into_iter.rs b/library/alloc/src/vec/into_iter.rs index 6c43afd3aeb0e..fdad67de09716 100644 --- a/library/alloc/src/vec/into_iter.rs +++ b/library/alloc/src/vec/into_iter.rs @@ -31,8 +31,9 @@ use core::slice::{self}; pub struct IntoIter< T, #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global, + const COOP_PREFERRED: bool = {alloc::SHORT_TERM_VEC_PREFERS_COOP} > -where [(); alloc::co_alloc_metadata_num_slots::()]: { +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { pub(super) buf: NonNull, pub(super) phantom: PhantomData, pub(super) cap: usize, @@ -46,15 +47,15 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { } #[stable(feature = "vec_intoiter_debug", since = "1.13.0")] -impl fmt::Debug for IntoIter -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl fmt::Debug for IntoIter +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_tuple("IntoIter").field(&self.as_slice()).finish() } } -impl IntoIter -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl IntoIter +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { /// Returns the remaining items of this iterator as a slice. /// /// # Examples @@ -143,8 +144,7 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { #[cfg(not(no_global_oom_handling))] #[inline] - pub(crate) fn into_vecdeque(self) -> VecDeque - where [(); alloc::co_alloc_metadata_num_slots::()]: { + pub(crate) fn into_vecdeque(self) -> VecDeque { // Keep our `Drop` impl from dropping the elements and the allocator let mut this = ManuallyDrop::new(self); @@ -171,23 +171,23 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { } #[stable(feature = "vec_intoiter_as_ref", since = "1.46.0")] -impl AsRef<[T]> for IntoIter -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl AsRef<[T]> for IntoIter +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { fn as_ref(&self) -> &[T] { self.as_slice() } } #[stable(feature = "rust1", since = "1.0.0")] -unsafe impl Send for IntoIter -where [(); alloc::co_alloc_metadata_num_slots::()]: {} +unsafe impl Send for IntoIter +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: {} #[stable(feature = "rust1", since = "1.0.0")] -unsafe impl Sync for IntoIter -where [(); alloc::co_alloc_metadata_num_slots::()]: {} +unsafe impl Sync for IntoIter +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: {} #[stable(feature = "rust1", since = "1.0.0")] -impl Iterator for IntoIter -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl Iterator for IntoIter +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { type Item = T; #[inline] @@ -301,8 +301,8 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { } #[stable(feature = "rust1", since = "1.0.0")] -impl DoubleEndedIterator for IntoIter -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl DoubleEndedIterator for IntoIter +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { #[inline] fn next_back(&mut self) -> Option { if self.end == self.ptr { @@ -343,20 +343,20 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { } #[stable(feature = "rust1", since = "1.0.0")] -impl ExactSizeIterator for IntoIter -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl ExactSizeIterator for IntoIter +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { fn is_empty(&self) -> bool { self.ptr == self.end } } #[stable(feature = "fused", since = "1.26.0")] -impl FusedIterator for IntoIter -where [(); alloc::co_alloc_metadata_num_slots::()]: {} +impl FusedIterator for IntoIter +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: {} #[unstable(feature = "trusted_len", issue = "37572")] -unsafe impl TrustedLen for IntoIter -where [(); alloc::co_alloc_metadata_num_slots::()]: {} +unsafe impl TrustedLen for IntoIter +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: {} #[doc(hidden)] #[unstable(issue = "none", feature = "std_internals")] @@ -372,18 +372,18 @@ impl 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 TrustedRandomAccessNoCoerce for IntoIter +unsafe impl TrustedRandomAccessNoCoerce for IntoIter where T: NonDrop, - [(); alloc::co_alloc_metadata_num_slots::()]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(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 Clone for IntoIter -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl Clone for IntoIter +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { #[cfg(not(test))] fn clone(&self) -> Self { self.as_slice().to_vec_in(self.alloc.deref().clone()).into_iter() @@ -395,20 +395,20 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { } #[stable(feature = "rust1", since = "1.0.0")] -unsafe impl<#[may_dangle] T, A: Allocator> Drop for IntoIter -where [(); alloc::co_alloc_metadata_num_slots::()]: { +unsafe impl<#[may_dangle] T, A: Allocator, const COOP_PREFERRED: bool> Drop for IntoIter +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { fn drop(&mut self) { - struct DropGuard<'a, T, A: Allocator>(&'a mut IntoIter) - where [(); alloc::co_alloc_metadata_num_slots::()]: ; + struct DropGuard<'a, T, A: Allocator, const COOP_PREFERRED: bool>(&'a mut IntoIter) + where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: ; - impl Drop for DropGuard<'_, T, A> - where [(); alloc::co_alloc_metadata_num_slots::()]: { + impl Drop for DropGuard<'_, T, A, COOP_PREFERRED> + where [(); alloc::co_alloc_metadata_num_slots_with_preference::(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); + let _ = RawVec::::from_raw_parts_in(self.0.buf.as_ptr(), self.0.cap, alloc); } } } @@ -426,13 +426,13 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { // also refer to the vec::in_place_collect module documentation to get an overview #[unstable(issue = "none", feature = "inplace_iteration")] #[doc(hidden)] -unsafe impl InPlaceIterable for IntoIter -where [(); alloc::co_alloc_metadata_num_slots::()]: {} +unsafe impl InPlaceIterable for IntoIter +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: {} #[unstable(issue = "none", feature = "inplace_iteration")] #[doc(hidden)] -unsafe impl SourceIter for IntoIter -where [(); alloc::co_alloc_metadata_num_slots::()]: { +unsafe impl SourceIter for IntoIter +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { type Source = Self; #[inline] diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs index 9c7a278bf7207..1f8607a05a442 100644 --- a/library/alloc/src/vec/mod.rs +++ b/library/alloc/src/vec/mod.rs @@ -398,10 +398,10 @@ mod spec_extend; #[cfg_attr(not(test), rustc_diagnostic_item = "Vec")] #[rustc_insignificant_dtor] // @TODO _coop -pub struct Vec -where [(); core::alloc::co_alloc_metadata_num_slots::()]: +pub struct Vec +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { - buf: RawVec, + buf: RawVec, len: usize, } @@ -609,8 +609,8 @@ impl Vec { } } -impl Vec -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +impl Vec +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { /// Constructs a new, empty `Vec`. /// /// The vector will not allocate until elements are pushed onto it. @@ -1623,16 +1623,16 @@ where [(); core::alloc::co_alloc_metadata_num_slots::()]: { // 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> - where [(); core::alloc::co_alloc_metadata_num_slots::()]: { - v: &'a mut Vec, + struct BackshiftOnDrop<'a, T, A: Allocator, const VEC_IS_COOP: bool=true> + where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(VEC_IS_COOP)]: { + v: &'a mut Vec, processed_len: usize, deleted_cnt: usize, original_len: usize, } - impl Drop for BackshiftOnDrop<'_, T, A> - where [(); core::alloc::co_alloc_metadata_num_slots::()]: { + impl Drop for BackshiftOnDrop<'_, T, A, VEC_IS_COOP> + where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(VEC_IS_COOP)]: { fn drop(&mut self) { if self.deleted_cnt > 0 { // SAFETY: Trailing unchecked items must be valid since we never touch them. @@ -1651,15 +1651,15 @@ where [(); core::alloc::co_alloc_metadata_num_slots::()]: { } } - let mut g = BackshiftOnDrop { v: self, processed_len: 0, deleted_cnt: 0, original_len }; + let mut g = BackshiftOnDrop:: { v: self, processed_len: 0, deleted_cnt: 0, original_len }; - fn process_loop( + fn process_loop( 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::()]: + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(VEC_IS_COOP)]: { while g.processed_len != original_len { // SAFETY: Unchecked element must be valid. @@ -1690,10 +1690,10 @@ where [(); core::alloc::co_alloc_metadata_num_slots::()]: { } // Stage 1: Nothing was deleted. - process_loop::(original_len, &mut f, &mut g); + process_loop::(original_len, &mut f, &mut g); // Stage 2: Some elements were deleted. - process_loop::(original_len, &mut f, &mut g); + process_loop::(original_len, &mut f, &mut g); // All item are processed. This can be optimized to `set_len` by LLVM. drop(g); @@ -1752,8 +1752,8 @@ where [(); core::alloc::co_alloc_metadata_num_slots::()]: { } /* INVARIANT: vec.len() > read >= write > write-1 >= 0 */ - struct FillGapOnDrop<'a, T, A: core::alloc::Allocator> - where [(); core::alloc::co_alloc_metadata_num_slots::()]: { + struct FillGapOnDrop<'a, T, A: core::alloc::Allocator, const COOP_PREFERRED: bool> + where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { /* Offset of the element we want to check if it is duplicate */ read: usize, @@ -1762,11 +1762,11 @@ where [(); core::alloc::co_alloc_metadata_num_slots::()]: { write: usize, /* The Vec that would need correction if `same_bucket` panicked */ - vec: &'a mut Vec, + vec: &'a mut Vec, } - impl<'a, T, A: core::alloc::Allocator> Drop for FillGapOnDrop<'a, T, A> - where [(); core::alloc::co_alloc_metadata_num_slots::()]: { + 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::(COOP_PREFERRED)]: { fn drop(&mut self) { /* This code gets executed when `same_bucket` panics */ @@ -2359,8 +2359,8 @@ where [(); core::alloc::co_alloc_metadata_num_slots::()]: { } } -impl Vec -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +impl Vec +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(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 @@ -2459,8 +2459,8 @@ where [(); core::alloc::co_alloc_metadata_num_slots::()]: { } } -impl Vec<[T; N], A> -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +impl Vec<[T; N], A, COOP_PREFERRED> +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { /// Takes a `Vec<[T; N]>` and flattens it into a `Vec`. /// /// # Panics @@ -2521,8 +2521,8 @@ impl ExtendWith for ExtendElement { } } -impl Vec -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +impl Vec +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { #[cfg(not(no_global_oom_handling))] /// Extend the vector by `n` values, using the given generator. fn extend_with>(&mut self, n: usize, mut value: E) { @@ -2554,8 +2554,8 @@ where [(); core::alloc::co_alloc_metadata_num_slots::()]: { } } -impl Vec -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +impl Vec +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { /// Removes consecutive repeated elements in the vector according to the /// [`PartialEq`] trait implementation. /// @@ -2591,8 +2591,8 @@ pub fn from_elem(elem: T, n: usize) -> Vec { #[doc(hidden)] #[cfg(not(no_global_oom_handling))] #[unstable(feature = "allocator_api", issue = "32838")] -pub fn from_elem_in(elem: T, n: usize, alloc: A) -> Vec -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +pub fn from_elem_in(elem: T, n: usize, alloc: A) -> Vec +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { ::from_elem(elem, n, alloc) } @@ -2604,8 +2604,8 @@ trait ExtendFromWithinSpec { unsafe fn spec_extend_from_within(&mut self, src: Range); } -impl ExtendFromWithinSpec for Vec -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +impl ExtendFromWithinSpec for Vec +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { default unsafe fn spec_extend_from_within(&mut self, src: Range) { // SAFETY: // - len is increased only after initializing elements @@ -2624,8 +2624,8 @@ where [(); core::alloc::co_alloc_metadata_num_slots::()]: { } } -impl ExtendFromWithinSpec for Vec -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +impl ExtendFromWithinSpec for Vec +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { unsafe fn spec_extend_from_within(&mut self, src: Range) { let count = src.len(); { @@ -2658,8 +2658,8 @@ where [(); core::alloc::co_alloc_metadata_num_slots::()]: { //////////////////////////////////////////////////////////////////////////////// #[stable(feature = "rust1", since = "1.0.0")] -impl ops::Deref for Vec -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +impl ops::Deref for Vec +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { type Target = [T]; #[inline] @@ -2669,8 +2669,8 @@ where [(); core::alloc::co_alloc_metadata_num_slots::()]: { } #[stable(feature = "rust1", since = "1.0.0")] -impl ops::DerefMut for Vec -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +impl ops::DerefMut for Vec +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { #[inline] fn deref_mut(&mut self) -> &mut [T] { unsafe { slice::from_raw_parts_mut(self.as_mut_ptr(), self.len) } @@ -2683,8 +2683,8 @@ trait SpecCloneFrom { } #[cfg(not(no_global_oom_handling))] -impl SpecCloneFrom for Vec -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +impl SpecCloneFrom for Vec +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { default fn clone_from(this: &mut Self, other: &Self) { // drop anything that will not be overwritten this.truncate(other.len()); @@ -2700,8 +2700,8 @@ where [(); core::alloc::co_alloc_metadata_num_slots::()]: { } #[cfg(not(no_global_oom_handling))] -impl SpecCloneFrom for Vec -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +impl SpecCloneFrom for Vec +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { fn clone_from(this: &mut Self, other: &Self) { this.clear(); this.extend_from_slice(other); @@ -2710,8 +2710,8 @@ where [(); core::alloc::co_alloc_metadata_num_slots::()]: { #[cfg(not(no_global_oom_handling))] #[stable(feature = "rust1", since = "1.0.0")] -impl Clone for Vec -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +impl Clone for Vec +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { #[cfg(not(test))] fn clone(&self) -> Self { let alloc = self.allocator().clone(); @@ -2746,8 +2746,8 @@ where [(); core::alloc::co_alloc_metadata_num_slots::()]: { /// assert_eq!(b.hash_one(v), b.hash_one(s)); /// ``` #[stable(feature = "rust1", since = "1.0.0")] -impl Hash for Vec -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +impl Hash for Vec +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { #[inline] fn hash(&self, state: &mut H) { Hash::hash(&**self, state) @@ -2759,8 +2759,8 @@ where [(); core::alloc::co_alloc_metadata_num_slots::()]: { message = "vector indices are of type `usize` or ranges of `usize`", label = "vector indices are of type `usize` or ranges of `usize`" )] -impl, A: Allocator> Index for Vec -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +impl, A: Allocator, const COOP_PREFERRED: bool> Index for Vec +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { type Output = I::Output; #[inline] @@ -2774,8 +2774,8 @@ where [(); core::alloc::co_alloc_metadata_num_slots::()]: { message = "vector indices are of type `usize` or ranges of `usize`", label = "vector indices are of type `usize` or ranges of `usize`" )] -impl, A: Allocator> IndexMut for Vec -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +impl, A: Allocator, const COOP_PREFERRED: bool> IndexMut for Vec +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { #[inline] fn index_mut(&mut self, index: I) -> &mut Self::Output { IndexMut::index_mut(&mut **self, index) @@ -2792,8 +2792,8 @@ impl FromIterator for Vec { } #[stable(feature = "rust1", since = "1.0.0")] -impl IntoIterator for Vec -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +impl IntoIterator for Vec +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { type Item = T; type IntoIter = IntoIter; @@ -2838,8 +2838,8 @@ where [(); core::alloc::co_alloc_metadata_num_slots::()]: { } #[stable(feature = "rust1", since = "1.0.0")] -impl<'a, T, A: Allocator> IntoIterator for &'a Vec -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +impl<'a, T, A: Allocator, const COOP_PREFERRED: bool> IntoIterator for &'a Vec +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { type Item = &'a T; type IntoIter = slice::Iter<'a, T>; @@ -2849,8 +2849,8 @@ where [(); core::alloc::co_alloc_metadata_num_slots::()]: { } #[stable(feature = "rust1", since = "1.0.0")] -impl<'a, T, A: Allocator> IntoIterator for &'a mut Vec -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +impl<'a, T, A: Allocator, const COOP_PREFERRED: bool> IntoIterator for &'a mut Vec +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { type Item = &'a mut T; type IntoIter = slice::IterMut<'a, T>; @@ -2861,8 +2861,8 @@ where [(); core::alloc::co_alloc_metadata_num_slots::()]: { #[cfg(not(no_global_oom_handling))] #[stable(feature = "rust1", since = "1.0.0")] -impl Extend for Vec -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +impl Extend for Vec +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { #[inline] fn extend>(&mut self, iter: I) { >::spec_extend(self, iter.into_iter()) @@ -2879,8 +2879,8 @@ where [(); core::alloc::co_alloc_metadata_num_slots::()]: { } } -impl Vec -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +impl Vec +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(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))] @@ -3054,8 +3054,8 @@ where [(); core::alloc::co_alloc_metadata_num_slots::()]: { /// [`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 -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +impl<'a, T: Copy + 'a, A: Allocator + 'a, const COOP_PREFERRED: bool> Extend<&'a T> for Vec +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { fn extend>(&mut self, iter: I) { self.spec_extend(iter.into_iter()) } @@ -3073,8 +3073,8 @@ where [(); core::alloc::co_alloc_metadata_num_slots::()]: { /// Implements comparison of vectors, [lexicographically](core::cmp::Ord#lexicographical-comparison). #[stable(feature = "rust1", since = "1.0.0")] -impl PartialOrd for Vec -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +impl PartialOrd for Vec +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { #[inline] fn partial_cmp(&self, other: &Self) -> Option { PartialOrd::partial_cmp(&**self, &**other) @@ -3082,13 +3082,13 @@ where [(); core::alloc::co_alloc_metadata_num_slots::()]: { } #[stable(feature = "rust1", since = "1.0.0")] -impl Eq for Vec -where [(); core::alloc::co_alloc_metadata_num_slots::()]: {} +impl Eq for Vec +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: {} /// Implements ordering of vectors, [lexicographically](core::cmp::Ord#lexicographical-comparison). #[stable(feature = "rust1", since = "1.0.0")] -impl Ord for Vec -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +impl Ord for Vec +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { #[inline] fn cmp(&self, other: &Self) -> Ordering { Ord::cmp(&**self, &**other) @@ -3096,8 +3096,8 @@ where [(); core::alloc::co_alloc_metadata_num_slots::()]: { } #[stable(feature = "rust1", since = "1.0.0")] -unsafe impl<#[may_dangle] T, A: Allocator> Drop for Vec -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +unsafe impl<#[may_dangle] T, A: Allocator, const COOP_PREFERRED: bool> Drop for Vec +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { fn drop(&mut self) { unsafe { // use drop for [T] @@ -3121,40 +3121,40 @@ impl const Default for Vec { } #[stable(feature = "rust1", since = "1.0.0")] -impl fmt::Debug for Vec -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +impl fmt::Debug for Vec +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fmt::Debug::fmt(&**self, f) } } #[stable(feature = "rust1", since = "1.0.0")] -impl AsRef> for Vec -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +impl AsRef> for Vec +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { fn as_ref(&self) -> &Vec { self } } #[stable(feature = "vec_as_mut", since = "1.5.0")] -impl AsMut> for Vec -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +impl AsMut> for Vec +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { fn as_mut(&mut self) -> &mut Vec { self } } #[stable(feature = "rust1", since = "1.0.0")] -impl AsRef<[T]> for Vec -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +impl AsRef<[T]> for Vec +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { fn as_ref(&self) -> &[T] { self } } #[stable(feature = "vec_as_mut", since = "1.5.0")] -impl AsMut<[T]> for Vec -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +impl AsMut<[T]> for Vec +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { fn as_mut(&mut self) -> &mut [T] { self } @@ -3251,8 +3251,8 @@ where // note: test pulls in std, which causes errors here #[cfg(not(test))] #[stable(feature = "vec_from_box", since = "1.18.0")] -impl From> for Vec -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +impl From> for Vec +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { /// Convert a boxed slice into a vector by transferring ownership of /// the existing heap allocation. /// @@ -3271,8 +3271,8 @@ where [(); core::alloc::co_alloc_metadata_num_slots::()]: { #[cfg(not(no_global_oom_handling))] #[cfg(not(test))] #[stable(feature = "box_from_vec", since = "1.20.0")] -impl From> for Box<[T], A> -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +impl From> for Box<[T], A> +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { /// Convert a vector into a boxed slice. /// /// If `v` has excess capacity, its items will be moved into a @@ -3312,8 +3312,8 @@ impl From<&str> for Vec { } #[stable(feature = "array_try_from_vec", since = "1.48.0")] -impl TryFrom> for [T; N] -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +impl TryFrom> for [T; N] +where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { type Error = Vec; /// Gets the entire contents of the `Vec` as an array, diff --git a/library/alloc/src/vec/partial_eq.rs b/library/alloc/src/vec/partial_eq.rs index b50b9673e1560..bcf52b7333218 100644 --- a/library/alloc/src/vec/partial_eq.rs +++ b/library/alloc/src/vec/partial_eq.rs @@ -6,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 PartialEq<$rhs> for $lhs where T: PartialEq, - $($ty: $bound)? + $($constraints)* { #[inline] fn eq(&self, other: &$rhs) -> bool { self[..] == other[..] } @@ -21,21 +21,21 @@ macro_rules! __impl_slice_eq1 { } } -__impl_slice_eq1! { [A1: Allocator, A2: Allocator] Vec, Vec, #[stable(feature = "rust1", since = "1.0.0")] } -__impl_slice_eq1! { [A: Allocator] Vec, &[U], #[stable(feature = "rust1", since = "1.0.0")] } -__impl_slice_eq1! { [A: Allocator] Vec, &mut [U], #[stable(feature = "rust1", since = "1.0.0")] } -__impl_slice_eq1! { [A: Allocator] &[T], Vec, #[stable(feature = "partialeq_vec_for_ref_slice", since = "1.46.0")] } -__impl_slice_eq1! { [A: Allocator] &mut [T], Vec, #[stable(feature = "partialeq_vec_for_ref_slice", since = "1.46.0")] } -__impl_slice_eq1! { [A: Allocator] Vec, [U], #[stable(feature = "partialeq_vec_for_slice", since = "1.48.0")] } -__impl_slice_eq1! { [A: Allocator] [T], Vec, #[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, Vec, #[stable(feature = "rust1", since = "1.0.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED1)]:, [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED2)]: } +__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] Vec, &[U], #[stable(feature = "rust1", since = "1.0.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: } +__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] Vec, &mut [U], #[stable(feature = "rust1", since = "1.0.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: } +__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] &[T], Vec, #[stable(feature = "partialeq_vec_for_ref_slice", since = "1.46.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: } +__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] &mut [T], Vec, #[stable(feature = "partialeq_vec_for_ref_slice", since = "1.46.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: } +__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] Vec, [U], #[stable(feature = "partialeq_vec_for_slice", since = "1.48.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: } +__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] [T], Vec, #[stable(feature = "partialeq_vec_for_slice", since = "1.48.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: } #[cfg(not(no_global_oom_handling))] -__impl_slice_eq1! { [A: Allocator] Cow<'_, [T]>, Vec where T: Clone, #[stable(feature = "rust1", since = "1.0.0")] } +__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] Cow<'_, [T]>, Vec, #[stable(feature = "rust1", since = "1.0.0")], T: Clone, [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(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, [U; N], #[stable(feature = "rust1", since = "1.0.0")] } -__impl_slice_eq1! { [A: Allocator, const N: usize] Vec, &[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, [U; N], #[stable(feature = "rust1", since = "1.0.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: } +__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool, const N: usize] Vec, &[U; N], #[stable(feature = "rust1", since = "1.0.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: } // NOTE: some less important impls are omitted to reduce code bloat // FIXME(Centril): Reconsider this? diff --git a/library/core/src/alloc/mod.rs b/library/core/src/alloc/mod.rs index 23bfdc732557e..9359273ca0a3a 100644 --- a/library/core/src/alloc/mod.rs +++ b/library/core/src/alloc/mod.rs @@ -28,6 +28,7 @@ use crate::ptr::{self, NonNull}; // @TODO Make this target-specific #[unstable(feature = "global_co_alloc_meta", issue = "none")] #[allow(missing_debug_implementations)] +#[derive(Clone, Copy)] pub struct GlobalCoAllocMeta { //pub one: usize, /*pub two: usize, @@ -73,6 +74,9 @@ pub struct SliceAndMeta { pub meta: GlobalCoAllocMeta, } +#[unstable(feature = "global_co_alloc_short_term_pref", issue = "none")] +pub const SHORT_TERM_VEC_PREFERS_COOP: bool = true; + #[unstable(feature = "global_co_alloc_meta", issue = "none")] #[allow(missing_debug_implementations)] pub type SliceAndMetaResult = Result; @@ -82,6 +86,13 @@ pub const fn co_alloc_metadata_num_slots() -> usize { 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(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`][]. /// From b0dd71cfe2d46e55d9acd3785ead2ca820d7cae1 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sat, 21 Jan 2023 16:14:15 -0800 Subject: [PATCH 10/80] CoAlloc: BinaryHeap now uses bounds. (Probably needs to go together with Vec). ICE --- .../alloc/src/collections/binary_heap/mod.rs | 20 +++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) diff --git a/library/alloc/src/collections/binary_heap/mod.rs b/library/alloc/src/collections/binary_heap/mod.rs index 0b73b1af4eb35..7c6b0bb6e6c75 100644 --- a/library/alloc/src/collections/binary_heap/mod.rs +++ b/library/alloc/src/collections/binary_heap/mod.rs @@ -143,13 +143,15 @@ #![allow(missing_docs)] #![stable(feature = "rust1", since = "1.0.0")] -use core::fmt; +use core::{alloc, 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 crate::alloc::Global; + use crate::collections::TryReserveError; use crate::slice; use crate::vec::{self, AsVecIntoIter, Vec}; @@ -1241,7 +1243,7 @@ impl BinaryHeap { /// ``` #[inline] #[stable(feature = "drain", since = "1.6.0")] - pub fn drain(&mut self) -> Drain<'_, T> { + pub fn drain(&mut self) -> Drain<'_, T, {alloc::SHORT_TERM_VEC_PREFERS_COOP}> { Drain { iter: self.data.drain(..) } } @@ -1521,12 +1523,14 @@ unsafe impl TrustedLen for IntoIterSorted {} /// [`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 [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { + iter: vec::Drain<'a, T, Global, COOP_PREFERRED>, } #[stable(feature = "drain", since = "1.6.0")] -impl Iterator for Drain<'_, T> { +impl Iterator for Drain<'_, T, COOP_PREFERRED> +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { type Item = T; #[inline] @@ -1541,7 +1545,7 @@ impl Iterator for Drain<'_, T> { } #[stable(feature = "drain", since = "1.6.0")] -impl DoubleEndedIterator for Drain<'_, T> { +impl DoubleEndedIterator for Drain<'_, T, COOP_PREFERRED> { #[inline] fn next_back(&mut self) -> Option { self.iter.next_back() @@ -1549,14 +1553,14 @@ impl DoubleEndedIterator for Drain<'_, T> { } #[stable(feature = "drain", since = "1.6.0")] -impl ExactSizeIterator for Drain<'_, T> { +impl ExactSizeIterator for Drain<'_, T, COOP_PREFERRED> { fn is_empty(&self) -> bool { self.iter.is_empty() } } #[stable(feature = "fused", since = "1.26.0")] -impl FusedIterator for Drain<'_, T> {} +impl FusedIterator for Drain<'_, T, COOP_PREFERRED> {} /// A draining iterator over the elements of a `BinaryHeap`. /// From b7c43ecb928dfe9e1168e7f021b6a4331441bf13 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sat, 21 Jan 2023 16:15:28 -0800 Subject: [PATCH 11/80] CoAlloc: VecDeque now uses bounds. ICE --- .../alloc/src/collections/vec_deque/drain.rs | 51 +++++---- .../alloc/src/collections/vec_deque/macros.rs | 4 +- .../alloc/src/collections/vec_deque/mod.rs | 107 +++++++++--------- .../src/collections/vec_deque/spec_extend.rs | 24 ++-- 4 files changed, 94 insertions(+), 92 deletions(-) diff --git a/library/alloc/src/collections/vec_deque/drain.rs b/library/alloc/src/collections/vec_deque/drain.rs index e4f2f80892504..bab4919eb6032 100644 --- a/library/alloc/src/collections/vec_deque/drain.rs +++ b/library/alloc/src/collections/vec_deque/drain.rs @@ -19,11 +19,12 @@ pub struct Drain< 'a, T: 'a, #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global, + const COOP_PREFERRED: bool = {alloc::SHORT_TERM_VEC_PREFERS_COOP} > -where [(); alloc::co_alloc_metadata_num_slots::()]: { +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { // We can't just use a &mut VecDeque, as that would make Drain invariant over T // and we want it to be covariant instead - deque: NonNull>, + deque: NonNull>, // 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)) @@ -35,10 +36,10 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { _marker: PhantomData<&'a T>, } -impl<'a, T, A: Allocator> Drain<'a, T, A> -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl<'a, T, A: Allocator, const COOP_PREFERRED: bool> Drain<'a, T, A, COOP_PREFERRED> +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { pub(super) unsafe fn new( - deque: &'a mut VecDeque, + deque: &'a mut VecDeque, drain_start: usize, drain_len: usize, ) -> Self { @@ -90,8 +91,8 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { } #[stable(feature = "collection_debug", since = "1.17.0")] -impl fmt::Debug for Drain<'_, T, A> -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl fmt::Debug for Drain<'_, T, A, COOP_PREFERRED> +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_tuple("Drain") .field(&self.drain_len) @@ -103,21 +104,21 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { } #[stable(feature = "drain", since = "1.6.0")] -unsafe impl Sync for Drain<'_, T, A> -where [(); alloc::co_alloc_metadata_num_slots::()]: {} +unsafe impl Sync for Drain<'_, T, A, COOP_PREFERRED> +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: {} #[stable(feature = "drain", since = "1.6.0")] -unsafe impl Send for Drain<'_, T, A> -where [(); alloc::co_alloc_metadata_num_slots::()]: {} +unsafe impl Send for Drain<'_, T, A, COOP_PREFERRED> +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: {} #[stable(feature = "drain", since = "1.6.0")] -impl Drop for Drain<'_, T, A> -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl Drop for Drain<'_, T, A, COOP_PREFERRED> +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { fn drop(&mut self) { - struct DropGuard<'r, 'a, T, A: Allocator> (&'r mut Drain<'a, T, A>) - where [(); alloc::co_alloc_metadata_num_slots::()]:; + 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::(COOP_PREFERRED)]:; - impl<'r, 'a, T, A: Allocator> Drop for DropGuard<'r, 'a, T, A> - where [(); alloc::co_alloc_metadata_num_slots::()]: { + 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::(COOP_PREFERRED)]: { fn drop(&mut self) { if self.0.remaining != 0 { unsafe { @@ -198,8 +199,8 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { } #[stable(feature = "drain", since = "1.6.0")] -impl Iterator for Drain<'_, T, A> -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl Iterator for Drain<'_, T, A, COOP_PREFERRED> +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { type Item = T; #[inline] @@ -221,8 +222,8 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { } #[stable(feature = "drain", since = "1.6.0")] -impl DoubleEndedIterator for Drain<'_, T, A> -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl DoubleEndedIterator for Drain<'_, T, A, COOP_PREFERRED> +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { #[inline] fn next_back(&mut self) -> Option { if self.remaining == 0 { @@ -235,9 +236,9 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { } #[stable(feature = "drain", since = "1.6.0")] -impl ExactSizeIterator for Drain<'_, T, A> -where [(); alloc::co_alloc_metadata_num_slots::()]: {} +impl ExactSizeIterator for Drain<'_, T, A, COOP_PREFERRED> +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: {} #[stable(feature = "fused", since = "1.26.0")] -impl FusedIterator for Drain<'_, T, A> -where [(); alloc::co_alloc_metadata_num_slots::()]: {} +impl FusedIterator for Drain<'_, T, A, COOP_PREFERRED> +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: {} diff --git a/library/alloc/src/collections/vec_deque/macros.rs b/library/alloc/src/collections/vec_deque/macros.rs index f7768f54c6225..68ee43152b5b5 100644 --- a/library/alloc/src/collections/vec_deque/macros.rs +++ b/library/alloc/src/collections/vec_deque/macros.rs @@ -1,10 +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 PartialEq<$rhs> for $lhs + impl PartialEq<$rhs> for $lhs where T: PartialEq, - [(); core::alloc::co_alloc_metadata_num_slots::()]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(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 cd13039cf015f..0d1c562825ede 100644 --- a/library/alloc/src/collections/vec_deque/mod.rs +++ b/library/alloc/src/collections/vec_deque/mod.rs @@ -97,8 +97,9 @@ mod tests; pub struct VecDeque< T, #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global, + const COOP_PREFERRED: bool = true > -where [(); alloc::co_alloc_metadata_num_slots::()]: +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { // `self[0]`, if it exists, is `buf[head]`. // `head < buf.capacity()`, unless `buf.capacity() == 0` when `head == 0`. @@ -107,12 +108,12 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: // 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, + buf: RawVec, } #[stable(feature = "rust1", since = "1.0.0")] -impl Clone for VecDeque -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl Clone for VecDeque +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { fn clone(&self) -> Self { let mut deq = Self::with_capacity_in(self.len(), self.allocator().clone()); deq.extend(self.iter().cloned()); @@ -126,8 +127,8 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { } #[stable(feature = "rust1", since = "1.0.0")] -unsafe impl<#[may_dangle] T, A: Allocator> Drop for VecDeque -where [(); alloc::co_alloc_metadata_num_slots::()]: { +unsafe impl<#[may_dangle] T, A: Allocator, const COOP_PREFERRED: bool> Drop for VecDeque +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { fn drop(&mut self) { /// Runs the destructor for all items in the slice when it gets dropped (normally or /// during unwinding). @@ -160,8 +161,8 @@ impl Default for VecDeque { } } -impl VecDeque -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl VecDeque +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { /// Marginally more convenient #[inline] fn ptr(&self) -> *mut T { @@ -450,14 +451,14 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { mut iter: impl Iterator, len: usize, ) -> usize { - struct Guard<'a, T, A: Allocator> - where [(); alloc::co_alloc_metadata_num_slots::()]: { - deque: &'a mut VecDeque, + struct Guard<'a, T, A: Allocator, const COOP_PREFERRED: bool> + where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { + deque: &'a mut VecDeque, written: usize, } - impl<'a, T, A: Allocator> Drop for Guard<'a, T, A> - where [(); alloc::co_alloc_metadata_num_slots::()]: { + 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::(COOP_PREFERRED)]: { fn drop(&mut self) { self.deque.len += self.written; } @@ -571,8 +572,8 @@ impl VecDeque { } } -impl VecDeque -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl VecDeque +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { /// Creates an empty deque. /// /// # Examples @@ -2607,8 +2608,8 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { } } -impl VecDeque -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl VecDeque +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(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. @@ -2653,8 +2654,8 @@ fn wrap_index(logical_index: usize, capacity: usize) -> usize { } #[stable(feature = "rust1", since = "1.0.0")] -impl PartialEq for VecDeque -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl PartialEq for VecDeque +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { fn eq(&self, other: &Self) -> bool { if self.len != other.len() { return false; @@ -2693,27 +2694,27 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { } #[stable(feature = "rust1", since = "1.0.0")] -impl Eq for VecDeque -where [(); alloc::co_alloc_metadata_num_slots::()]: {} +impl Eq for VecDeque +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: {} -__impl_slice_eq1! { [] VecDeque, Vec, } -__impl_slice_eq1! { [] VecDeque, &[U], } -__impl_slice_eq1! { [] VecDeque, &mut [U], } -__impl_slice_eq1! { [const N: usize] VecDeque, [U; N], } -__impl_slice_eq1! { [const N: usize] VecDeque, &[U; N], } -__impl_slice_eq1! { [const N: usize] VecDeque, &mut [U; N], } +__impl_slice_eq1! { [] VecDeque, Vec, } +__impl_slice_eq1! { [] VecDeque, &[U], } +__impl_slice_eq1! { [] VecDeque, &mut [U], } +__impl_slice_eq1! { [const N: usize] VecDeque, [U; N], } +__impl_slice_eq1! { [const N: usize] VecDeque, &[U; N], } +__impl_slice_eq1! { [const N: usize] VecDeque, &mut [U; N], } #[stable(feature = "rust1", since = "1.0.0")] -impl PartialOrd for VecDeque -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl PartialOrd for VecDeque +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { fn partial_cmp(&self, other: &Self) -> Option { self.iter().partial_cmp(other.iter()) } } #[stable(feature = "rust1", since = "1.0.0")] -impl Ord for VecDeque -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl Ord for VecDeque +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { #[inline] fn cmp(&self, other: &Self) -> Ordering { self.iter().cmp(other.iter()) @@ -2721,8 +2722,8 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { } #[stable(feature = "rust1", since = "1.0.0")] -impl Hash for VecDeque -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl Hash for VecDeque +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { fn hash(&self, state: &mut H) { state.write_length_prefix(self.len); // It's not possible to use Hash::hash_slice on slices @@ -2736,8 +2737,8 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { } #[stable(feature = "rust1", since = "1.0.0")] -impl Index for VecDeque -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl Index for VecDeque +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { type Output = T; #[inline] @@ -2747,8 +2748,8 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { } #[stable(feature = "rust1", since = "1.0.0")] -impl IndexMut for VecDeque -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl IndexMut for VecDeque +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { #[inline] fn index_mut(&mut self, index: usize) -> &mut T { self.get_mut(index).expect("Out of bounds access") @@ -2763,8 +2764,8 @@ impl FromIterator for VecDeque { } #[stable(feature = "rust1", since = "1.0.0")] -impl IntoIterator for VecDeque -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl IntoIterator for VecDeque +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { type Item = T; type IntoIter = IntoIter; @@ -2776,8 +2777,8 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { } #[stable(feature = "rust1", since = "1.0.0")] -impl<'a, T, A: Allocator> IntoIterator for &'a VecDeque -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl<'a, T, A: Allocator, const COOP_PREFERRED: bool> IntoIterator for &'a VecDeque +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { type Item = &'a T; type IntoIter = Iter<'a, T>; @@ -2787,8 +2788,8 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { } #[stable(feature = "rust1", since = "1.0.0")] -impl<'a, T, A: Allocator> IntoIterator for &'a mut VecDeque -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl<'a, T, A: Allocator, const COOP_PREFERRED: bool> IntoIterator for &'a mut VecDeque +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { type Item = &'a mut T; type IntoIter = IterMut<'a, T>; @@ -2798,8 +2799,8 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { } #[stable(feature = "rust1", since = "1.0.0")] -impl Extend for VecDeque -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl Extend for VecDeque +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { fn extend>(&mut self, iter: I) { >::spec_extend(self, iter.into_iter()); } @@ -2816,8 +2817,8 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { } #[stable(feature = "extend_ref", since = "1.2.0")] -impl<'a, T: 'a + Copy, A: Allocator> Extend<&'a T> for VecDeque -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl<'a, T: 'a + Copy, A: Allocator, const COOP_PREFERRED: bool> Extend<&'a T> for VecDeque +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { fn extend>(&mut self, iter: I) { self.spec_extend(iter.into_iter()); } @@ -2834,16 +2835,16 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { } #[stable(feature = "rust1", since = "1.0.0")] -impl fmt::Debug for VecDeque -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl fmt::Debug for VecDeque +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(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 From> for VecDeque -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl From> for VecDeque +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { /// Turn a [`Vec`] into a [`VecDeque`]. /// /// [`Vec`]: crate::vec::Vec @@ -2860,8 +2861,8 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { } #[stable(feature = "vecdeque_vec_conversions", since = "1.10.0")] -impl From> for Vec -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl From> for Vec +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { /// Turn a [`VecDeque`] into a [`Vec`]. /// /// [`Vec`]: crate::vec::Vec diff --git a/library/alloc/src/collections/vec_deque/spec_extend.rs b/library/alloc/src/collections/vec_deque/spec_extend.rs index f6d957fdc03ba..cdeda1a57bed5 100644 --- a/library/alloc/src/collections/vec_deque/spec_extend.rs +++ b/library/alloc/src/collections/vec_deque/spec_extend.rs @@ -13,10 +13,10 @@ pub(super) trait SpecExtend { fn spec_extend(&mut self, iter: I); } -impl SpecExtend for VecDeque +impl SpecExtend for VecDeque where I: Iterator, - [(); alloc::co_alloc_metadata_num_slots::()]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { default fn spec_extend(&mut self, mut iter: I) { // This function should be the moral equivalent of: @@ -26,8 +26,8 @@ where // } // May only be called if `deque.len() < deque.capacity()` - unsafe fn push_unchecked(deque: &mut VecDeque, element: T) - where [(); alloc::co_alloc_metadata_num_slots::()]: { + unsafe fn push_unchecked(deque: &mut VecDeque, element: T) + where [(); alloc::co_alloc_metadata_num_slots_with_preference::(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) }; @@ -54,10 +54,10 @@ where } } -impl SpecExtend for VecDeque +impl SpecExtend for VecDeque where I: TrustedLen, - [(); alloc::co_alloc_metadata_num_slots::()]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { default fn spec_extend(&mut self, iter: I) { // This is the case for a TrustedLen iterator. @@ -90,8 +90,8 @@ where } } -impl SpecExtend> for VecDeque -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl SpecExtend> for VecDeque +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { fn spec_extend(&mut self, mut iterator: vec::IntoIter) { let slice = iterator.as_slice(); self.reserve(slice.len()); @@ -104,21 +104,21 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { } } -impl<'a, T: 'a, I, A: Allocator> SpecExtend<&'a T, I> for VecDeque +impl<'a, T: 'a, I, A: Allocator, const COOP_PREFERRED: bool> SpecExtend<&'a T, I> for VecDeque where I: Iterator, T: Copy, - [(); alloc::co_alloc_metadata_num_slots::()]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(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 +impl<'a, T: 'a, A: Allocator, const COOP_PREFERRED: bool> SpecExtend<&'a T, slice::Iter<'a, T>> for VecDeque where T: Copy, - [(); alloc::co_alloc_metadata_num_slots::()]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { fn spec_extend(&mut self, iterator: slice::Iter<'a, T>) { let slice = iterator.as_slice(); From 33c42a401a19f6d2d8b0d69683a7e17c67e9a3a9 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sat, 21 Jan 2023 21:50:46 -0800 Subject: [PATCH 12/80] CoAlloc: VecDeque. Probably ICE. --- .../src/collections/vec_deque/into_iter.rs | 11 ++++++----- library/alloc/src/collections/vec_deque/mod.rs | 18 ++++++++++-------- library/std/src/io/impls.rs | 6 ++++-- 3 files changed, 20 insertions(+), 15 deletions(-) diff --git a/library/alloc/src/collections/vec_deque/into_iter.rs b/library/alloc/src/collections/vec_deque/into_iter.rs index 18a1891a3f3ed..477ab0c4db594 100644 --- a/library/alloc/src/collections/vec_deque/into_iter.rs +++ b/library/alloc/src/collections/vec_deque/into_iter.rs @@ -17,18 +17,19 @@ use super::VecDeque; pub struct IntoIter< T, #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global, + const COOP_PREFERRED: bool = true > -where [(); alloc::co_alloc_metadata_num_slots::()]: { - inner: VecDeque, +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { + inner: VecDeque, } -impl IntoIter +impl IntoIter where [(); alloc::co_alloc_metadata_num_slots::()]: { - pub(super) fn new(inner: VecDeque) -> Self { + pub(super) fn new(inner: VecDeque) -> Self { IntoIter { inner } } - pub(super) fn into_vecdeque(self) -> VecDeque { + pub(super) fn into_vecdeque(self) -> VecDeque { self.inner } } diff --git a/library/alloc/src/collections/vec_deque/mod.rs b/library/alloc/src/collections/vec_deque/mod.rs index 0d1c562825ede..95fda23c22274 100644 --- a/library/alloc/src/collections/vec_deque/mod.rs +++ b/library/alloc/src/collections/vec_deque/mod.rs @@ -153,10 +153,10 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE } #[stable(feature = "rust1", since = "1.0.0")] -impl Default for VecDeque { +impl Default for VecDeque { /// Creates an empty deque. #[inline] - fn default() -> VecDeque { + fn default() -> VecDeque { VecDeque::new() } } @@ -536,7 +536,8 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE } } -impl VecDeque { +impl VecDeque +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { /// Creates an empty deque. /// /// # Examples @@ -550,7 +551,7 @@ impl VecDeque { #[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 { + pub const fn new() -> VecDeque { // FIXME: This should just be `VecDeque::new_in(Global)` once that hits stable. VecDeque { head: 0, len: 0, buf: RawVec::NEW } } @@ -567,7 +568,7 @@ impl VecDeque { #[inline] #[stable(feature = "rust1", since = "1.0.0")] #[must_use] - pub fn with_capacity(capacity: usize) -> VecDeque { + pub fn with_capacity(capacity: usize) -> VecDeque { Self::with_capacity_in(capacity, Global) } } @@ -585,7 +586,7 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE /// ``` #[inline] #[unstable(feature = "allocator_api", issue = "32838")] - pub const fn new_in(alloc: A) -> VecDeque { + pub const fn new_in(alloc: A) -> VecDeque { VecDeque { head: 0, len: 0, buf: RawVec::new_in(alloc) } } @@ -599,7 +600,7 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE /// let deque: VecDeque = VecDeque::with_capacity(10); /// ``` #[unstable(feature = "allocator_api", issue = "32838")] - pub fn with_capacity_in(capacity: usize, alloc: A) -> VecDeque { + pub fn with_capacity_in(capacity: usize, alloc: A) -> VecDeque { VecDeque { head: 0, len: 0, buf: RawVec::with_capacity_in(capacity, alloc) } } @@ -2892,7 +2893,7 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE /// assert_eq!(vec, [8, 9, 1, 2, 3, 4]); /// assert_eq!(vec.as_ptr(), ptr); /// ``` - fn from(mut other: VecDeque) -> Self { + fn from(mut other: VecDeque) -> Self { other.make_contiguous(); unsafe { @@ -2905,6 +2906,7 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE if other.head != 0 { ptr::copy(buf.add(other.head), buf, len); } + // @TODO: Vec::from_raw_parts_in(buf, len, cap, alloc) } } diff --git a/library/std/src/io/impls.rs b/library/std/src/io/impls.rs index e5048dcc8acd9..d575d9fa3f990 100644 --- a/library/std/src/io/impls.rs +++ b/library/std/src/io/impls.rs @@ -414,7 +414,8 @@ impl Write for Vec { /// Read is implemented for `VecDeque` by consuming bytes from the front of the `VecDeque`. #[stable(feature = "vecdeque_read_write", since = "1.63.0")] -impl Read for VecDeque { +impl Read for VecDeque +where [(); co_alloc_metadata_num_slots_with_preference::(_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 +439,8 @@ impl Read for VecDeque { /// Write is implemented for `VecDeque` by appending to the `VecDeque`, growing it as needed. #[stable(feature = "vecdeque_read_write", since = "1.63.0")] -impl Write for VecDeque { +impl Write for VecDeque +where [(); co_alloc_metadata_num_slots_with_preference::(_COOP_PREFERRED)]: { #[inline] fn write(&mut self, buf: &[u8]) -> io::Result { self.extend(buf); From b221045e63922f25fcf57c4c8ca65b06cc86ae1a Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sat, 21 Jan 2023 21:53:16 -0800 Subject: [PATCH 13/80] CoAlloc: Vec + Slice. ICE --- library/alloc/src/raw_vec.rs | 3 ++- library/alloc/src/slice.rs | 30 ++++++++++++------------- library/alloc/src/vec/drain.rs | 2 +- library/alloc/src/vec/into_iter.rs | 2 +- library/alloc/src/vec/mod.rs | 16 ++++++------- library/alloc/src/vec/spec_extend.rs | 20 ++++++++--------- library/alloc/src/vec/spec_from_elem.rs | 20 ++++++++--------- 7 files changed, 47 insertions(+), 46 deletions(-) diff --git a/library/alloc/src/raw_vec.rs b/library/alloc/src/raw_vec.rs index 19f1ef0ac06e1..b231d6785b0d9 100644 --- a/library/alloc/src/raw_vec.rs +++ b/library/alloc/src/raw_vec.rs @@ -62,7 +62,8 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE pub(crate) metas: [GlobalCoAllocMeta; alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)], } -impl RawVec { +impl RawVec +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { /// HACK(Centril): This exists because stable `const fn` can only call stable `const fn`, so /// they cannot call `Self::new()`. /// diff --git a/library/alloc/src/slice.rs b/library/alloc/src/slice.rs index 00da725042141..5184204056b92 100644 --- a/library/alloc/src/slice.rs +++ b/library/alloc/src/slice.rs @@ -97,8 +97,8 @@ 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(b: Box<[T], A>) -> Vec - where [(); core::alloc::co_alloc_metadata_num_slots::()]: { + pub fn into_vec(b: Box<[T], A>) -> Vec + where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { unsafe { let len = b.len(); let (b, alloc) = Box::into_raw_with_allocator(b); @@ -108,31 +108,31 @@ pub(crate) mod hack { #[cfg(not(no_global_oom_handling))] #[inline] - pub fn to_vec(s: &[T], alloc: A) -> Vec - where [(); core::alloc::co_alloc_metadata_num_slots::()]: { + pub fn to_vec(s: &[T], alloc: A) -> Vec + where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { T::to_vec(s, alloc) } #[cfg(not(no_global_oom_handling))] pub trait ConvertVec { - fn to_vec(s: &[Self], alloc: A) -> Vec + fn to_vec(s: &[Self], alloc: A) -> Vec where Self: Sized, - [(); core::alloc::co_alloc_metadata_num_slots::()]:; + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:; } #[cfg(not(no_global_oom_handling))] impl ConvertVec for T { #[inline] - default fn to_vec(s: &[Self], alloc: A) -> Vec - where [(); core::alloc::co_alloc_metadata_num_slots::()]: { - struct DropGuard<'a, T, A: Allocator> - where [(); core::alloc::co_alloc_metadata_num_slots::()]: { - vec: &'a mut Vec, + default fn to_vec(s: &[Self], alloc: A) -> Vec + where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { + struct DropGuard<'a, T, A: Allocator, const COOP_PREFERRED: bool> + where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { + vec: &'a mut Vec, num_init: usize, } - impl<'a, T, A: Allocator> Drop for DropGuard<'a, T, A> - where [(); core::alloc::co_alloc_metadata_num_slots::()]: { + 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::(COOP_PREFERRED)]: { #[inline] fn drop(&mut self) { // SAFETY: @@ -164,8 +164,8 @@ pub(crate) mod hack { #[cfg(not(no_global_oom_handling))] impl ConvertVec for T { #[inline] - fn to_vec(s: &[Self], alloc: A) -> Vec - where [(); core::alloc::co_alloc_metadata_num_slots::()]: { + fn to_vec(s: &[Self], alloc: A) -> Vec + where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(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 diff --git a/library/alloc/src/vec/drain.rs b/library/alloc/src/vec/drain.rs index 6372333bda81d..e0dc758b87b59 100644 --- a/library/alloc/src/vec/drain.rs +++ b/library/alloc/src/vec/drain.rs @@ -32,7 +32,7 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE pub(super) tail_len: usize, /// Current remaining range to remove pub(super) iter: slice::Iter<'a, T>, - pub(super) vec: NonNull>, + pub(super) vec: NonNull>, } #[stable(feature = "collection_debug", since = "1.17.0")] diff --git a/library/alloc/src/vec/into_iter.rs b/library/alloc/src/vec/into_iter.rs index fdad67de09716..d07aad4724ccd 100644 --- a/library/alloc/src/vec/into_iter.rs +++ b/library/alloc/src/vec/into_iter.rs @@ -144,7 +144,7 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE #[cfg(not(no_global_oom_handling))] #[inline] - pub(crate) fn into_vecdeque(self) -> VecDeque { + pub(crate) fn into_vecdeque(self) -> VecDeque { // Keep our `Drop` impl from dropping the elements and the allocator let mut this = ManuallyDrop::new(self); diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs index 1f8607a05a442..cd57a6b9ccbb1 100644 --- a/library/alloc/src/vec/mod.rs +++ b/library/alloc/src/vec/mod.rs @@ -2483,7 +2483,7 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PR /// assert_eq!(flattened.pop(), Some(6)); /// ``` #[unstable(feature = "slice_flatten", issue = "95629")] - pub fn into_flattened(self) -> Vec { + pub fn into_flattened(self) -> Vec { 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) @@ -3129,17 +3129,17 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PR } #[stable(feature = "rust1", since = "1.0.0")] -impl AsRef> for Vec +impl AsRef> for Vec where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { - fn as_ref(&self) -> &Vec { + fn as_ref(&self) -> &Vec { self } } #[stable(feature = "vec_as_mut", since = "1.5.0")] -impl AsMut> for Vec +impl AsMut> for Vec where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { - fn as_mut(&mut self) -> &mut Vec { + fn as_mut(&mut self) -> &mut Vec { self } } @@ -3291,7 +3291,7 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PR /// /// assert_eq!(Box::from(vec), vec![1, 2, 3].into_boxed_slice()); /// ``` - fn from(v: Vec) -> Self { + fn from(v: Vec) -> Self { v.into_boxed_slice() } } @@ -3314,7 +3314,7 @@ impl From<&str> for Vec { #[stable(feature = "array_try_from_vec", since = "1.48.0")] impl TryFrom> for [T; N] where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { - type Error = Vec; + type Error = Vec; /// Gets the entire contents of the `Vec` as an array, /// if its size exactly matches that of the requested array. @@ -3342,7 +3342,7 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PR /// assert_eq!(a, b' '); /// assert_eq!(b, b'd'); /// ``` - fn try_from(mut vec: Vec) -> Result<[T; N], Vec> { + fn try_from(mut vec: Vec) -> Result<[T; N], Vec> { if vec.len() != N { return Err(vec); } diff --git a/library/alloc/src/vec/spec_extend.rs b/library/alloc/src/vec/spec_extend.rs index 81245a394b22e..87bdb3aaab7a5 100644 --- a/library/alloc/src/vec/spec_extend.rs +++ b/library/alloc/src/vec/spec_extend.rs @@ -10,28 +10,28 @@ pub(super) trait SpecExtend { fn spec_extend(&mut self, iter: I); } -impl SpecExtend for Vec +impl SpecExtend for Vec where I: Iterator, - [(); alloc::co_alloc_metadata_num_slots::()]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { default fn spec_extend(&mut self, iter: I) { self.extend_desugared(iter) } } -impl SpecExtend for Vec +impl SpecExtend for Vec where I: TrustedLen, - [(); alloc::co_alloc_metadata_num_slots::()]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { default fn spec_extend(&mut self, iterator: I) { self.extend_trusted(iterator) } } -impl SpecExtend> for Vec -where [(); alloc::co_alloc_metadata_num_slots::()]: { +impl SpecExtend> for Vec +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { fn spec_extend(&mut self, mut iterator: IntoIter) { unsafe { self.append_elements(iterator.as_slice() as _); @@ -40,21 +40,21 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { } } -impl<'a, T: 'a, I, A: Allocator + 'a> SpecExtend<&'a T, I> for Vec +impl<'a, T: 'a, I, A: Allocator + 'a, const COOP_PREFERRED: bool> SpecExtend<&'a T, I> for Vec where I: Iterator, T: Clone, - [(); alloc::co_alloc_metadata_num_slots::()]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(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 +impl<'a, T: 'a, A: Allocator + 'a, const COOP_PREFERRED: bool> SpecExtend<&'a T, slice::Iter<'a, T>> for Vec where T: Copy, - [(); alloc::co_alloc_metadata_num_slots::()]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(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 7f95539b12d96..682375a607837 100644 --- a/library/alloc/src/vec/spec_from_elem.rs +++ b/library/alloc/src/vec/spec_from_elem.rs @@ -8,13 +8,13 @@ use super::{ExtendElement, IsZero, Vec}; // Specialization trait used for Vec::from_elem pub(super) trait SpecFromElem: Sized { - fn from_elem(elem: Self, n: usize, alloc: A) -> Vec - where [(); alloc::co_alloc_metadata_num_slots::()]: ; + fn from_elem(elem: Self, n: usize, alloc: A) -> Vec + where [(); alloc::co_alloc_metadata_num_slots::(COOP_PREFERRED)]: ; } impl SpecFromElem for T { - default fn from_elem(elem: Self, n: usize, alloc: A) -> Vec - where [(); alloc::co_alloc_metadata_num_slots::()]: { + default fn from_elem(elem: Self, n: usize, alloc: A) -> Vec + where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { let mut v = Vec::with_capacity_in(n, alloc); v.extend_with(n, ExtendElement(elem)); v @@ -23,8 +23,8 @@ impl SpecFromElem for T { impl SpecFromElem for T { #[inline] - default fn from_elem(elem: T, n: usize, alloc: A) -> Vec - where [(); alloc::co_alloc_metadata_num_slots::()]: { + default fn from_elem(elem: T, n: usize, alloc: A) -> Vec + where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { if elem.is_zero() { return Vec { buf: RawVec::with_capacity_zeroed_in(n, alloc), len: n }; } @@ -36,8 +36,8 @@ impl SpecFromElem for T { impl SpecFromElem for i8 { #[inline] - fn from_elem(elem: i8, n: usize, alloc: A) -> Vec - where [(); alloc::co_alloc_metadata_num_slots::()]: { + fn from_elem(elem: i8, n: usize, alloc: A) -> Vec + where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { if elem == 0 { return Vec { buf: RawVec::with_capacity_zeroed_in(n, alloc), len: n }; } @@ -52,8 +52,8 @@ impl SpecFromElem for i8 { impl SpecFromElem for u8 { #[inline] - fn from_elem(elem: u8, n: usize, alloc: A) -> Vec - where [(); alloc::co_alloc_metadata_num_slots::()]: { + fn from_elem(elem: u8, n: usize, alloc: A) -> Vec + where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { if elem == 0 { return Vec { buf: RawVec::with_capacity_zeroed_in(n, alloc), len: n }; } From 6ee4ede5935016838af1b758b198ee5d2e79fb67 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sat, 21 Jan 2023 21:53:30 -0800 Subject: [PATCH 14/80] CoAlloc: VecDeque. ICE --- library/alloc/src/collections/vec_deque/mod.rs | 13 ++++++++----- .../src/collections/vec_deque/spec_from_iter.rs | 11 ++++++++--- 2 files changed, 16 insertions(+), 8 deletions(-) diff --git a/library/alloc/src/collections/vec_deque/mod.rs b/library/alloc/src/collections/vec_deque/mod.rs index 95fda23c22274..d21b39feddffb 100644 --- a/library/alloc/src/collections/vec_deque/mod.rs +++ b/library/alloc/src/collections/vec_deque/mod.rs @@ -8,7 +8,7 @@ #![feature(global_co_alloc)] #![stable(feature = "rust1", since = "1.0.0")] -use core::alloc; +use core::alloc::{self, GlobalAlloc}; use core::cmp::{self, Ordering}; use core::fmt; use core::hash::{Hash, Hasher}; @@ -2758,8 +2758,9 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE } #[stable(feature = "rust1", since = "1.0.0")] -impl FromIterator for VecDeque { - fn from_iter>(iter: I) -> VecDeque { +impl FromIterator for VecDeque +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { + fn from_iter>(iter: I) -> VecDeque { SpecFromIter::spec_from_iter(iter.into_iter()) } } @@ -2855,7 +2856,8 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE /// and to not re-allocate the `Vec`'s buffer or allocate /// any additional memory. #[inline] - fn from(other: Vec) -> Self { + fn from(other: Vec) -> Self + where [(); alloc::co_alloc_metadata_num_slots_with_preference::(OTHER_COOP_PREFERRED)]: { 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) } } } @@ -2913,7 +2915,8 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE } #[stable(feature = "std_collections_from_array", since = "1.56.0")] -impl From<[T; N]> for VecDeque { +impl From<[T; N]> for VecDeque +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { /// Converts a `[T; N]` into a `VecDeque`. /// /// ``` 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..b9641ef156c88 100644 --- a/library/alloc/src/collections/vec_deque/spec_from_iter.rs +++ b/library/alloc/src/collections/vec_deque/spec_from_iter.rs @@ -1,13 +1,16 @@ use super::{IntoIter, VecDeque}; +use crate::alloc::Allocator; +use core::alloc; /// Specialization trait used for `VecDeque::from_iter` pub(super) trait SpecFromIter { fn spec_from_iter(iter: I) -> Self; } -impl SpecFromIter for VecDeque +impl SpecFromIter for VecDeque where I: Iterator, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { default fn spec_from_iter(iterator: I) -> Self { // Since converting is O(1) now, just re-use the `Vec` logic for @@ -18,14 +21,16 @@ where } } -impl SpecFromIter> for VecDeque { +impl SpecFromIter> for VecDeque +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { #[inline] fn spec_from_iter(iterator: crate::vec::IntoIter) -> Self { iterator.into_vecdeque() } } -impl SpecFromIter> for VecDeque { +impl SpecFromIter> for VecDeque +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { #[inline] fn spec_from_iter(iterator: IntoIter) -> Self { iterator.into_vecdeque() From eeb4214b3079bc7cc4c69d76f7354936a0ae3b47 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sat, 21 Jan 2023 21:59:55 -0800 Subject: [PATCH 15/80] CoAlloc: Minor --- library/core/src/alloc/global.rs | 4 ++-- library/core/src/alloc/mod.rs | 11 ++++++----- library/std/src/alloc.rs | 2 +- 3 files changed, 9 insertions(+), 8 deletions(-) diff --git a/library/core/src/alloc/global.rs b/library/core/src/alloc/global.rs index fd47d6cf88025..b0d457ff8c4d9 100644 --- a/library/core/src/alloc/global.rs +++ b/library/core/src/alloc/global.rs @@ -166,7 +166,7 @@ pub unsafe trait GlobalAlloc { 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!("TODO")} + 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`. /// @@ -184,7 +184,7 @@ pub unsafe trait GlobalAlloc { 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!("TODO")} + 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. diff --git a/library/core/src/alloc/mod.rs b/library/core/src/alloc/mod.rs index 9359273ca0a3a..7993e8e546d89 100644 --- a/library/core/src/alloc/mod.rs +++ b/library/core/src/alloc/mod.rs @@ -25,7 +25,7 @@ use crate::error::Error; use crate::fmt; use crate::ptr::{self, NonNull}; -// @TODO Make this target-specific +// @FIXME Make this target-specific #[unstable(feature = "global_co_alloc_meta", issue = "none")] #[allow(missing_debug_implementations)] #[derive(Clone, Copy)] @@ -156,7 +156,8 @@ pub unsafe trait Allocator { // 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?! TODO + // 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. @@ -181,7 +182,7 @@ pub unsafe trait Allocator { /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html fn allocate(&self, layout: Layout) -> Result, AllocError>; - fn co_allocate(&self, _layout: Layout, _result: &mut SliceAndMetaResult) {panic!("TODO")} + fn co_allocate(&self, _layout: Layout, _result: &mut SliceAndMetaResult) {panic!("FIXME")} /// Behaves like `allocate`, but also ensures that the returned memory is zero-initialized. /// @@ -229,7 +230,7 @@ pub unsafe trait Allocator { /// [*fit*]: #memory-fitting unsafe fn deallocate(&self, ptr: NonNull, layout: Layout); - unsafe fn co_deallocate(&self, _ptr_and_meta: PtrAndMeta, _layout: Layout) {panic!("TODO")} + unsafe fn co_deallocate(&self, _ptr_and_meta: PtrAndMeta, _layout: Layout) {panic!("FIXME")} /// Attempts to extend the memory block. /// @@ -527,7 +528,7 @@ pub unsafe trait Allocator { } } -// @TODO +// @FIXME #[unstable(feature = "allocator_api", issue = "32838")] unsafe impl Allocator for &A where diff --git a/library/std/src/alloc.rs b/library/std/src/alloc.rs index bee6edbc40731..6969c7d81dd5e 100644 --- a/library/std/src/alloc.rs +++ b/library/std/src/alloc.rs @@ -197,7 +197,7 @@ impl System { } } -// @TODO +// @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")] From 6c3801da7b556877d62bf2d76f1e546cd0e970cd Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sat, 21 Jan 2023 22:00:15 -0800 Subject: [PATCH 16/80] CoAlloc: Vec + its use cases. ICE --- library/alloc/src/raw_vec.rs | 8 ++--- library/alloc/src/vec/mod.rs | 30 ++++++++++++------- library/std/src/io/cursor.rs | 25 ++++++++++------ library/std/src/io/impls.rs | 3 +- .../std/src/sys/hermit/thread_local_dtor.rs | 4 ++- .../std/src/sys/solid/thread_local_dtor.rs | 6 ++-- library/std/src/sys/unix/thread_local_dtor.rs | 5 +++- .../std/src/sys/windows/thread_local_dtor.rs | 5 +++- 8 files changed, 57 insertions(+), 29 deletions(-) diff --git a/library/alloc/src/raw_vec.rs b/library/alloc/src/raw_vec.rs index b231d6785b0d9..58e8d72fc2d25 100644 --- a/library/alloc/src/raw_vec.rs +++ b/library/alloc/src/raw_vec.rs @@ -14,6 +14,7 @@ use crate::alloc::{Allocator, Global, Layout}; use crate::boxed::Box; use crate::collections::TryReserveError; use crate::collections::TryReserveErrorKind::*; +use crate::vec::DEFAULT_COOP_PREFERRED; #[cfg(test)] mod tests; @@ -49,8 +50,7 @@ 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)] -// @TODO apply `_coop` with logical && to `A::IsCoAllocator` -pub(crate) struct RawVec +pub(crate) struct RawVec where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { ptr: Unique, @@ -506,12 +506,12 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE } } -// @TODO Custom +// @FIXME Custom unsafe impl<#[may_dangle] T, const COOP_PREFERRED: bool> Drop for RawVec where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { /// Frees the memory owned by the `RawVec` *without* trying to drop its contents. fn drop(&mut self) { - // @TODO + // @TOFIXMEDO if let Some((ptr, layout)) = self.current_memory() { unsafe { self.alloc.deallocate(ptr, layout) } } diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs index cd57a6b9ccbb1..cbd286054a9b5 100644 --- a/library/alloc/src/vec/mod.rs +++ b/library/alloc/src/vec/mod.rs @@ -397,24 +397,34 @@ mod spec_extend; #[stable(feature = "rust1", since = "1.0.0")] #[cfg_attr(not(test), rustc_diagnostic_item = "Vec")] #[rustc_insignificant_dtor] -// @TODO _coop -pub struct Vec +pub struct Vec where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { buf: RawVec, len: usize, } -#[unstable(feature = "global_co_alloc_vec", issue = "none")] -pub type CoVec = Vec; +#[unstable(feature = "global_co_alloc_covec", issue = "none")] +pub type CoVec = Vec; + +/// "Plain" Vec. Not "cooperative" - not carrying extra data to assist the allocator. +#[unstable(feature = "global_co_alloc_plvec", issue = "none")] +pub type PlVec = Vec; + +/// 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; + +/// "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")] +pub type DefVec = Vec; -/// "Plain" Vec. -#[unstable(feature = "global_co_alloc_vec", issue = "none")] -pub type PlVec = Vec; -/// "Weighted" Vec. -/// weight means how much it wants to cooperate. 0 = always pack; u8::MAX = always coop (if `Global` supports it). -/// @TODO Weighing on the side of Allocator - const fn. +/// "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 = Vec1}>; diff --git a/library/std/src/io/cursor.rs b/library/std/src/io/cursor.rs index d98ab021cadb1..33d1ee065de2a 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,12 @@ fn slice_write_vectored( } /// Reserves the required space, and pads the vec with 0s if necessary. -fn reserve_and_pad( +fn reserve_and_pad( pos_mut: &mut u64, - vec: &mut Vec, + vec: &mut Vec, buf_len: usize, -) -> io::Result { +) -> io::Result +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { let pos: usize = (*pos_mut).try_into().map_err(|_| { io::const_io_error!( ErrorKind::InvalidInput, @@ -440,9 +442,10 @@ fn reserve_and_pad( /// Writes the slice to the vec without allocating /// # Safety: vec must have buf.len() spare capacity -unsafe fn vec_write_unchecked(pos: usize, vec: &mut Vec, buf: &[u8]) -> usize +unsafe fn vec_write_unchecked(pos: usize, vec: &mut Vec, buf: &[u8]) -> usize where A: Allocator, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { debug_assert!(vec.capacity() >= pos + buf.len()); vec.as_mut_ptr().add(pos).copy_from(buf.as_ptr(), buf.len()); @@ -458,9 +461,10 @@ 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(pos_mut: &mut u64, vec: &mut Vec, buf: &[u8]) -> io::Result +fn vec_write(pos_mut: &mut u64, vec: &mut Vec, buf: &[u8]) -> io::Result where A: Allocator, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { let buf_len = buf.len(); let mut pos = reserve_and_pad(pos_mut, vec, buf_len)?; @@ -489,13 +493,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( +fn vec_write_vectored( pos_mut: &mut u64, - vec: &mut Vec, + vec: &mut Vec, bufs: &[IoSlice<'_>], ) -> io::Result where A: Allocator, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(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 +548,10 @@ impl Write for Cursor<&mut [u8]> { } #[stable(feature = "cursor_mut_vec", since = "1.25.0")] -impl Write for Cursor<&mut Vec> +impl Write for Cursor<&mut Vec> where A: Allocator, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { fn write(&mut self, buf: &[u8]) -> io::Result { vec_write(&mut self.pos, self.inner, buf) @@ -567,9 +573,10 @@ where } #[stable(feature = "rust1", since = "1.0.0")] -impl Write for Cursor> +impl Write for Cursor> where A: Allocator, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { fn write(&mut self, buf: &[u8]) -> io::Result { 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 d575d9fa3f990..ec3394e0b16c1 100644 --- a/library/std/src/io/impls.rs +++ b/library/std/src/io/impls.rs @@ -378,7 +378,8 @@ impl Write for &mut [u8] { /// Write is implemented for `Vec` by appending to the vector. /// The vector will grow as needed. #[stable(feature = "rust1", since = "1.0.0")] -impl Write for Vec { +impl Write for Vec +where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { #[inline] fn write(&mut self, buf: &[u8]) -> io::Result { self.extend_from_slice(buf); diff --git a/library/std/src/sys/hermit/thread_local_dtor.rs b/library/std/src/sys/hermit/thread_local_dtor.rs index 613266b9530a8..9816a7f200b6f 100644 --- a/library/std/src/sys/hermit/thread_local_dtor.rs +++ b/library/std/src/sys/hermit/thread_local_dtor.rs @@ -1,14 +1,16 @@ #![cfg(target_thread_local)] #![unstable(feature = "thread_local_internals", issue = "none")] +#![feature(global_co_alloc_plvec)] // Simplify dtor registration by using a list of destructors. // The this solution works like the implementation of macOS and // doesn't additional OS support +use core::alloc::PlVec; use crate::mem; #[thread_local] -static mut DTORS: Vec<(*mut u8, unsafe extern "C" fn(*mut u8))> = Vec::new(); +static mut DTORS: PlVec<(*mut u8, unsafe extern "C" fn(*mut u8))> = PlVec::new(); pub unsafe fn register_dtor(t: *mut u8, dtor: unsafe extern "C" fn(*mut u8)) { let list = &mut DTORS; diff --git a/library/std/src/sys/solid/thread_local_dtor.rs b/library/std/src/sys/solid/thread_local_dtor.rs index bad14bb37f720..5468264393b55 100644 --- a/library/std/src/sys/solid/thread_local_dtor.rs +++ b/library/std/src/sys/solid/thread_local_dtor.rs @@ -1,17 +1,19 @@ #![cfg(target_thread_local)] -#![unstable(feature = "thread_local_internals", issue = "none")] +#![unstable(feature = "thread_local_internals", issue = "none")]#![feature(global_co_alloc_plvec)] +#![feature(global_co_alloc_plvec)] // Simplify dtor registration by using a list of destructors. use super::{abi, itron::task}; use crate::cell::Cell; use crate::mem; +use core::alloc::PlVec; #[thread_local] static REGISTERED: Cell = Cell::new(false); #[thread_local] -static mut DTORS: Vec<(*mut u8, unsafe extern "C" fn(*mut u8))> = Vec::new(); +static mut DTORS: PlVec<(*mut u8, unsafe extern "C" fn(*mut u8))> = PlVec::new(); pub unsafe fn register_dtor(t: *mut u8, dtor: unsafe extern "C" fn(*mut u8)) { if !REGISTERED.get() { diff --git a/library/std/src/sys/unix/thread_local_dtor.rs b/library/std/src/sys/unix/thread_local_dtor.rs index c31fb3a48dabb..1eea75e16d338 100644 --- a/library/std/src/sys/unix/thread_local_dtor.rs +++ b/library/std/src/sys/unix/thread_local_dtor.rs @@ -1,5 +1,8 @@ #![cfg(target_thread_local)] #![unstable(feature = "thread_local_internals", issue = "none")] +#![feature(global_co_alloc_plvec)] + +use core::alloc::PlVec; //! Provides thread-local destructors without an associated "key", which //! can be more efficient. @@ -64,7 +67,7 @@ pub unsafe fn register_dtor(t: *mut u8, dtor: unsafe extern "C" fn(*mut u8)) { static REGISTERED: Cell = Cell::new(false); #[thread_local] - static mut DTORS: Vec<(*mut u8, unsafe extern "C" fn(*mut u8))> = Vec::new(); + static mut DTORS: PlVec<(*mut u8, unsafe extern "C" fn(*mut u8))> = PlVec::new(); if !REGISTERED.get() { _tlv_atexit(run_dtors, ptr::null_mut()); 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. From 682f1e03f880be06a9a6d78b5a4a031083fde2b0 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sat, 21 Jan 2023 22:00:42 -0800 Subject: [PATCH 17/80] CoAlloc: VecDeque minor. ICE --- library/alloc/src/collections/vec_deque/mod.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/library/alloc/src/collections/vec_deque/mod.rs b/library/alloc/src/collections/vec_deque/mod.rs index d21b39feddffb..694d733f68a54 100644 --- a/library/alloc/src/collections/vec_deque/mod.rs +++ b/library/alloc/src/collections/vec_deque/mod.rs @@ -9,6 +9,7 @@ #![stable(feature = "rust1", since = "1.0.0")] use core::alloc::{self, GlobalAlloc}; +use crate::vec::DEFAULT_COOP_PREFERRED; use core::cmp::{self, Ordering}; use core::fmt; use core::hash::{Hash, Hasher}; @@ -93,11 +94,10 @@ mod tests; #[cfg_attr(not(test), rustc_diagnostic_item = "VecDeque")] #[stable(feature = "rust1", since = "1.0.0")] #[rustc_insignificant_dtor] -// @TODO pub struct VecDeque< T, #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global, - const COOP_PREFERRED: bool = true + const COOP_PREFERRED: bool = DEFAULT_COOP_PREFERRED > where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { @@ -2908,7 +2908,7 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE if other.head != 0 { ptr::copy(buf.add(other.head), buf, len); } - // @TODO: + // @FIXME: COOP Vec::from_raw_parts_in(buf, len, cap, alloc) } } From 3cdb2d941478e39d619be1bad75825b36b283787 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sat, 21 Jan 2023 22:06:08 -0800 Subject: [PATCH 18/80] CoAlloc: Vec, Alloc, GlobalAlloc: x test tidy --bless. ICE --- compiler/rustc_middle/src/mir/mod.rs | 2 +- compiler/rustc_middle/src/mir/syntax.rs | 2 +- .../rustc_parse/src/parser/attr_wrapper.rs | 2 +- compiler/rustc_parse/src/parser/mod.rs | 7 +- library/alloc/src/boxed.rs | 34 ++- library/alloc/src/raw_vec.rs | 65 +++-- library/alloc/src/slice.rs | 62 +++-- library/alloc/src/vec/drain.rs | 90 +++++-- library/alloc/src/vec/drain_filter.rs | 23 +- library/alloc/src/vec/into_iter.rs | 123 +++++++--- library/alloc/src/vec/mod.rs | 230 +++++++++++++----- library/alloc/src/vec/spec_extend.rs | 23 +- library/alloc/src/vec/spec_from_elem.rs | 51 +++- library/alloc/src/vec/splice.rs | 29 ++- library/alloc/tests/boxed.rs | 2 +- library/core/src/alloc/global.rs | 12 +- library/core/src/alloc/mod.rs | 33 +-- library/std/src/io/cursor.rs | 26 +- library/std/src/io/impls.rs | 12 +- library/std/src/sys/unix/thread_local_dtor.rs | 4 +- src/librustdoc/html/render/context.rs | 5 +- 21 files changed, 592 insertions(+), 245 deletions(-) diff --git a/compiler/rustc_middle/src/mir/mod.rs b/compiler/rustc_middle/src/mir/mod.rs index 1d9c893500a7f..06984646bead5 100644 --- a/compiler/rustc_middle/src/mir/mod.rs +++ b/compiler/rustc_middle/src/mir/mod.rs @@ -2,7 +2,6 @@ //! //! [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/mir/index.html -use core::alloc::GlobalCoAllocMeta; use crate::mir::interpret::{ AllocRange, ConstAllocation, ConstValue, ErrorHandled, GlobalAlloc, LitToConstInput, Scalar, }; @@ -14,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; diff --git a/compiler/rustc_middle/src/mir/syntax.rs b/compiler/rustc_middle/src/mir/syntax.rs index cfaecf0775ff4..36cc4fa4cce3b 100644 --- a/compiler/rustc_middle/src/mir/syntax.rs +++ b/compiler/rustc_middle/src/mir/syntax.rs @@ -3,9 +3,9 @@ //! This is in a dedicated file so that changes to this file can be reviewed more carefully. //! 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 super::{BasicBlock, Constant, Field, Local, SwitchTargets, UserTypeProjection}; use crate::mir::coverage::{CodeRegion, CoverageKind}; use crate::traits::Reveal; diff --git a/compiler/rustc_parse/src/parser/attr_wrapper.rs b/compiler/rustc_parse/src/parser/attr_wrapper.rs index a8c2d8c2c59d3..df02751005ce8 100644 --- a/compiler/rustc_parse/src/parser/attr_wrapper.rs +++ b/compiler/rustc_parse/src/parser/attr_wrapper.rs @@ -1,6 +1,6 @@ +use super::{Capturing, FlatToken, ForceCollect, Parser, ReplaceRange, TokenCursor, TrailingToken}; use core::alloc::GlobalCoAllocMeta; use core::mem; -use super::{Capturing, FlatToken, ForceCollect, Parser, ReplaceRange, TokenCursor, TrailingToken}; use rustc_ast::token::{self, Delimiter, Token, TokenKind}; use rustc_ast::tokenstream::{AttrTokenStream, AttributesData, ToAttrTokenStream}; use rustc_ast::tokenstream::{AttrTokenTree, DelimSpan, LazyAttrTokenStream, Spacing}; diff --git a/compiler/rustc_parse/src/parser/mod.rs b/compiler/rustc_parse/src/parser/mod.rs index e8567a650d85f..8b66ec971b006 100644 --- a/compiler/rustc_parse/src/parser/mod.rs +++ b/compiler/rustc_parse/src/parser/mod.rs @@ -11,8 +11,8 @@ mod stmt; mod ty; use crate::lexer::UnmatchedBrace; -use core::alloc::GlobalCoAllocMeta; pub use attr_wrapper::AttrWrapper; +use core::alloc::GlobalCoAllocMeta; pub use diagnostics::AttemptLocalParseRecovery; pub(crate) use item::FnParseMode; pub use pat::{CommaRecoveryMode, RecoverColon, RecoverComma}; @@ -169,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 + 4 * mem::size_of::()); +rustc_data_structures::static_assert_size!( + Parser<'_>, + 336 + 4 * mem::size_of::() +); /// Stores span information about a closure. #[derive(Clone)] diff --git a/library/alloc/src/boxed.rs b/library/alloc/src/boxed.rs index 9dc695559a80e..021f36e6770bd 100644 --- a/library/alloc/src/boxed.rs +++ b/library/alloc/src/boxed.rs @@ -699,7 +699,12 @@ impl 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::::from_raw_parts_in( + ptr.as_mut_ptr() as *mut _, + len, + Global, + ) + .into_box(len)) } } @@ -731,13 +736,20 @@ impl 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::::from_raw_parts_in( + ptr.as_mut_ptr() as *mut _, + len, + Global, + ) + .into_box(len)) } } } impl Box<[T], A> -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +where + [(); core::alloc::co_alloc_metadata_num_slots::()]:, +{ /// Constructs a new boxed slice with uninitialized contents in the provided allocator. /// /// # Examples @@ -765,7 +777,10 @@ where [(); core::alloc::co_alloc_metadata_num_slots::()]: { // #[unstable(feature = "new_uninit", issue = "63291")] #[must_use] pub fn new_uninit_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit], A> { - unsafe { RawVec::::with_capacity_in(len, alloc).into_box(len) } + unsafe { + RawVec::::with_capacity_in(len, alloc) + .into_box(len) + } } /// Constructs a new boxed slice with uninitialized contents in the provided allocator, @@ -793,7 +808,12 @@ where [(); core::alloc::co_alloc_metadata_num_slots::()]: { // #[unstable(feature = "new_uninit", issue = "63291")] #[must_use] pub fn new_zeroed_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit], A> { - unsafe { RawVec::::with_capacity_zeroed_in(len, alloc).into_box(len) } + unsafe { + RawVec::::with_capacity_zeroed_in( + len, alloc, + ) + .into_box(len) + } } } @@ -2022,7 +2042,9 @@ impl FromIterator for Box<[I]> { #[cfg(not(no_global_oom_handling))] #[stable(feature = "box_slice_clone", since = "1.3.0")] impl Clone for Box<[T], A> -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +where + [(); core::alloc::co_alloc_metadata_num_slots::()]:, +{ fn clone(&self) -> Self { let alloc = Box::allocator(self).clone(); self.to_vec_in(alloc).into_boxed_slice() diff --git a/library/alloc/src/raw_vec.rs b/library/alloc/src/raw_vec.rs index 58e8d72fc2d25..84fd954edbd7a 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::{self, LayoutError, GlobalCoAllocMeta, PtrAndMeta}; +use core::alloc::{self, GlobalCoAllocMeta, LayoutError, PtrAndMeta}; use core::cmp; use core::intrinsics; use core::mem::{self, ManuallyDrop, MaybeUninit, SizedTypeProperties}; @@ -50,8 +50,12 @@ 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 -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: +pub(crate) struct RawVec< + T, + A: Allocator = Global, + const COOP_PREFERRED: bool = DEFAULT_COOP_PREFERRED, +> where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { ptr: Unique, cap: usize, @@ -59,11 +63,14 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE // As of v1.67.0, `cmp` for `TypeId` is not `const`, unfortunately: //pub(crate) meta: [GlobalCoAllocMeta; {if core::any::TypeId::of::()==core::any::TypeId::of::() {1} else {0}}], //pub(crate) meta: [GlobalCoAllocMeta; mem::size_of::()], - pub(crate) metas: [GlobalCoAllocMeta; alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)], + pub(crate) metas: [GlobalCoAllocMeta; + alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)], } impl RawVec -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ /// HACK(Centril): This exists because stable `const fn` can only call stable `const fn`, so /// they cannot call `Self::new()`. /// @@ -111,7 +118,8 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PRE } impl RawVec -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { // Tiny Vecs are dumb. Skip to: // - 8 if the element size is 1, because any heap allocators is likely @@ -130,8 +138,13 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE /// 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, - metas: [GlobalCoAllocMeta {/*one: 1*/ /* , two: 2, three: 3, four: 4*/}; alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)] } + 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::(COOP_PREFERRED)], + } } /// Like `with_capacity`, but parameterized over the choice of @@ -208,7 +221,8 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE 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::(COOP_PREFERRED)] + metas: [GlobalCoAllocMeta {/*one: 1*/ /*, two: 2, three: 3, four: 4*/}; + alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)], } } } @@ -225,7 +239,13 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE /// 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, metas: [GlobalCoAllocMeta {/*one: 1*/ /*, two: 2, three: 3, four: 4*/}; alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)] } + 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::(COOP_PREFERRED)], + } } /// Gets a raw pointer to the start of the allocation. Note that this is @@ -293,8 +313,8 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE slf: &mut RawVec, len: usize, additional: usize, - ) - where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: + ) where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { handle_reserve(slf.grow_amortized(len, additional)); } @@ -369,17 +389,16 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE } impl RawVec -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(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 - { + fn needs_to_grow(&self, len: usize, additional: usize) -> bool { additional > self.capacity().wrapping_sub(len) } - fn set_ptr_and_cap(&mut self, ptr: NonNull<[u8]>, cap: usize) - { + fn set_ptr_and_cap(&mut self, ptr: NonNull<[u8]>, cap: usize) { // Allocators currently return a `NonNull<[u8]>` whose length matches // the size requested. If that ever changes, the capacity here should // change to `ptr.len() / mem::size_of::()`. @@ -490,15 +509,17 @@ where memory.map_err(|_| AllocError { layout: new_layout, non_exhaustive: () }.into()) } -unsafe impl<#[may_dangle] T, A: Allocator, const COOP_PREFERRED: bool> Drop for RawVec -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: +unsafe impl<#[may_dangle] T, A: Allocator, const COOP_PREFERRED: bool> Drop + for RawVec +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { /// Frees the memory owned by the `RawVec` *without* trying to drop its contents. default fn drop(&mut self) { if let Some((ptr, layout)) = self.current_memory() { if A::IS_CO_ALLOCATOR && COOP_PREFERRED { let meta = self.metas[0]; - unsafe { self.alloc.co_deallocate(PtrAndMeta {ptr, meta}, layout) } + unsafe { self.alloc.co_deallocate(PtrAndMeta { ptr, meta }, layout) } } else { unsafe { self.alloc.deallocate(ptr, layout) } } @@ -508,7 +529,9 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE // @FIXME Custom unsafe impl<#[may_dangle] T, const COOP_PREFERRED: bool> Drop for RawVec -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ /// Frees the memory owned by the `RawVec` *without* trying to drop its contents. fn drop(&mut self) { // @TOFIXMEDO diff --git a/library/alloc/src/slice.rs b/library/alloc/src/slice.rs index 5184204056b92..205e7b5f1d438 100644 --- a/library/alloc/src/slice.rs +++ b/library/alloc/src/slice.rs @@ -97,8 +97,12 @@ 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(b: Box<[T], A>) -> Vec - where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { + pub fn into_vec( + b: Box<[T], A>, + ) -> Vec + where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + { unsafe { let len = b.len(); let (b, alloc) = Box::into_raw_with_allocator(b); @@ -108,14 +112,22 @@ pub(crate) mod hack { #[cfg(not(no_global_oom_handling))] #[inline] - pub fn to_vec(s: &[T], alloc: A) -> Vec - where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { + pub fn to_vec( + s: &[T], + alloc: A, + ) -> Vec + where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + { T::to_vec(s, alloc) } #[cfg(not(no_global_oom_handling))] pub trait ConvertVec { - fn to_vec(s: &[Self], alloc: A) -> Vec + fn to_vec( + s: &[Self], + alloc: A, + ) -> Vec where Self: Sized, [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:; @@ -124,15 +136,24 @@ pub(crate) mod hack { #[cfg(not(no_global_oom_handling))] impl ConvertVec for T { #[inline] - default fn to_vec(s: &[Self], alloc: A) -> Vec - where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { + default fn to_vec( + s: &[Self], + alloc: A, + ) -> Vec + where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + { struct DropGuard<'a, T, A: Allocator, const COOP_PREFERRED: bool> - where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { + where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + { vec: &'a mut Vec, num_init: usize, } 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::(COOP_PREFERRED)]: { + where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + { #[inline] fn drop(&mut self) { // SAFETY: @@ -164,8 +185,13 @@ pub(crate) mod hack { #[cfg(not(no_global_oom_handling))] impl ConvertVec for T { #[inline] - fn to_vec(s: &[Self], alloc: A) -> Vec - where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { + fn to_vec( + s: &[Self], + alloc: A, + ) -> Vec + where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(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 @@ -443,7 +469,7 @@ impl [T] { pub fn to_vec_in(&self, alloc: A) -> Vec where T: Clone, - [(); core::alloc::co_alloc_metadata_num_slots::()]: + [(); core::alloc::co_alloc_metadata_num_slots::()]:, { // N.B., see the `hack` module in this file for more details. hack::to_vec(self, alloc) @@ -467,7 +493,9 @@ impl [T] { #[stable(feature = "rust1", since = "1.0.0")] #[inline] pub fn into_vec(self: Box) -> Vec - where [(); core::alloc::co_alloc_metadata_num_slots::()]: { + where + [(); core::alloc::co_alloc_metadata_num_slots::()]:, + { // N.B., see the `hack` module in this file for more details. hack::into_vec(self) } @@ -779,7 +807,9 @@ impl> Join<&[T]> for [V] { #[stable(feature = "rust1", since = "1.0.0")] impl Borrow<[T]> for Vec -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ fn borrow(&self) -> &[T] { &self[..] } @@ -787,7 +817,9 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PR #[stable(feature = "rust1", since = "1.0.0")] impl BorrowMut<[T]> for Vec -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ fn borrow_mut(&mut self) -> &mut [T] { &mut self[..] } diff --git a/library/alloc/src/vec/drain.rs b/library/alloc/src/vec/drain.rs index e0dc758b87b59..d7f7292e4f1cf 100644 --- a/library/alloc/src/vec/drain.rs +++ b/library/alloc/src/vec/drain.rs @@ -23,9 +23,10 @@ pub struct Drain< 'a, T: 'a, #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator + 'a = Global, - const COOP_PREFERRED: bool = {alloc::SHORT_TERM_VEC_PREFERS_COOP} -> -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { + const COOP_PREFERRED: bool = { alloc::SHORT_TERM_VEC_PREFERS_COOP }, +> where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ /// Index of tail to preserve pub(super) tail_start: usize, /// Length of tail @@ -36,15 +37,20 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE } #[stable(feature = "collection_debug", since = "1.17.0")] -impl fmt::Debug for Drain<'_, T, A, COOP_PREFERRED> -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +impl fmt::Debug + for Drain<'_, T, A, COOP_PREFERRED> +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(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, const COOP_PREFERRED: bool> Drain<'a, T, A, COOP_PREFERRED> -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ /// Returns the remaining items of this iterator as a slice. /// /// # Examples @@ -144,22 +150,34 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE #[stable(feature = "vec_drain_as_slice", since = "1.46.0")] 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::(COOP_PREFERRED)]: { +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ fn as_ref(&self) -> &[T] { self.as_slice() } } #[stable(feature = "drain", since = "1.6.0")] -unsafe impl Sync for Drain<'_, T, A, COOP_PREFERRED> -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: {} +unsafe impl Sync + for Drain<'_, T, A, COOP_PREFERRED> +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ +} #[stable(feature = "drain", since = "1.6.0")] -unsafe impl Send for Drain<'_, T, A, COOP_PREFERRED> -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: {} +unsafe impl Send + for Drain<'_, T, A, COOP_PREFERRED> +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ +} #[stable(feature = "drain", since = "1.6.0")] impl Iterator for Drain<'_, T, A, COOP_PREFERRED> -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ type Item = T; #[inline] @@ -173,8 +191,11 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE } #[stable(feature = "drain", since = "1.6.0")] -impl DoubleEndedIterator for Drain<'_, T, A, COOP_PREFERRED> -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +impl DoubleEndedIterator + for Drain<'_, T, A, COOP_PREFERRED> +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ #[inline] fn next_back(&mut self) -> Option { self.iter.next_back().map(|elt| unsafe { ptr::read(elt as *const _) }) @@ -183,14 +204,22 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE #[stable(feature = "drain", since = "1.6.0")] impl Drop for Drain<'_, T, A, COOP_PREFERRED> -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(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, const COOP_PREFERRED: bool>(&'r mut Drain<'a, T, A, COOP_PREFERRED>) - where [(); alloc::co_alloc_metadata_num_slots_with_preference::(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::(COOP_PREFERRED)]: { + 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::(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::(COOP_PREFERRED)]:, + { fn drop(&mut self) { if self.0.tail_len > 0 { unsafe { @@ -254,17 +283,26 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE } #[stable(feature = "drain", since = "1.6.0")] -impl ExactSizeIterator for Drain<'_, T, A, COOP_PREFERRED> -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +impl ExactSizeIterator + for Drain<'_, T, A, COOP_PREFERRED> +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ fn is_empty(&self) -> bool { self.iter.is_empty() } } #[unstable(feature = "trusted_len", issue = "37572")] -unsafe impl TrustedLen for Drain<'_, T, A, COOP_PREFERRED> -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: {} +unsafe impl TrustedLen + for Drain<'_, T, A, COOP_PREFERRED> +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ +} #[stable(feature = "fused", since = "1.26.0")] -impl FusedIterator for Drain<'_, T, A, COOP_PREFERRED> -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: {} +impl FusedIterator for Drain<'_, T, A, COOP_PREFERRED> where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: +{ +} diff --git a/library/alloc/src/vec/drain_filter.rs b/library/alloc/src/vec/drain_filter.rs index 7be4abacbec96..89baafca46729 100644 --- a/library/alloc/src/vec/drain_filter.rs +++ b/library/alloc/src/vec/drain_filter.rs @@ -24,10 +24,10 @@ pub struct DrainFilter< T, F, #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global, - const COOP_PREFERRED: bool = true + const COOP_PREFERRED: bool = true, > where F: FnMut(&mut T) -> bool, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { pub(super) vec: &'a mut Vec, /// The index of the item that will be inspected by the next call to `next`. @@ -49,7 +49,7 @@ pub struct DrainFilter< impl DrainFilter<'_, T, F, A, COOP_PREFERRED> where F: FnMut(&mut T) -> bool, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { /// Returns a reference to the underlying allocator. #[unstable(feature = "allocator_api", issue = "32838")] @@ -115,10 +115,11 @@ where } #[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")] -impl Iterator for DrainFilter<'_, T, F, A, COOP_PREFERRED> +impl Iterator + for DrainFilter<'_, T, F, A, COOP_PREFERRED> where F: FnMut(&mut T) -> bool, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { type Item = T; @@ -154,24 +155,26 @@ where } #[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")] -impl Drop for DrainFilter<'_, T, F, A, COOP_PREFERRED> +impl Drop + for DrainFilter<'_, T, F, A, COOP_PREFERRED> where F: FnMut(&mut T) -> bool, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn drop(&mut self) { 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::(COOP_PREFERRED)]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { drain: &'b mut DrainFilter<'a, T, F, A, COOP_PREFERRED>, } - impl<'a, 'b, T, F, A: Allocator, const COOP_PREFERRED: bool> Drop for BackshiftOnDrop<'a, 'b, T, F, A, COOP_PREFERRED> + 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::(COOP_PREFERRED)]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn drop(&mut self) { unsafe { diff --git a/library/alloc/src/vec/into_iter.rs b/library/alloc/src/vec/into_iter.rs index d07aad4724ccd..790e6323f514e 100644 --- a/library/alloc/src/vec/into_iter.rs +++ b/library/alloc/src/vec/into_iter.rs @@ -4,7 +4,6 @@ use crate::alloc::{Allocator, Global}; #[cfg(not(no_global_oom_handling))] use crate::collections::VecDeque; use crate::raw_vec::RawVec; -use core::{alloc, array, fmt}; use core::iter::{ FusedIterator, InPlaceIterable, SourceIter, TrustedLen, TrustedRandomAccessNoCoerce, }; @@ -14,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. /// @@ -31,9 +31,10 @@ use core::slice::{self}; pub struct IntoIter< T, #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global, - const COOP_PREFERRED: bool = {alloc::SHORT_TERM_VEC_PREFERS_COOP} -> -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { + const COOP_PREFERRED: bool = { alloc::SHORT_TERM_VEC_PREFERS_COOP }, +> where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ pub(super) buf: NonNull, pub(super) phantom: PhantomData, pub(super) cap: usize, @@ -47,15 +48,20 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE } #[stable(feature = "vec_intoiter_debug", since = "1.13.0")] -impl fmt::Debug for IntoIter -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +impl fmt::Debug + for IntoIter +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_tuple("IntoIter").field(&self.as_slice()).finish() } } impl IntoIter -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ /// Returns the remaining items of this iterator as a slice. /// /// # Examples @@ -172,22 +178,34 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE #[stable(feature = "vec_intoiter_as_ref", since = "1.46.0")] impl AsRef<[T]> for IntoIter -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ fn as_ref(&self) -> &[T] { self.as_slice() } } #[stable(feature = "rust1", since = "1.0.0")] -unsafe impl Send for IntoIter -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: {} +unsafe impl Send + for IntoIter +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ +} #[stable(feature = "rust1", since = "1.0.0")] -unsafe impl Sync for IntoIter -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: {} +unsafe impl Sync + for IntoIter +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ +} #[stable(feature = "rust1", since = "1.0.0")] impl Iterator for IntoIter -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ type Item = T; #[inline] @@ -301,8 +319,11 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE } #[stable(feature = "rust1", since = "1.0.0")] -impl DoubleEndedIterator for IntoIter -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +impl DoubleEndedIterator + for IntoIter +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ #[inline] fn next_back(&mut self) -> Option { if self.end == self.ptr { @@ -343,20 +364,29 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE } #[stable(feature = "rust1", since = "1.0.0")] -impl ExactSizeIterator for IntoIter -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +impl ExactSizeIterator + for IntoIter +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ fn is_empty(&self) -> bool { self.ptr == self.end } } #[stable(feature = "fused", since = "1.26.0")] -impl FusedIterator for IntoIter -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: {} +impl FusedIterator for IntoIter where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: +{ +} #[unstable(feature = "trusted_len", issue = "37572")] -unsafe impl TrustedLen for IntoIter -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: {} +unsafe impl TrustedLen + for IntoIter +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ +} #[doc(hidden)] #[unstable(issue = "none", feature = "std_internals")] @@ -372,18 +402,22 @@ impl 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 TrustedRandomAccessNoCoerce for IntoIter +unsafe impl TrustedRandomAccessNoCoerce + for IntoIter where T: NonDrop, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(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 Clone for IntoIter -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +impl Clone + for IntoIter +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ #[cfg(not(test))] fn clone(&self) -> Self { self.as_slice().to_vec_in(self.alloc.deref().clone()).into_iter() @@ -395,20 +429,32 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE } #[stable(feature = "rust1", since = "1.0.0")] -unsafe impl<#[may_dangle] T, A: Allocator, const COOP_PREFERRED: bool> Drop for IntoIter -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +unsafe impl<#[may_dangle] T, A: Allocator, const COOP_PREFERRED: bool> Drop + for IntoIter +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ fn drop(&mut self) { - struct DropGuard<'a, T, A: Allocator, const COOP_PREFERRED: bool>(&'a mut IntoIter) - where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: ; + struct DropGuard<'a, T, A: Allocator, const COOP_PREFERRED: bool>( + &'a mut IntoIter, + ) + where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:; impl Drop for DropGuard<'_, T, A, COOP_PREFERRED> - where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { + where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(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); + let _ = RawVec::::from_raw_parts_in( + self.0.buf.as_ptr(), + self.0.cap, + alloc, + ); } } } @@ -426,13 +472,20 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE // also refer to the vec::in_place_collect module documentation to get an overview #[unstable(issue = "none", feature = "inplace_iteration")] #[doc(hidden)] -unsafe impl InPlaceIterable for IntoIter -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: {} +unsafe impl InPlaceIterable + for IntoIter +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ +} #[unstable(issue = "none", feature = "inplace_iteration")] #[doc(hidden)] -unsafe impl SourceIter for IntoIter -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +unsafe impl SourceIter + for IntoIter +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ type Source = Self; #[inline] diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs index cbd286054a9b5..c53e3d3ad483f 100644 --- a/library/alloc/src/vec/mod.rs +++ b/library/alloc/src/vec/mod.rs @@ -397,19 +397,25 @@ mod spec_extend; #[stable(feature = "rust1", since = "1.0.0")] #[cfg_attr(not(test), rustc_diagnostic_item = "Vec")] #[rustc_insignificant_dtor] -pub struct Vec -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: +pub struct Vec< + T, + #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global, + const COOP_PREFERRED: bool = DEFAULT_COOP_PREFERRED, +> where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { buf: RawVec, len: usize, } #[unstable(feature = "global_co_alloc_covec", issue = "none")] -pub type CoVec = Vec; +pub type CoVec = + Vec; /// "Plain" Vec. Not "cooperative" - not carrying extra data to assist the allocator. #[unstable(feature = "global_co_alloc_plvec", issue = "none")] -pub type PlVec = Vec; +pub type PlVec = + Vec; /// Default `Vec`, `DefVec`, `DecVeque`, `DefDecVeq` "cooperation" (`COOP_PREFERRED`) generic parameter. #[unstable(feature = "global_co_alloc_def", issue = "none")] @@ -419,14 +425,14 @@ pub const DEFAULT_COOP_PREFERRED: bool = true; /// 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")] -pub type DefVec = Vec; - +pub type DefVec = + Vec; /// "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 = Vec1}>; +pub type WeVec = Vec 1 }>; //////////////////////////////////////////////////////////////////////////////// // Inherent methods @@ -620,7 +626,9 @@ impl Vec { } impl Vec -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ /// Constructs a new, empty `Vec`. /// /// The vector will not allocate until elements are pushed onto it. @@ -1633,8 +1641,10 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PR // 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, const VEC_IS_COOP: bool=true> - where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(VEC_IS_COOP)]: { + struct BackshiftOnDrop<'a, T, A: Allocator, const VEC_IS_COOP: bool = true> + where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(VEC_IS_COOP)]:, + { v: &'a mut Vec, processed_len: usize, deleted_cnt: usize, @@ -1642,7 +1652,9 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PR } impl Drop for BackshiftOnDrop<'_, T, A, VEC_IS_COOP> - where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(VEC_IS_COOP)]: { + where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(VEC_IS_COOP)]:, + { fn drop(&mut self) { if self.deleted_cnt > 0 { // SAFETY: Trailing unchecked items must be valid since we never touch them. @@ -1661,7 +1673,12 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PR } } - let mut g = BackshiftOnDrop:: { v: self, processed_len: 0, deleted_cnt: 0, original_len }; + let mut g = BackshiftOnDrop:: { + v: self, + processed_len: 0, + deleted_cnt: 0, + original_len, + }; fn process_loop( original_len: usize, @@ -1669,7 +1686,7 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PR g: &mut BackshiftOnDrop<'_, T, A, VEC_IS_COOP>, ) where F: FnMut(&mut T) -> bool, - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(VEC_IS_COOP)]: + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(VEC_IS_COOP)]:, { while g.processed_len != original_len { // SAFETY: Unchecked element must be valid. @@ -1763,7 +1780,9 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PR /* INVARIANT: vec.len() > read >= write > write-1 >= 0 */ struct FillGapOnDrop<'a, T, A: core::alloc::Allocator, const COOP_PREFERRED: bool> - where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { + where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + { /* Offset of the element we want to check if it is duplicate */ read: usize, @@ -1775,8 +1794,11 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PR vec: &'a mut Vec, } - 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::(COOP_PREFERRED)]: { + 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::(COOP_PREFERRED)]:, + { fn drop(&mut self) { /* This code gets executed when `same_bucket` panics */ @@ -2370,7 +2392,9 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PR } impl Vec -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(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 @@ -2470,7 +2494,9 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PR } impl Vec<[T; N], A, COOP_PREFERRED> -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ /// Takes a `Vec<[T; N]>` and flattens it into a `Vec`. /// /// # Panics @@ -2532,7 +2558,9 @@ impl ExtendWith for ExtendElement { } impl Vec -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ #[cfg(not(no_global_oom_handling))] /// Extend the vector by `n` values, using the given generator. fn extend_with>(&mut self, n: usize, mut value: E) { @@ -2565,7 +2593,9 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PR } impl Vec -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ /// Removes consecutive repeated elements in the vector according to the /// [`PartialEq`] trait implementation. /// @@ -2601,8 +2631,14 @@ pub fn from_elem(elem: T, n: usize) -> Vec { #[doc(hidden)] #[cfg(not(no_global_oom_handling))] #[unstable(feature = "allocator_api", issue = "32838")] -pub fn from_elem_in(elem: T, n: usize, alloc: A) -> Vec -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +pub fn from_elem_in( + elem: T, + n: usize, + alloc: A, +) -> Vec +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ ::from_elem(elem, n, alloc) } @@ -2614,8 +2650,11 @@ trait ExtendFromWithinSpec { unsafe fn spec_extend_from_within(&mut self, src: Range); } -impl ExtendFromWithinSpec for Vec -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +impl ExtendFromWithinSpec + for Vec +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ default unsafe fn spec_extend_from_within(&mut self, src: Range) { // SAFETY: // - len is increased only after initializing elements @@ -2634,8 +2673,11 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PR } } -impl ExtendFromWithinSpec for Vec -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +impl ExtendFromWithinSpec + for Vec +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ unsafe fn spec_extend_from_within(&mut self, src: Range) { let count = src.len(); { @@ -2669,7 +2711,9 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PR #[stable(feature = "rust1", since = "1.0.0")] impl ops::Deref for Vec -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ type Target = [T]; #[inline] @@ -2680,7 +2724,9 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PR #[stable(feature = "rust1", since = "1.0.0")] impl ops::DerefMut for Vec -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ #[inline] fn deref_mut(&mut self) -> &mut [T] { unsafe { slice::from_raw_parts_mut(self.as_mut_ptr(), self.len) } @@ -2694,7 +2740,9 @@ trait SpecCloneFrom { #[cfg(not(no_global_oom_handling))] impl SpecCloneFrom for Vec -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ default fn clone_from(this: &mut Self, other: &Self) { // drop anything that will not be overwritten this.truncate(other.len()); @@ -2711,7 +2759,9 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PR #[cfg(not(no_global_oom_handling))] impl SpecCloneFrom for Vec -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ fn clone_from(this: &mut Self, other: &Self) { this.clear(); this.extend_from_slice(other); @@ -2721,7 +2771,9 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PR #[cfg(not(no_global_oom_handling))] #[stable(feature = "rust1", since = "1.0.0")] impl Clone for Vec -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ #[cfg(not(test))] fn clone(&self) -> Self { let alloc = self.allocator().clone(); @@ -2757,7 +2809,9 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PR /// ``` #[stable(feature = "rust1", since = "1.0.0")] impl Hash for Vec -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ #[inline] fn hash(&self, state: &mut H) { Hash::hash(&**self, state) @@ -2769,8 +2823,11 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PR message = "vector indices are of type `usize` or ranges of `usize`", label = "vector indices are of type `usize` or ranges of `usize`" )] -impl, A: Allocator, const COOP_PREFERRED: bool> Index for Vec -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +impl, A: Allocator, const COOP_PREFERRED: bool> Index + for Vec +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ type Output = I::Output; #[inline] @@ -2784,8 +2841,11 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PR message = "vector indices are of type `usize` or ranges of `usize`", label = "vector indices are of type `usize` or ranges of `usize`" )] -impl, A: Allocator, const COOP_PREFERRED: bool> IndexMut for Vec -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +impl, A: Allocator, const COOP_PREFERRED: bool> IndexMut + for Vec +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ #[inline] fn index_mut(&mut self, index: I) -> &mut Self::Output { IndexMut::index_mut(&mut **self, index) @@ -2803,7 +2863,9 @@ impl FromIterator for Vec { #[stable(feature = "rust1", since = "1.0.0")] impl IntoIterator for Vec -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ type Item = T; type IntoIter = IntoIter; @@ -2849,7 +2911,9 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PR #[stable(feature = "rust1", since = "1.0.0")] impl<'a, T, A: Allocator, const COOP_PREFERRED: bool> IntoIterator for &'a Vec -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ type Item = &'a T; type IntoIter = slice::Iter<'a, T>; @@ -2859,8 +2923,11 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PR } #[stable(feature = "rust1", since = "1.0.0")] -impl<'a, T, A: Allocator, const COOP_PREFERRED: bool> IntoIterator for &'a mut Vec -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +impl<'a, T, A: Allocator, const COOP_PREFERRED: bool> IntoIterator + for &'a mut Vec +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ type Item = &'a mut T; type IntoIter = slice::IterMut<'a, T>; @@ -2872,7 +2939,9 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PR #[cfg(not(no_global_oom_handling))] #[stable(feature = "rust1", since = "1.0.0")] impl Extend for Vec -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ #[inline] fn extend>(&mut self, iter: I) { >::spec_extend(self, iter.into_iter()) @@ -2890,7 +2959,9 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PR } impl Vec -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(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))] @@ -3064,8 +3135,11 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PR /// [`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, const COOP_PREFERRED: bool> Extend<&'a T> for Vec -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +impl<'a, T: Copy + 'a, A: Allocator + 'a, const COOP_PREFERRED: bool> Extend<&'a T> + for Vec +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ fn extend>(&mut self, iter: I) { self.spec_extend(iter.into_iter()) } @@ -3083,8 +3157,11 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PR /// Implements comparison of vectors, [lexicographically](core::cmp::Ord#lexicographical-comparison). #[stable(feature = "rust1", since = "1.0.0")] -impl PartialOrd for Vec -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +impl PartialOrd + for Vec +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ #[inline] fn partial_cmp(&self, other: &Self) -> Option { PartialOrd::partial_cmp(&**self, &**other) @@ -3092,13 +3169,17 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PR } #[stable(feature = "rust1", since = "1.0.0")] -impl Eq for Vec -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: {} +impl Eq for Vec where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: +{ +} /// Implements ordering of vectors, [lexicographically](core::cmp::Ord#lexicographical-comparison). #[stable(feature = "rust1", since = "1.0.0")] impl Ord for Vec -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ #[inline] fn cmp(&self, other: &Self) -> Ordering { Ord::cmp(&**self, &**other) @@ -3106,8 +3187,11 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PR } #[stable(feature = "rust1", since = "1.0.0")] -unsafe impl<#[may_dangle] T, A: Allocator, const COOP_PREFERRED: bool> Drop for Vec -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +unsafe impl<#[may_dangle] T, A: Allocator, const COOP_PREFERRED: bool> Drop + for Vec +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ fn drop(&mut self) { unsafe { // use drop for [T] @@ -3131,24 +3215,33 @@ impl const Default for Vec { } #[stable(feature = "rust1", since = "1.0.0")] -impl fmt::Debug for Vec -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +impl fmt::Debug + for Vec +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fmt::Debug::fmt(&**self, f) } } #[stable(feature = "rust1", since = "1.0.0")] -impl AsRef> for Vec -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +impl AsRef> + for Vec +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ fn as_ref(&self) -> &Vec { self } } #[stable(feature = "vec_as_mut", since = "1.5.0")] -impl AsMut> for Vec -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +impl AsMut> + for Vec +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ fn as_mut(&mut self) -> &mut Vec { self } @@ -3156,7 +3249,9 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PR #[stable(feature = "rust1", since = "1.0.0")] impl AsRef<[T]> for Vec -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ fn as_ref(&self) -> &[T] { self } @@ -3164,7 +3259,9 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PR #[stable(feature = "vec_as_mut", since = "1.5.0")] impl AsMut<[T]> for Vec -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ fn as_mut(&mut self) -> &mut [T] { self } @@ -3262,7 +3359,9 @@ where #[cfg(not(test))] #[stable(feature = "vec_from_box", since = "1.18.0")] impl From> for Vec -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ /// Convert a boxed slice into a vector by transferring ownership of /// the existing heap allocation. /// @@ -3282,7 +3381,9 @@ where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PR #[cfg(not(test))] #[stable(feature = "box_from_vec", since = "1.20.0")] impl From> for Box<[T], A> -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ /// Convert a vector into a boxed slice. /// /// If `v` has excess capacity, its items will be moved into a @@ -3322,8 +3423,11 @@ impl From<&str> for Vec { } #[stable(feature = "array_try_from_vec", since = "1.48.0")] -impl TryFrom> for [T; N] -where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +impl TryFrom> + for [T; N] +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ type Error = Vec; /// Gets the entire contents of the `Vec` as an array, diff --git a/library/alloc/src/vec/spec_extend.rs b/library/alloc/src/vec/spec_extend.rs index 87bdb3aaab7a5..73cf325889290 100644 --- a/library/alloc/src/vec/spec_extend.rs +++ b/library/alloc/src/vec/spec_extend.rs @@ -1,5 +1,5 @@ -use core::alloc; use crate::alloc::Allocator; +use core::alloc; use core::iter::TrustedLen; use core::slice::{self}; @@ -13,7 +13,7 @@ pub(super) trait SpecExtend { impl SpecExtend for Vec where I: Iterator, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { default fn spec_extend(&mut self, iter: I) { self.extend_desugared(iter) @@ -23,15 +23,18 @@ where impl SpecExtend for Vec where I: TrustedLen, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { default fn spec_extend(&mut self, iterator: I) { self.extend_trusted(iterator) } } -impl SpecExtend> for Vec -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +impl SpecExtend> + for Vec +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ fn spec_extend(&mut self, mut iterator: IntoIter) { unsafe { self.append_elements(iterator.as_slice() as _); @@ -40,21 +43,23 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE } } -impl<'a, T: 'a, I, A: Allocator + 'a, const COOP_PREFERRED: bool> SpecExtend<&'a T, I> for Vec +impl<'a, T: 'a, I, A: Allocator + 'a, const COOP_PREFERRED: bool> SpecExtend<&'a T, I> + for Vec where I: Iterator, T: Clone, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { default fn spec_extend(&mut self, iterator: I) { self.spec_extend(iterator.cloned()) } } -impl<'a, T: 'a, A: Allocator + 'a, const COOP_PREFERRED: bool> SpecExtend<&'a T, slice::Iter<'a, T>> for Vec +impl<'a, T: 'a, A: Allocator + 'a, const COOP_PREFERRED: bool> SpecExtend<&'a T, slice::Iter<'a, T>> + for Vec where T: Copy, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(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 682375a607837..3766f6de061bb 100644 --- a/library/alloc/src/vec/spec_from_elem.rs +++ b/library/alloc/src/vec/spec_from_elem.rs @@ -1,20 +1,31 @@ use core::ptr; -use core::alloc; 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(elem: Self, n: usize, alloc: A) -> Vec - where [(); alloc::co_alloc_metadata_num_slots::(COOP_PREFERRED)]: ; + fn from_elem( + elem: Self, + n: usize, + alloc: A, + ) -> Vec + where + [(); alloc::co_alloc_metadata_num_slots::(COOP_PREFERRED)]:; } impl SpecFromElem for T { - default fn from_elem(elem: Self, n: usize, alloc: A) -> Vec - where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { + default fn from_elem( + elem: Self, + n: usize, + alloc: A, + ) -> Vec + where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + { let mut v = Vec::with_capacity_in(n, alloc); v.extend_with(n, ExtendElement(elem)); v @@ -23,8 +34,14 @@ impl SpecFromElem for T { impl SpecFromElem for T { #[inline] - default fn from_elem(elem: T, n: usize, alloc: A) -> Vec - where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { + default fn from_elem( + elem: T, + n: usize, + alloc: A, + ) -> Vec + where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + { if elem.is_zero() { return Vec { buf: RawVec::with_capacity_zeroed_in(n, alloc), len: n }; } @@ -36,8 +53,14 @@ impl SpecFromElem for T { impl SpecFromElem for i8 { #[inline] - fn from_elem(elem: i8, n: usize, alloc: A) -> Vec - where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { + fn from_elem( + elem: i8, + n: usize, + alloc: A, + ) -> Vec + where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + { if elem == 0 { return Vec { buf: RawVec::with_capacity_zeroed_in(n, alloc), len: n }; } @@ -52,8 +75,14 @@ impl SpecFromElem for i8 { impl SpecFromElem for u8 { #[inline] - fn from_elem(elem: u8, n: usize, alloc: A) -> Vec - where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { + fn from_elem( + elem: u8, + n: usize, + alloc: A, + ) -> Vec + where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + { if elem == 0 { return Vec { buf: RawVec::with_capacity_zeroed_in(n, alloc), len: n }; } diff --git a/library/alloc/src/vec/splice.rs b/library/alloc/src/vec/splice.rs index 631d9d5e3aa60..d8569a6e89c62 100644 --- a/library/alloc/src/vec/splice.rs +++ b/library/alloc/src/vec/splice.rs @@ -1,5 +1,5 @@ -use core::alloc; use crate::alloc::{Allocator, Global}; +use core::alloc; use core::ptr::{self}; use core::slice::{self}; @@ -23,15 +23,18 @@ pub struct Splice< 'a, I: Iterator + 'a, #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator + 'a = Global, -> -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +> where + [(); core::alloc::co_alloc_metadata_num_slots::()]:, +{ pub(super) drain: Drain<'a, I::Item, A>, pub(super) replace_with: I, } #[stable(feature = "vec_splice", since = "1.21.0")] impl Iterator for Splice<'_, I, A> -where [(); core::alloc::co_alloc_metadata_num_slots::()]: { +where + [(); core::alloc::co_alloc_metadata_num_slots::()]:, +{ type Item = I::Item; fn next(&mut self) -> Option { @@ -45,19 +48,25 @@ where [(); core::alloc::co_alloc_metadata_num_slots::()]: { #[stable(feature = "vec_splice", since = "1.21.0")] impl DoubleEndedIterator for Splice<'_, I, A> -where [(); alloc::co_alloc_metadata_num_slots::()]: { +where + [(); alloc::co_alloc_metadata_num_slots::()]:, +{ fn next_back(&mut self) -> Option { self.drain.next_back() } } #[stable(feature = "vec_splice", since = "1.21.0")] -impl ExactSizeIterator for Splice<'_, I, A> -where [(); alloc::co_alloc_metadata_num_slots::()]: {} +impl ExactSizeIterator for Splice<'_, I, A> where + [(); alloc::co_alloc_metadata_num_slots::()]: +{ +} #[stable(feature = "vec_splice", since = "1.21.0")] impl Drop for Splice<'_, I, A> -where [(); alloc::co_alloc_metadata_num_slots::()]: { +where + [(); alloc::co_alloc_metadata_num_slots::()]:, +{ fn drop(&mut self) { self.drain.by_ref().for_each(drop); // At this point draining is done and the only remaining tasks are splicing @@ -105,7 +114,9 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { /// Private helper methods for `Splice::drop` impl Drain<'_, T, A> -where [(); alloc::co_alloc_metadata_num_slots::()]: { +where + [(); alloc::co_alloc_metadata_num_slots::()]:, +{ /// 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 c34e7a558061d..656e079f9c61c 100644 --- a/library/alloc/tests/boxed.rs +++ b/library/alloc/tests/boxed.rs @@ -61,7 +61,7 @@ fn box_deref_lval() { pub struct ConstAllocator; -//@TODO +//@FIXME unsafe impl const Allocator for ConstAllocator { fn allocate(&self, layout: Layout) -> Result, AllocError> { match layout.size() { diff --git a/library/core/src/alloc/global.rs b/library/core/src/alloc/global.rs index b0d457ff8c4d9..a7251328c128b 100644 --- a/library/core/src/alloc/global.rs +++ b/library/core/src/alloc/global.rs @@ -1,7 +1,7 @@ +use crate::alloc::GlobalCoAllocMeta; use crate::alloc::Layout; use crate::cmp; use crate::ptr; -use crate::alloc::GlobalCoAllocMeta; #[unstable(feature = "global_co_alloc_meta", issue = "none")] #[allow(missing_debug_implementations)] @@ -166,7 +166,9 @@ pub unsafe trait GlobalAlloc { 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")} + 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`. /// @@ -184,7 +186,9 @@ pub unsafe trait GlobalAlloc { 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")} + 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. @@ -308,7 +312,7 @@ pub unsafe trait GlobalAlloc { ptr_and_meta: RawAndMeta, layout: Layout, new_size: usize, - mut result: &mut RawAndMeta + 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. diff --git a/library/core/src/alloc/mod.rs b/library/core/src/alloc/mod.rs index 7993e8e546d89..cc55c15db6268 100644 --- a/library/core/src/alloc/mod.rs +++ b/library/core/src/alloc/mod.rs @@ -89,7 +89,9 @@ pub const fn co_alloc_metadata_num_slots() -> usize { #[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(coop_preferred: bool) -> usize { +pub const fn co_alloc_metadata_num_slots_with_preference( + coop_preferred: bool, +) -> usize { if A::IS_CO_ALLOCATOR && coop_preferred { 1 } else { 0 } } @@ -182,7 +184,9 @@ pub unsafe trait Allocator { /// [`handle_alloc_error`]: ../../alloc/alloc/fn.handle_alloc_error.html fn allocate(&self, layout: Layout) -> Result, AllocError>; - fn co_allocate(&self, _layout: Layout, _result: &mut SliceAndMetaResult) {panic!("FIXME")} + fn co_allocate(&self, _layout: Layout, _result: &mut SliceAndMetaResult) { + panic!("FIXME") + } /// Behaves like `allocate`, but also ensures that the returned memory is zero-initialized. /// @@ -208,14 +212,9 @@ pub unsafe trait Allocator { fn co_allocate_zeroed(&self, layout: Layout, mut result: &mut SliceAndMetaResult) { self.co_allocate(layout, &mut result); - if let Ok(SliceAndMeta{slice, ..}) = 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()) - } + unsafe { slice.as_non_null_ptr().as_ptr().write_bytes(0, slice.len()) } } } @@ -230,7 +229,9 @@ pub unsafe trait Allocator { /// [*fit*]: #memory-fitting unsafe fn deallocate(&self, ptr: NonNull, layout: Layout); - unsafe fn co_deallocate(&self, _ptr_and_meta: PtrAndMeta, _layout: Layout) {panic!("FIXME")} + unsafe fn co_deallocate(&self, _ptr_and_meta: PtrAndMeta, _layout: Layout) { + panic!("FIXME") + } /// Attempts to extend the memory block. /// @@ -301,7 +302,7 @@ pub unsafe trait Allocator { ptr_and_meta: PtrAndMeta, old_layout: Layout, new_layout: Layout, - mut result: &mut SliceAndMetaResult + mut result: &mut SliceAndMetaResult, ) { debug_assert!( new_layout.size() >= old_layout.size(), @@ -310,7 +311,7 @@ pub unsafe trait Allocator { self.co_allocate(new_layout, &mut result); - if let Ok(SliceAndMeta {slice, ..}) = 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 @@ -395,7 +396,7 @@ pub unsafe trait Allocator { ptr_and_meta: PtrAndMeta, old_layout: Layout, new_layout: Layout, - mut result: &mut SliceAndMetaResult + mut result: &mut SliceAndMetaResult, ) { debug_assert!( new_layout.size() >= old_layout.size(), @@ -404,7 +405,7 @@ pub unsafe trait Allocator { self.co_allocate_zeroed(new_layout, &mut result); - if let Ok(SliceAndMeta{ slice, ..}) = 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 @@ -490,7 +491,7 @@ pub unsafe trait Allocator { ptr_and_meta: PtrAndMeta, old_layout: Layout, new_layout: Layout, - mut result: &mut SliceAndMetaResult + mut result: &mut SliceAndMetaResult, ) { debug_assert!( new_layout.size() <= old_layout.size(), @@ -499,7 +500,7 @@ pub unsafe trait Allocator { self.co_allocate(new_layout, &mut result); - if let Ok(SliceAndMeta{ slice, ..}) = 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 diff --git a/library/std/src/io/cursor.rs b/library/std/src/io/cursor.rs index 33d1ee065de2a..63045ebcb8157 100644 --- a/library/std/src/io/cursor.rs +++ b/library/std/src/io/cursor.rs @@ -403,7 +403,9 @@ fn reserve_and_pad( vec: &mut Vec, buf_len: usize, ) -> io::Result -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ let pos: usize = (*pos_mut).try_into().map_err(|_| { io::const_io_error!( ErrorKind::InvalidInput, @@ -442,10 +444,14 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE /// Writes the slice to the vec without allocating /// # Safety: vec must have buf.len() spare capacity -unsafe fn vec_write_unchecked(pos: usize, vec: &mut Vec, buf: &[u8]) -> usize +unsafe fn vec_write_unchecked( + pos: usize, + vec: &mut Vec, + buf: &[u8], +) -> usize where A: Allocator, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { debug_assert!(vec.capacity() >= pos + buf.len()); vec.as_mut_ptr().add(pos).copy_from(buf.as_ptr(), buf.len()); @@ -461,10 +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(pos_mut: &mut u64, vec: &mut Vec, buf: &[u8]) -> io::Result +fn vec_write( + pos_mut: &mut u64, + vec: &mut Vec, + buf: &[u8], +) -> io::Result where A: Allocator, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { let buf_len = buf.len(); let mut pos = reserve_and_pad(pos_mut, vec, buf_len)?; @@ -500,7 +510,7 @@ fn vec_write_vectored( ) -> io::Result where A: Allocator, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(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. @@ -551,7 +561,7 @@ impl Write for Cursor<&mut [u8]> { impl Write for Cursor<&mut Vec> where A: Allocator, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn write(&mut self, buf: &[u8]) -> io::Result { vec_write(&mut self.pos, self.inner, buf) @@ -576,7 +586,7 @@ where impl Write for Cursor> where A: Allocator, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn write(&mut self, buf: &[u8]) -> io::Result { 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 ec3394e0b16c1..8671ebf5c8141 100644 --- a/library/std/src/io/impls.rs +++ b/library/std/src/io/impls.rs @@ -379,7 +379,9 @@ impl Write for &mut [u8] { /// The vector will grow as needed. #[stable(feature = "rust1", since = "1.0.0")] impl Write for Vec -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ #[inline] fn write(&mut self, buf: &[u8]) -> io::Result { self.extend_from_slice(buf); @@ -416,7 +418,9 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE /// Read is implemented for `VecDeque` by consuming bytes from the front of the `VecDeque`. #[stable(feature = "vecdeque_read_write", since = "1.63.0")] impl Read for VecDeque -where [(); co_alloc_metadata_num_slots_with_preference::(_COOP_PREFERRED)]: { +where + [(); co_alloc_metadata_num_slots_with_preference::(_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. @@ -441,7 +445,9 @@ where [(); co_alloc_metadata_num_slots_with_preference::(_COOP_PREFERRED)]: { /// Write is implemented for `VecDeque` by appending to the `VecDeque`, growing it as needed. #[stable(feature = "vecdeque_read_write", since = "1.63.0")] impl Write for VecDeque -where [(); co_alloc_metadata_num_slots_with_preference::(_COOP_PREFERRED)]: { +where + [(); co_alloc_metadata_num_slots_with_preference::(_COOP_PREFERRED)]:, +{ #[inline] fn write(&mut self, buf: &[u8]) -> io::Result { self.extend(buf); diff --git a/library/std/src/sys/unix/thread_local_dtor.rs b/library/std/src/sys/unix/thread_local_dtor.rs index 1eea75e16d338..37e5571a7cd45 100644 --- a/library/std/src/sys/unix/thread_local_dtor.rs +++ b/library/std/src/sys/unix/thread_local_dtor.rs @@ -2,11 +2,11 @@ #![unstable(feature = "thread_local_internals", issue = "none")] #![feature(global_co_alloc_plvec)] -use core::alloc::PlVec; - //! Provides thread-local destructors without an associated "key", which //! can be more efficient. +use core::alloc::PlVec; + // Since what appears to be glibc 2.18 this symbol has been shipped which // GCC and clang both use to invoke destructors in thread_local globals, so // let's do the same! diff --git a/src/librustdoc/html/render/context.rs b/src/librustdoc/html/render/context.rs index 16137c49fb22d..420c8345c8c5f 100644 --- a/src/librustdoc/html/render/context.rs +++ b/src/librustdoc/html/render/context.rs @@ -77,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 + 2 * mem::size_of::()); +rustc_data_structures::static_assert_size!( + Context<'_>, + 160 + 2 * mem::size_of::() +); /// Shared mutable state used in [`Context`] and elsewhere. pub(crate) struct SharedContext<'tcx> { From 4909d57098f7f61039dc7f4009375d942024c6a0 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sat, 21 Jan 2023 22:06:34 -0800 Subject: [PATCH 19/80] CoAlloc: VecDeque + BinaryHeap: x test tidy --bless. ICE --- .../alloc/src/collections/binary_heap/mod.rs | 12 +- .../alloc/src/collections/vec_deque/drain.rs | 77 ++++++--- .../src/collections/vec_deque/into_iter.rs | 41 +++-- .../alloc/src/collections/vec_deque/mod.rs | 154 +++++++++++++----- .../src/collections/vec_deque/spec_extend.rs | 35 ++-- .../collections/vec_deque/spec_from_iter.rs | 19 ++- 6 files changed, 236 insertions(+), 102 deletions(-) diff --git a/library/alloc/src/collections/binary_heap/mod.rs b/library/alloc/src/collections/binary_heap/mod.rs index 7c6b0bb6e6c75..3d10072ce43b4 100644 --- a/library/alloc/src/collections/binary_heap/mod.rs +++ b/library/alloc/src/collections/binary_heap/mod.rs @@ -143,12 +143,12 @@ #![allow(missing_docs)] #![stable(feature = "rust1", since = "1.0.0")] -use core::{alloc, 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::{alloc, fmt}; use crate::alloc::Global; @@ -1243,7 +1243,7 @@ impl BinaryHeap { /// ``` #[inline] #[stable(feature = "drain", since = "1.6.0")] - pub fn drain(&mut self) -> Drain<'_, T, {alloc::SHORT_TERM_VEC_PREFERS_COOP}> { + pub fn drain(&mut self) -> Drain<'_, T, { alloc::SHORT_TERM_VEC_PREFERS_COOP }> { Drain { iter: self.data.drain(..) } } @@ -1524,13 +1524,17 @@ unsafe impl TrustedLen for IntoIterSorted {} #[stable(feature = "drain", since = "1.6.0")] #[derive(Debug)] pub struct Drain<'a, T: 'a, const COOP_PREFERRED: bool> -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ iter: vec::Drain<'a, T, Global, COOP_PREFERRED>, } #[stable(feature = "drain", since = "1.6.0")] impl Iterator for Drain<'_, T, COOP_PREFERRED> -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ type Item = T; #[inline] diff --git a/library/alloc/src/collections/vec_deque/drain.rs b/library/alloc/src/collections/vec_deque/drain.rs index bab4919eb6032..0bcf82e3ceff5 100644 --- a/library/alloc/src/collections/vec_deque/drain.rs +++ b/library/alloc/src/collections/vec_deque/drain.rs @@ -19,9 +19,10 @@ pub struct Drain< 'a, T: 'a, #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global, - const COOP_PREFERRED: bool = {alloc::SHORT_TERM_VEC_PREFERS_COOP} -> -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { + const COOP_PREFERRED: bool = { alloc::SHORT_TERM_VEC_PREFERS_COOP }, +> where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ // We can't just use a &mut VecDeque, as that would make Drain invariant over T // and we want it to be covariant instead deque: NonNull>, @@ -37,7 +38,9 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE } impl<'a, T, A: Allocator, const COOP_PREFERRED: bool> Drain<'a, T, A, COOP_PREFERRED> -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ pub(super) unsafe fn new( deque: &'a mut VecDeque, drain_start: usize, @@ -91,8 +94,11 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE } #[stable(feature = "collection_debug", since = "1.17.0")] -impl fmt::Debug for Drain<'_, T, A, COOP_PREFERRED> -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +impl fmt::Debug + for Drain<'_, T, A, COOP_PREFERRED> +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_tuple("Drain") .field(&self.drain_len) @@ -104,21 +110,37 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE } #[stable(feature = "drain", since = "1.6.0")] -unsafe impl Sync for Drain<'_, T, A, COOP_PREFERRED> -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: {} +unsafe impl Sync + for Drain<'_, T, A, COOP_PREFERRED> +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ +} #[stable(feature = "drain", since = "1.6.0")] -unsafe impl Send for Drain<'_, T, A, COOP_PREFERRED> -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: {} +unsafe impl Send + for Drain<'_, T, A, COOP_PREFERRED> +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ +} #[stable(feature = "drain", since = "1.6.0")] impl Drop for Drain<'_, T, A, COOP_PREFERRED> -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ fn drop(&mut self) { - 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::(COOP_PREFERRED)]:; + 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::(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::(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::(COOP_PREFERRED)]:, + { fn drop(&mut self) { if self.0.remaining != 0 { unsafe { @@ -200,7 +222,9 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE #[stable(feature = "drain", since = "1.6.0")] impl Iterator for Drain<'_, T, A, COOP_PREFERRED> -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ type Item = T; #[inline] @@ -222,8 +246,11 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE } #[stable(feature = "drain", since = "1.6.0")] -impl DoubleEndedIterator for Drain<'_, T, A, COOP_PREFERRED> -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +impl DoubleEndedIterator + for Drain<'_, T, A, COOP_PREFERRED> +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ #[inline] fn next_back(&mut self) -> Option { if self.remaining == 0 { @@ -236,9 +263,15 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE } #[stable(feature = "drain", since = "1.6.0")] -impl ExactSizeIterator for Drain<'_, T, A, COOP_PREFERRED> -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: {} +impl ExactSizeIterator + for Drain<'_, T, A, COOP_PREFERRED> +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ +} #[stable(feature = "fused", since = "1.26.0")] -impl FusedIterator for Drain<'_, T, A, COOP_PREFERRED> -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: {} +impl FusedIterator for Drain<'_, T, A, COOP_PREFERRED> where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(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 477ab0c4db594..7924098c14db2 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::{alloc, fmt}; use core::iter::{FusedIterator, TrustedLen}; +use core::{alloc, fmt}; use crate::alloc::{Allocator, Global}; @@ -17,14 +17,17 @@ use super::VecDeque; pub struct IntoIter< T, #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global, - const COOP_PREFERRED: bool = true -> -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { + const COOP_PREFERRED: bool = true, +> where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ inner: VecDeque, } impl IntoIter -where [(); alloc::co_alloc_metadata_num_slots::()]: { +where + [(); alloc::co_alloc_metadata_num_slots::()]:, +{ pub(super) fn new(inner: VecDeque) -> Self { IntoIter { inner } } @@ -36,7 +39,9 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { #[stable(feature = "collection_debug", since = "1.17.0")] impl fmt::Debug for IntoIter -where [(); alloc::co_alloc_metadata_num_slots::()]: { +where + [(); alloc::co_alloc_metadata_num_slots::()]:, +{ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_tuple("IntoIter").field(&self.inner).finish() } @@ -44,7 +49,9 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { #[stable(feature = "rust1", since = "1.0.0")] impl Iterator for IntoIter -where [(); alloc::co_alloc_metadata_num_slots::()]: { +where + [(); alloc::co_alloc_metadata_num_slots::()]:, +{ type Item = T; #[inline] @@ -61,7 +68,9 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { #[stable(feature = "rust1", since = "1.0.0")] impl DoubleEndedIterator for IntoIter -where [(); alloc::co_alloc_metadata_num_slots::()]: { +where + [(); alloc::co_alloc_metadata_num_slots::()]:, +{ #[inline] fn next_back(&mut self) -> Option { self.inner.pop_back() @@ -70,16 +79,22 @@ where [(); alloc::co_alloc_metadata_num_slots::()]: { #[stable(feature = "rust1", since = "1.0.0")] impl ExactSizeIterator for IntoIter -where [(); alloc::co_alloc_metadata_num_slots::()]: { +where + [(); alloc::co_alloc_metadata_num_slots::()]:, +{ fn is_empty(&self) -> bool { self.inner.is_empty() } } #[stable(feature = "fused", since = "1.26.0")] -impl FusedIterator for IntoIter -where [(); alloc::co_alloc_metadata_num_slots::()]: {} +impl FusedIterator for IntoIter where + [(); alloc::co_alloc_metadata_num_slots::()]: +{ +} #[unstable(feature = "trusted_len", issue = "37572")] -unsafe impl TrustedLen for IntoIter -where [(); alloc::co_alloc_metadata_num_slots::()]: {} +unsafe impl TrustedLen for IntoIter where + [(); alloc::co_alloc_metadata_num_slots::()]: +{ +} diff --git a/library/alloc/src/collections/vec_deque/mod.rs b/library/alloc/src/collections/vec_deque/mod.rs index 694d733f68a54..b441f23ed23f3 100644 --- a/library/alloc/src/collections/vec_deque/mod.rs +++ b/library/alloc/src/collections/vec_deque/mod.rs @@ -6,10 +6,9 @@ //! contained type is sendable. #![feature(global_co_alloc)] - #![stable(feature = "rust1", since = "1.0.0")] -use core::alloc::{self, GlobalAlloc}; use crate::vec::DEFAULT_COOP_PREFERRED; +use core::alloc::{self, GlobalAlloc}; use core::cmp::{self, Ordering}; use core::fmt; use core::hash::{Hash, Hasher}; @@ -97,9 +96,9 @@ mod tests; 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::(COOP_PREFERRED)]: + const COOP_PREFERRED: bool = DEFAULT_COOP_PREFERRED, +> where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { // `self[0]`, if it exists, is `buf[head]`. // `head < buf.capacity()`, unless `buf.capacity() == 0` when `head == 0`. @@ -112,8 +111,11 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE } #[stable(feature = "rust1", since = "1.0.0")] -impl Clone for VecDeque -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +impl Clone + for VecDeque +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ fn clone(&self) -> Self { let mut deq = Self::with_capacity_in(self.len(), self.allocator().clone()); deq.extend(self.iter().cloned()); @@ -127,8 +129,11 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE } #[stable(feature = "rust1", since = "1.0.0")] -unsafe impl<#[may_dangle] T, A: Allocator, const COOP_PREFERRED: bool> Drop for VecDeque -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +unsafe impl<#[may_dangle] T, A: Allocator, const COOP_PREFERRED: bool> Drop + for VecDeque +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ fn drop(&mut self) { /// Runs the destructor for all items in the slice when it gets dropped (normally or /// during unwinding). @@ -162,7 +167,9 @@ impl Default for VecDeque VecDeque -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ /// Marginally more convenient #[inline] fn ptr(&self) -> *mut T { @@ -452,13 +459,17 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE len: usize, ) -> usize { struct Guard<'a, T, A: Allocator, const COOP_PREFERRED: bool> - where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { + where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + { deque: &'a mut VecDeque, written: usize, } 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::(COOP_PREFERRED)]: { + where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + { fn drop(&mut self) { self.deque.len += self.written; } @@ -536,8 +547,10 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE } } -impl VecDeque -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +impl VecDeque +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ /// Creates an empty deque. /// /// # Examples @@ -574,7 +587,9 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE } impl VecDeque -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ /// Creates an empty deque. /// /// # Examples @@ -2610,7 +2625,9 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE } impl VecDeque -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(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. @@ -2655,8 +2672,11 @@ fn wrap_index(logical_index: usize, capacity: usize) -> usize { } #[stable(feature = "rust1", since = "1.0.0")] -impl PartialEq for VecDeque -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +impl PartialEq + for VecDeque +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ fn eq(&self, other: &Self) -> bool { if self.len != other.len() { return false; @@ -2695,8 +2715,10 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE } #[stable(feature = "rust1", since = "1.0.0")] -impl Eq for VecDeque -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: {} +impl Eq for VecDeque where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: +{ +} __impl_slice_eq1! { [] VecDeque, Vec, } __impl_slice_eq1! { [] VecDeque, &[U], } @@ -2706,8 +2728,11 @@ __impl_slice_eq1! { [const N: usize] VecDeque, &[U; N], } __impl_slice_eq1! { [const N: usize] VecDeque, &mut [U; N], } #[stable(feature = "rust1", since = "1.0.0")] -impl PartialOrd for VecDeque -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +impl PartialOrd + for VecDeque +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ fn partial_cmp(&self, other: &Self) -> Option { self.iter().partial_cmp(other.iter()) } @@ -2715,7 +2740,9 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE #[stable(feature = "rust1", since = "1.0.0")] impl Ord for VecDeque -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ #[inline] fn cmp(&self, other: &Self) -> Ordering { self.iter().cmp(other.iter()) @@ -2724,7 +2751,9 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE #[stable(feature = "rust1", since = "1.0.0")] impl Hash for VecDeque -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ fn hash(&self, state: &mut H) { state.write_length_prefix(self.len); // It's not possible to use Hash::hash_slice on slices @@ -2739,7 +2768,9 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE #[stable(feature = "rust1", since = "1.0.0")] impl Index for VecDeque -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ type Output = T; #[inline] @@ -2750,7 +2781,9 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE #[stable(feature = "rust1", since = "1.0.0")] impl IndexMut for VecDeque -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ #[inline] fn index_mut(&mut self, index: usize) -> &mut T { self.get_mut(index).expect("Out of bounds access") @@ -2759,7 +2792,9 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE #[stable(feature = "rust1", since = "1.0.0")] impl FromIterator for VecDeque -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ fn from_iter>(iter: I) -> VecDeque { SpecFromIter::spec_from_iter(iter.into_iter()) } @@ -2767,7 +2802,9 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE #[stable(feature = "rust1", since = "1.0.0")] impl IntoIterator for VecDeque -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ type Item = T; type IntoIter = IntoIter; @@ -2779,8 +2816,11 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE } #[stable(feature = "rust1", since = "1.0.0")] -impl<'a, T, A: Allocator, const COOP_PREFERRED: bool> IntoIterator for &'a VecDeque -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +impl<'a, T, A: Allocator, const COOP_PREFERRED: bool> IntoIterator + for &'a VecDeque +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ type Item = &'a T; type IntoIter = Iter<'a, T>; @@ -2790,8 +2830,11 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE } #[stable(feature = "rust1", since = "1.0.0")] -impl<'a, T, A: Allocator, const COOP_PREFERRED: bool> IntoIterator for &'a mut VecDeque -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +impl<'a, T, A: Allocator, const COOP_PREFERRED: bool> IntoIterator + for &'a mut VecDeque +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ type Item = &'a mut T; type IntoIter = IterMut<'a, T>; @@ -2802,7 +2845,9 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE #[stable(feature = "rust1", since = "1.0.0")] impl Extend for VecDeque -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ fn extend>(&mut self, iter: I) { >::spec_extend(self, iter.into_iter()); } @@ -2819,8 +2864,11 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE } #[stable(feature = "extend_ref", since = "1.2.0")] -impl<'a, T: 'a + Copy, A: Allocator, const COOP_PREFERRED: bool> Extend<&'a T> for VecDeque -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +impl<'a, T: 'a + Copy, A: Allocator, const COOP_PREFERRED: bool> Extend<&'a T> + for VecDeque +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ fn extend>(&mut self, iter: I) { self.spec_extend(iter.into_iter()); } @@ -2837,16 +2885,22 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE } #[stable(feature = "rust1", since = "1.0.0")] -impl fmt::Debug for VecDeque -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +impl fmt::Debug + for VecDeque +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(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 From> for VecDeque -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +impl From> + for VecDeque +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ /// Turn a [`Vec`] into a [`VecDeque`]. /// /// [`Vec`]: crate::vec::Vec @@ -2857,15 +2911,20 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE /// any additional memory. #[inline] fn from(other: Vec) -> Self - where [(); alloc::co_alloc_metadata_num_slots_with_preference::(OTHER_COOP_PREFERRED)]: { + where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(OTHER_COOP_PREFERRED)]:, + { 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) } } } } #[stable(feature = "vecdeque_vec_conversions", since = "1.10.0")] -impl From> for Vec -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +impl From> + for Vec +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ /// Turn a [`VecDeque`] into a [`Vec`]. /// /// [`Vec`]: crate::vec::Vec @@ -2895,7 +2954,9 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE /// assert_eq!(vec, [8, 9, 1, 2, 3, 4]); /// assert_eq!(vec.as_ptr(), ptr); /// ``` - fn from(mut other: VecDeque) -> Self { + fn from( + mut other: VecDeque, + ) -> Self { other.make_contiguous(); unsafe { @@ -2915,8 +2976,11 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE } #[stable(feature = "std_collections_from_array", since = "1.56.0")] -impl From<[T; N]> for VecDeque -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +impl From<[T; N]> + for VecDeque +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ /// Converts a `[T; N]` into a `VecDeque`. /// /// ``` diff --git a/library/alloc/src/collections/vec_deque/spec_extend.rs b/library/alloc/src/collections/vec_deque/spec_extend.rs index cdeda1a57bed5..b1a9d23fd4a99 100644 --- a/library/alloc/src/collections/vec_deque/spec_extend.rs +++ b/library/alloc/src/collections/vec_deque/spec_extend.rs @@ -13,10 +13,11 @@ pub(super) trait SpecExtend { fn spec_extend(&mut self, iter: I); } -impl SpecExtend for VecDeque +impl SpecExtend + for VecDeque where I: Iterator, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { default fn spec_extend(&mut self, mut iter: I) { // This function should be the moral equivalent of: @@ -26,8 +27,12 @@ where // } // May only be called if `deque.len() < deque.capacity()` - unsafe fn push_unchecked(deque: &mut VecDeque, element: T) - where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { + unsafe fn push_unchecked( + deque: &mut VecDeque, + element: T, + ) where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(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) }; @@ -54,10 +59,11 @@ where } } -impl SpecExtend for VecDeque +impl SpecExtend + for VecDeque where I: TrustedLen, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { default fn spec_extend(&mut self, iter: I) { // This is the case for a TrustedLen iterator. @@ -90,8 +96,11 @@ where } } -impl SpecExtend> for VecDeque -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +impl SpecExtend> + for VecDeque +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ fn spec_extend(&mut self, mut iterator: vec::IntoIter) { let slice = iterator.as_slice(); self.reserve(slice.len()); @@ -104,21 +113,23 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRE } } -impl<'a, T: 'a, I, A: Allocator, const COOP_PREFERRED: bool> SpecExtend<&'a T, I> for VecDeque +impl<'a, T: 'a, I, A: Allocator, const COOP_PREFERRED: bool> SpecExtend<&'a T, I> + for VecDeque where I: Iterator, T: Copy, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { default fn spec_extend(&mut self, iterator: I) { self.spec_extend(iterator.copied()) } } -impl<'a, T: 'a, A: Allocator, const COOP_PREFERRED: bool> SpecExtend<&'a T, slice::Iter<'a, T>> for VecDeque +impl<'a, T: 'a, A: Allocator, const COOP_PREFERRED: bool> SpecExtend<&'a T, slice::Iter<'a, T>> + for VecDeque where T: Copy, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(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 b9641ef156c88..85dd756337350 100644 --- a/library/alloc/src/collections/vec_deque/spec_from_iter.rs +++ b/library/alloc/src/collections/vec_deque/spec_from_iter.rs @@ -7,10 +7,11 @@ pub(super) trait SpecFromIter { fn spec_from_iter(iter: I) -> Self; } -impl SpecFromIter for VecDeque +impl SpecFromIter + for VecDeque where I: Iterator, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { default fn spec_from_iter(iterator: I) -> Self { // Since converting is O(1) now, just re-use the `Vec` logic for @@ -21,16 +22,22 @@ where } } -impl SpecFromIter> for VecDeque -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +impl SpecFromIter> + for VecDeque +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ #[inline] fn spec_from_iter(iterator: crate::vec::IntoIter) -> Self { iterator.into_vecdeque() } } -impl SpecFromIter> for VecDeque -where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { +impl SpecFromIter> + for VecDeque +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ #[inline] fn spec_from_iter(iterator: IntoIter) -> Self { iterator.into_vecdeque() From 17b3244bf3d1c9590efd8e2290384a21c09374dd Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sat, 21 Jan 2023 22:07:51 -0800 Subject: [PATCH 20/80] CoAlloc: VecDeque. ICE --- library/alloc/src/collections/vec_deque/mod.rs | 13 +++++++------ 1 file changed, 7 insertions(+), 6 deletions(-) diff --git a/library/alloc/src/collections/vec_deque/mod.rs b/library/alloc/src/collections/vec_deque/mod.rs index b441f23ed23f3..7be36d0e1132c 100644 --- a/library/alloc/src/collections/vec_deque/mod.rs +++ b/library/alloc/src/collections/vec_deque/mod.rs @@ -158,7 +158,7 @@ where } #[stable(feature = "rust1", since = "1.0.0")] -impl Default for VecDeque { +impl Default for VecDeque { /// Creates an empty deque. #[inline] fn default() -> VecDeque { @@ -547,7 +547,7 @@ where } } -impl VecDeque +impl VecDeque where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { @@ -581,7 +581,7 @@ where #[inline] #[stable(feature = "rust1", since = "1.0.0")] #[must_use] - pub fn with_capacity(capacity: usize) -> VecDeque { + pub fn with_capacity(capacity: usize) -> VecDeque { Self::with_capacity_in(capacity, Global) } } @@ -2791,7 +2791,7 @@ where } #[stable(feature = "rust1", since = "1.0.0")] -impl FromIterator for VecDeque +impl FromIterator for VecDeque where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { @@ -2976,8 +2976,8 @@ where } #[stable(feature = "std_collections_from_array", since = "1.56.0")] -impl From<[T; N]> - for VecDeque +impl + From<[T; N]> for VecDeque where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { @@ -2996,6 +2996,7 @@ where if !::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); } } From 85c6759d00c6affa95c515b74556930654185b6e Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sat, 21 Jan 2023 22:08:35 -0800 Subject: [PATCH 21/80] CoAlloc: VecDeque. ICE --- library/alloc/src/collections/vec_deque/mod.rs | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/library/alloc/src/collections/vec_deque/mod.rs b/library/alloc/src/collections/vec_deque/mod.rs index 7be36d0e1132c..422d9287ab4a7 100644 --- a/library/alloc/src/collections/vec_deque/mod.rs +++ b/library/alloc/src/collections/vec_deque/mod.rs @@ -8,7 +8,7 @@ #![feature(global_co_alloc)] #![stable(feature = "rust1", since = "1.0.0")] use crate::vec::DEFAULT_COOP_PREFERRED; -use core::alloc::{self, GlobalAlloc}; +use core::alloc; use core::cmp::{self, Ordering}; use core::fmt; use core::hash::{Hash, Hasher}; @@ -158,10 +158,10 @@ where } #[stable(feature = "rust1", since = "1.0.0")] -impl Default for VecDeque { +impl Default for VecDeque { /// Creates an empty deque. #[inline] - fn default() -> VecDeque { + fn default() -> VecDeque { VecDeque::new() } } @@ -2976,8 +2976,8 @@ where } #[stable(feature = "std_collections_from_array", since = "1.56.0")] -impl - From<[T; N]> for VecDeque +impl From<[T; N]> + for VecDeque where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { From 3306d1db213df959531aba4fab27c50d49831cef Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sat, 21 Jan 2023 22:09:19 -0800 Subject: [PATCH 22/80] CoAlloc: Alloc docs. ICE --- library/core/src/alloc/mod.rs | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/library/core/src/alloc/mod.rs b/library/core/src/alloc/mod.rs index cc55c15db6268..d80f6dc17055a 100644 --- a/library/core/src/alloc/mod.rs +++ b/library/core/src/alloc/mod.rs @@ -26,6 +26,12 @@ 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)] @@ -83,6 +89,9 @@ pub type SliceAndMetaResult = Result; #[unstable(feature = "global_co_alloc", issue = "none")] pub const fn co_alloc_metadata_num_slots() -> usize { + if true { + panic!("FIXME - consider removing co_alloc_metadata_num_slots()"); + } if A::IS_CO_ALLOCATOR { 1 } else { 0 } } From 13f09f7371a0a5b22bee800bea453087469dcaef Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Wed, 14 Dec 2022 13:27:35 -0800 Subject: [PATCH 23/80] CoAlloc: Vec + BinaryHeap. ICE --- library/alloc/src/boxed.rs | 10 +++++++--- .../alloc/src/collections/binary_heap/mod.rs | 4 ++-- library/alloc/src/raw_vec.rs | 16 +--------------- library/alloc/src/rc.rs | 12 ++++++++++-- library/alloc/src/slice.rs | 19 ++++++++++++++----- library/alloc/src/str.rs | 8 +++++++- library/alloc/src/vec/mod.rs | 8 ++++---- library/core/src/alloc/mod.rs | 13 +++++++++++++ .../std/src/sys_common/thread_local_dtor.rs | 4 +++- 9 files changed, 61 insertions(+), 33 deletions(-) diff --git a/library/alloc/src/boxed.rs b/library/alloc/src/boxed.rs index 021f36e6770bd..65baed0056619 100644 --- a/library/alloc/src/boxed.rs +++ b/library/alloc/src/boxed.rs @@ -1683,8 +1683,12 @@ impl TryFrom> for Box<[T; N]> { #[cfg(not(no_global_oom_handling))] #[stable(feature = "boxed_array_try_from_vec", since = "1.66.0")] -impl TryFrom> for Box<[T; N]> { - type Error = Vec; +impl TryFrom> + for Box<[T; N]> +where + [(); alloc::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:, +{ + type Error = Vec; /// Attempts to convert a `Vec` into a `Box<[T; N]>`. /// @@ -1704,7 +1708,7 @@ impl TryFrom> 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) -> Result { + fn try_from(vec: Vec) -> Result { if vec.len() == N { let boxed_slice = vec.into_boxed_slice(); Ok(unsafe { boxed_slice_as_array_unchecked(boxed_slice) }) diff --git a/library/alloc/src/collections/binary_heap/mod.rs b/library/alloc/src/collections/binary_heap/mod.rs index 3d10072ce43b4..8409954c5dbc8 100644 --- a/library/alloc/src/collections/binary_heap/mod.rs +++ b/library/alloc/src/collections/binary_heap/mod.rs @@ -1525,7 +1525,7 @@ unsafe impl TrustedLen for IntoIterSorted {} #[derive(Debug)] pub struct Drain<'a, T: 'a, const COOP_PREFERRED: bool> where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:, { iter: vec::Drain<'a, T, Global, COOP_PREFERRED>, } @@ -1533,7 +1533,7 @@ where #[stable(feature = "drain", since = "1.6.0")] impl Iterator for Drain<'_, T, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:, { type Item = T; diff --git a/library/alloc/src/raw_vec.rs b/library/alloc/src/raw_vec.rs index 84fd954edbd7a..e195285511430 100644 --- a/library/alloc/src/raw_vec.rs +++ b/library/alloc/src/raw_vec.rs @@ -69,7 +69,7 @@ pub(crate) struct RawVec< impl RawVec where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); 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()`. @@ -527,20 +527,6 @@ where } } -// @FIXME Custom -unsafe impl<#[may_dangle] T, const COOP_PREFERRED: bool> Drop for RawVec -where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, -{ - /// Frees the memory owned by the `RawVec` *without* trying to drop its contents. - fn drop(&mut self) { - // @TOFIXMEDO - if let Some((ptr, layout)) = self.current_memory() { - unsafe { self.alloc.deallocate(ptr, layout) } - } - } -} - // Central function for reserve error handling. #[cfg(not(no_global_oom_handling))] #[inline] diff --git a/library/alloc/src/rc.rs b/library/alloc/src/rc.rs index c9aa23fc4af1f..b1cffc74f283c 100644 --- a/library/alloc/src/rc.rs +++ b/library/alloc/src/rc.rs @@ -247,6 +247,7 @@ use crate::boxed::Box; #[cfg(test)] use std::boxed::Box; +use crate::alloc; use core::any::Any; use core::borrow; use core::cell::Cell; @@ -1987,7 +1988,10 @@ impl From> for Rc { #[cfg(not(no_global_oom_handling))] #[stable(feature = "shared_from_slice", since = "1.21.0")] -impl From> for Rc<[T]> { +impl From> for Rc<[T]> +where + [(); 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 +2003,10 @@ impl From> for Rc<[T]> { /// assert_eq!(vec![1, 2, 3], *shared); /// ``` #[inline] - fn from(mut v: Vec) -> Rc<[T]> { + fn from(mut v: Vec) -> Rc<[T]> + where + [(); 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 +2127,7 @@ trait ToRcSlice: Iterator + Sized { fn to_rc_slice(self) -> Rc<[T]>; } +// COOP_NOT_POSSIBLE #[cfg(not(no_global_oom_handling))] impl> ToRcSlice 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 205e7b5f1d438..f13d130095fbd 100644 --- a/library/alloc/src/slice.rs +++ b/library/alloc/src/slice.rs @@ -466,10 +466,13 @@ impl [T] { #[rustc_allow_incoherent_impl] #[inline] #[unstable(feature = "allocator_api", issue = "32838")] - pub fn to_vec_in(&self, alloc: A) -> Vec + pub fn to_vec_in( + &self, + alloc: A, + ) -> Vec where T: Clone, - [(); core::alloc::co_alloc_metadata_num_slots::()]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { // N.B., see the `hack` module in this file for more details. hack::to_vec(self, alloc) @@ -492,9 +495,11 @@ impl [T] { #[rustc_allow_incoherent_impl] #[stable(feature = "rust1", since = "1.0.0")] #[inline] - pub fn into_vec(self: Box) -> Vec + pub fn into_vec( + self: Box, + ) -> Vec where - [(); core::alloc::co_alloc_metadata_num_slots::()]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { // N.B., see the `hack` module in this file for more details. hack::into_vec(self) @@ -739,6 +744,7 @@ pub trait Join { 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> Concat for [V] { @@ -754,6 +760,7 @@ impl> Concat for [V] { } } +// COOP_NOT_POSSIBLE #[cfg(not(no_global_oom_handling))] #[unstable(feature = "slice_concat_ext", issue = "27747")] impl> Join<&T> for [V] { @@ -777,10 +784,11 @@ impl> Join<&T> for [V] { } } +// COOP_NOT_POSSIBLE #[cfg(not(no_global_oom_handling))] #[unstable(feature = "slice_concat_ext", issue = "27747")] impl> Join<&[T]> for [V] { - type Output = Vec; + type Output = Vec; fn join(slice: &Self, sep: &[T]) -> Vec { let mut iter = slice.iter(); @@ -825,6 +833,7 @@ where } } +// COOP_NOT_POSSIBLE #[cfg(not(no_global_oom_handling))] #[stable(feature = "rust1", since = "1.0.0")] impl ToOwned for [T] { diff --git a/library/alloc/src/str.rs b/library/alloc/src/str.rs index afbe5cfaf8ef9..eedf856f5d253 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(slice: &[S], sep: &[T]) -> Vec +fn join_generic_copy( + slice: &[S], + sep: &[T], +) -> Vec where T: Copy, B: AsRef<[T]> + ?Sized, S: Borrow, + [(); alloc::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:, { let sep_len = sep.len(); let mut iter = slice.iter(); diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs index c53e3d3ad483f..66d1baafa5538 100644 --- a/library/alloc/src/vec/mod.rs +++ b/library/alloc/src/vec/mod.rs @@ -408,6 +408,10 @@ pub struct Vec< len: usize, } +/// 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; + #[unstable(feature = "global_co_alloc_covec", issue = "none")] pub type CoVec = Vec; @@ -417,10 +421,6 @@ pub type CoVec = Vec; -/// 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; - /// "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. diff --git a/library/core/src/alloc/mod.rs b/library/core/src/alloc/mod.rs index d80f6dc17055a..4a61a9e5215be 100644 --- a/library/core/src/alloc/mod.rs +++ b/library/core/src/alloc/mod.rs @@ -104,6 +104,19 @@ pub const fn co_alloc_metadata_num_slots_with_preference( if A::IS_CO_ALLOCATOR && coop_preferred { 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_global(_coop_preferred: bool) -> usize { + if true { + panic!("FIXME"); + } + // @FIXME Move these functions to :alloc instead. + // Then: + 0 + //if Global::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`][]. /// diff --git a/library/std/src/sys_common/thread_local_dtor.rs b/library/std/src/sys_common/thread_local_dtor.rs index 844946eda031f..43b7b0bb00468 100644 --- a/library/std/src/sys_common/thread_local_dtor.rs +++ b/library/std/src/sys_common/thread_local_dtor.rs @@ -12,9 +12,11 @@ #![unstable(feature = "thread_local_internals", issue = "none")] #![allow(dead_code)] +#![feature(global_co_alloc_plvec)] 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 +30,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 = Box::new(Vec::new()); DTORS.set(Box::into_raw(v) as *mut u8); From 932d3563be5473a3bf440f22ebec5605c31dd438 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sat, 21 Jan 2023 22:12:07 -0800 Subject: [PATCH 24/80] CoAlloc: WeVec. ICE --- library/alloc/src/vec/mod.rs | 2 +- library/std/src/sys/windows/mod.rs | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs index 66d1baafa5538..7db56260e6d9e 100644 --- a/library/alloc/src/vec/mod.rs +++ b/library/alloc/src/vec/mod.rs @@ -432,7 +432,7 @@ pub type DefVec = Vec 1 }>; +pub type WeVec = Vec 127 }>; //////////////////////////////////////////////////////////////////////////////// // Inherent methods 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; 512] = MaybeUninit::uninit_array(); + // @FIXME Use CoVec? let mut heap_buf: Vec> = Vec::new(); unsafe { let mut n = stack_buf.len(); From 4e2268dc0e707f8dfc10440af6f2657af1c2e2dc Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sat, 21 Jan 2023 22:15:44 -0800 Subject: [PATCH 25/80] CoAlloc: Vec + Alloc. Moved co_alloc_metadata_num_slots_with_preference_global from ::core::alloc to ::alloc. ICE --- library/alloc/src/boxed.rs | 2 +- library/alloc/src/lib.rs | 7 +++++++ library/alloc/src/raw_vec.rs | 2 +- library/alloc/src/rc.rs | 5 ++--- library/alloc/src/vec/mod.rs | 1 + library/core/src/alloc/mod.rs | 13 ------------- 6 files changed, 12 insertions(+), 18 deletions(-) diff --git a/library/alloc/src/boxed.rs b/library/alloc/src/boxed.rs index 65baed0056619..615744a2d60a3 100644 --- a/library/alloc/src/boxed.rs +++ b/library/alloc/src/boxed.rs @@ -1686,7 +1686,7 @@ impl TryFrom> for Box<[T; N]> { impl TryFrom> for Box<[T; N]> where - [(); alloc::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:, + [(); crate::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:, { type Error = Vec; diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs index 5d856158c206c..9400be19d6130 100644 --- a/library/alloc/src/lib.rs +++ b/library/alloc/src/lib.rs @@ -284,4 +284,11 @@ pub(crate) mod test_helpers { let seed: [u8; 16] = seed_vec.as_slice().try_into().unwrap(); rand::SeedableRng::from_seed(seed) } + +use crate::alloc::Global; + +/// See also `core::alloc::co_alloc_metadata_num_slots_with_preference`. +#[unstable(feature = "global_co_alloc", issue = "none")] +pub const fn co_alloc_metadata_num_slots_with_preference_global(coop_preferred: bool) -> usize { + if Global::IS_CO_ALLOCATOR && coop_preferred { 1 } else { 0 } } diff --git a/library/alloc/src/raw_vec.rs b/library/alloc/src/raw_vec.rs index e195285511430..99c1b4c6dc13d 100644 --- a/library/alloc/src/raw_vec.rs +++ b/library/alloc/src/raw_vec.rs @@ -69,7 +69,7 @@ pub(crate) struct RawVec< impl RawVec where - [(); alloc::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:, + [(); crate::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()`. diff --git a/library/alloc/src/rc.rs b/library/alloc/src/rc.rs index b1cffc74f283c..aeffaf7afbcd5 100644 --- a/library/alloc/src/rc.rs +++ b/library/alloc/src/rc.rs @@ -247,7 +247,6 @@ use crate::boxed::Box; #[cfg(test)] use std::boxed::Box; -use crate::alloc; use core::any::Any; use core::borrow; use core::cell::Cell; @@ -1990,7 +1989,7 @@ impl From> for Rc { #[stable(feature = "shared_from_slice", since = "1.21.0")] impl From> for Rc<[T]> where - [(); alloc::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:, + [(); crate::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:, { /// Allocate a reference-counted slice and move `v`'s items into it. /// @@ -2005,7 +2004,7 @@ where #[inline] fn from(mut v: Vec) -> Rc<[T]> where - [(); alloc::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:, + [(); crate::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:, { unsafe { let rc = Rc::copy_from_slice(&v); diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs index 7db56260e6d9e..30b57b8d32e95 100644 --- a/library/alloc/src/vec/mod.rs +++ b/library/alloc/src/vec/mod.rs @@ -400,6 +400,7 @@ mod spec_extend; 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::(COOP_PREFERRED)]:, diff --git a/library/core/src/alloc/mod.rs b/library/core/src/alloc/mod.rs index 4a61a9e5215be..d80f6dc17055a 100644 --- a/library/core/src/alloc/mod.rs +++ b/library/core/src/alloc/mod.rs @@ -104,19 +104,6 @@ pub const fn co_alloc_metadata_num_slots_with_preference( if A::IS_CO_ALLOCATOR && coop_preferred { 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_global(_coop_preferred: bool) -> usize { - if true { - panic!("FIXME"); - } - // @FIXME Move these functions to :alloc instead. - // Then: - 0 - //if Global::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`][]. /// From 4f54ecb296dfd55495f3f0260b4147983f80c01f Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sat, 21 Jan 2023 22:16:10 -0800 Subject: [PATCH 26/80] CoAlloc: BinaryHeap. ICE --- library/alloc/src/collections/binary_heap/mod.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/library/alloc/src/collections/binary_heap/mod.rs b/library/alloc/src/collections/binary_heap/mod.rs index 8409954c5dbc8..f1b0cc4a72424 100644 --- a/library/alloc/src/collections/binary_heap/mod.rs +++ b/library/alloc/src/collections/binary_heap/mod.rs @@ -1525,7 +1525,7 @@ unsafe impl TrustedLen for IntoIterSorted {} #[derive(Debug)] pub struct Drain<'a, T: 'a, const COOP_PREFERRED: bool> where - [(); alloc::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:, + [(); crate::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:, { iter: vec::Drain<'a, T, Global, COOP_PREFERRED>, } @@ -1533,7 +1533,7 @@ where #[stable(feature = "drain", since = "1.6.0")] impl Iterator for Drain<'_, T, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:, + [(); crate::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:, { type Item = T; From 72db464d2e0887b5b00f5fd9ab5aab8dd182ee6e Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 07:41:26 -0800 Subject: [PATCH 27/80] CoAlloc: Vec: Renamed ::core::alloc::co_alloc_metadata_num_slots_with_preference to ::core::alloc::co_alloc_metadata_num_slots_with_preference_specific. ICE --- library/alloc/src/raw_vec.rs | 20 +++--- library/alloc/src/slice.rs | 40 ++++++++--- library/alloc/src/vec/drain.rs | 28 ++++---- library/alloc/src/vec/drain_filter.rs | 12 ++-- library/alloc/src/vec/into_iter.rs | 36 +++++----- library/alloc/src/vec/mod.rs | 90 ++++++++++++++----------- library/alloc/src/vec/partial_eq.rs | 20 +++--- library/alloc/src/vec/spec_extend.rs | 10 +-- library/alloc/src/vec/spec_from_elem.rs | 8 +-- library/core/src/alloc/mod.rs | 2 +- library/std/src/io/cursor.rs | 12 ++-- 11 files changed, 154 insertions(+), 124 deletions(-) diff --git a/library/alloc/src/raw_vec.rs b/library/alloc/src/raw_vec.rs index 99c1b4c6dc13d..f74e876b6cb9c 100644 --- a/library/alloc/src/raw_vec.rs +++ b/library/alloc/src/raw_vec.rs @@ -55,7 +55,7 @@ pub(crate) struct RawVec< A: Allocator = Global, const COOP_PREFERRED: bool = DEFAULT_COOP_PREFERRED, > where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { ptr: Unique, cap: usize, @@ -64,7 +64,7 @@ pub(crate) struct RawVec< //pub(crate) meta: [GlobalCoAllocMeta; {if core::any::TypeId::of::()==core::any::TypeId::of::() {1} else {0}}], //pub(crate) meta: [GlobalCoAllocMeta; mem::size_of::()], pub(crate) metas: [GlobalCoAllocMeta; - alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)], + alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)], } impl RawVec @@ -119,7 +119,7 @@ where impl RawVec where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { // Tiny Vecs are dumb. Skip to: // - 8 if the element size is 1, because any heap allocators is likely @@ -143,7 +143,7 @@ where cap: 0, alloc, metas: [GlobalCoAllocMeta {/*one: 1*/ /* , two: 2, three: 3, four: 4*/}; - alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)], + alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)], } } @@ -222,7 +222,9 @@ where cap: capacity, alloc, metas: [GlobalCoAllocMeta {/*one: 1*/ /*, two: 2, three: 3, four: 4*/}; - alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)], + alloc::co_alloc_metadata_num_slots_with_preference_specific::( + COOP_PREFERRED, + )], } } } @@ -244,7 +246,7 @@ where cap: capacity, alloc, metas: [GlobalCoAllocMeta {/*one: 1*/ /*, two: 2, three: 3, four: 4*/}; - alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)], + alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)], } } @@ -314,7 +316,7 @@ where len: usize, additional: usize, ) where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { handle_reserve(slf.grow_amortized(len, additional)); } @@ -390,7 +392,7 @@ where impl RawVec where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(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`. @@ -512,7 +514,7 @@ where unsafe impl<#[may_dangle] T, A: Allocator, const COOP_PREFERRED: bool> Drop for RawVec where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { /// Frees the memory owned by the `RawVec` *without* trying to drop its contents. default fn drop(&mut self) { diff --git a/library/alloc/src/slice.rs b/library/alloc/src/slice.rs index f13d130095fbd..e621f900c6036 100644 --- a/library/alloc/src/slice.rs +++ b/library/alloc/src/slice.rs @@ -101,7 +101,9 @@ pub(crate) mod hack { b: Box<[T], A>, ) -> Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::( + COOP_PREFERRED, + )]:, { unsafe { let len = b.len(); @@ -117,7 +119,9 @@ pub(crate) mod hack { alloc: A, ) -> Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::( + COOP_PREFERRED, + )]:, { T::to_vec(s, alloc) } @@ -130,7 +134,9 @@ pub(crate) mod hack { ) -> Vec where Self: Sized, - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:; + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::( + COOP_PREFERRED, + )]:; } #[cfg(not(no_global_oom_handling))] @@ -141,18 +147,24 @@ pub(crate) mod hack { alloc: A, ) -> Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::( + COOP_PREFERRED, + )]:, { struct DropGuard<'a, T, A: Allocator, const COOP_PREFERRED: bool> where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::( + COOP_PREFERRED, + )]:, { vec: &'a mut Vec, num_init: usize, } 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::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::( + COOP_PREFERRED, + )]:, { #[inline] fn drop(&mut self) { @@ -190,7 +202,9 @@ pub(crate) mod hack { alloc: A, ) -> Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::( + COOP_PREFERRED, + )]:, { let mut v = Vec::with_capacity_in(s.len(), alloc); // SAFETY: @@ -472,7 +486,9 @@ impl [T] { ) -> Vec where T: Clone, - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::( + COOP_PREFERRED, + )]:, { // N.B., see the `hack` module in this file for more details. hack::to_vec(self, alloc) @@ -499,7 +515,9 @@ impl [T] { self: Box, ) -> Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::( + COOP_PREFERRED, + )]:, { // N.B., see the `hack` module in this file for more details. hack::into_vec(self) @@ -816,7 +834,7 @@ impl> Join<&[T]> for [V] { #[stable(feature = "rust1", since = "1.0.0")] impl Borrow<[T]> for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn borrow(&self) -> &[T] { &self[..] @@ -826,7 +844,7 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl BorrowMut<[T]> for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn borrow_mut(&mut self) -> &mut [T] { &mut self[..] diff --git a/library/alloc/src/vec/drain.rs b/library/alloc/src/vec/drain.rs index d7f7292e4f1cf..2159edc7b1a23 100644 --- a/library/alloc/src/vec/drain.rs +++ b/library/alloc/src/vec/drain.rs @@ -25,7 +25,7 @@ pub struct Drain< #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator + 'a = Global, const COOP_PREFERRED: bool = { alloc::SHORT_TERM_VEC_PREFERS_COOP }, > where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { /// Index of tail to preserve pub(super) tail_start: usize, @@ -40,7 +40,7 @@ pub struct Drain< impl fmt::Debug for Drain<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_tuple("Drain").field(&self.iter.as_slice()).finish() @@ -49,7 +49,7 @@ where impl<'a, T, A: Allocator, const COOP_PREFERRED: bool> Drain<'a, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { /// Returns the remaining items of this iterator as a slice. /// @@ -151,7 +151,7 @@ where #[stable(feature = "vec_drain_as_slice", since = "1.46.0")] 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::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn as_ref(&self) -> &[T] { self.as_slice() @@ -162,21 +162,21 @@ where unsafe impl Sync for Drain<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { } #[stable(feature = "drain", since = "1.6.0")] unsafe impl Send for Drain<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { } #[stable(feature = "drain", since = "1.6.0")] impl Iterator for Drain<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { type Item = T; @@ -194,7 +194,7 @@ where impl DoubleEndedIterator for Drain<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { #[inline] fn next_back(&mut self) -> Option { @@ -205,7 +205,7 @@ where #[stable(feature = "drain", since = "1.6.0")] impl Drop for Drain<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn drop(&mut self) { /// Moves back the un-`Drain`ed elements to restore the original `Vec`. @@ -213,12 +213,12 @@ where &'r mut Drain<'a, T, A, COOP_PREFERRED>, ) where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:; + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(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::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn drop(&mut self) { if self.0.tail_len > 0 { @@ -286,7 +286,7 @@ where impl ExactSizeIterator for Drain<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn is_empty(&self) -> bool { self.iter.is_empty() @@ -297,12 +297,12 @@ where unsafe impl TrustedLen for Drain<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { } #[stable(feature = "fused", since = "1.26.0")] impl FusedIterator for Drain<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]: { } diff --git a/library/alloc/src/vec/drain_filter.rs b/library/alloc/src/vec/drain_filter.rs index 89baafca46729..29cf29e2532d9 100644 --- a/library/alloc/src/vec/drain_filter.rs +++ b/library/alloc/src/vec/drain_filter.rs @@ -27,7 +27,7 @@ pub struct DrainFilter< const COOP_PREFERRED: bool = true, > where F: FnMut(&mut T) -> bool, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { pub(super) vec: &'a mut Vec, /// The index of the item that will be inspected by the next call to `next`. @@ -49,7 +49,7 @@ pub struct DrainFilter< impl DrainFilter<'_, T, F, A, COOP_PREFERRED> where F: FnMut(&mut T) -> bool, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { /// Returns a reference to the underlying allocator. #[unstable(feature = "allocator_api", issue = "32838")] @@ -119,7 +119,7 @@ impl Iterator for DrainFilter<'_, T, F, A, COOP_PREFERRED> where F: FnMut(&mut T) -> bool, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { type Item = T; @@ -159,13 +159,13 @@ impl Drop for DrainFilter<'_, T, F, A, COOP_PREFERRED> where F: FnMut(&mut T) -> bool, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn drop(&mut self) { 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::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { drain: &'b mut DrainFilter<'a, T, F, A, COOP_PREFERRED>, } @@ -174,7 +174,7 @@ where for BackshiftOnDrop<'a, 'b, T, F, A, COOP_PREFERRED> where F: FnMut(&mut T) -> bool, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn drop(&mut self) { unsafe { diff --git a/library/alloc/src/vec/into_iter.rs b/library/alloc/src/vec/into_iter.rs index 790e6323f514e..98b7a7cda6731 100644 --- a/library/alloc/src/vec/into_iter.rs +++ b/library/alloc/src/vec/into_iter.rs @@ -33,7 +33,7 @@ pub struct IntoIter< #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global, const COOP_PREFERRED: bool = { alloc::SHORT_TERM_VEC_PREFERS_COOP }, > where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { pub(super) buf: NonNull, pub(super) phantom: PhantomData, @@ -51,7 +51,7 @@ pub struct IntoIter< impl fmt::Debug for IntoIter where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_tuple("IntoIter").field(&self.as_slice()).finish() @@ -60,7 +60,7 @@ where impl IntoIter where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { /// Returns the remaining items of this iterator as a slice. /// @@ -179,7 +179,7 @@ where #[stable(feature = "vec_intoiter_as_ref", since = "1.46.0")] impl AsRef<[T]> for IntoIter where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn as_ref(&self) -> &[T] { self.as_slice() @@ -190,21 +190,21 @@ where unsafe impl Send for IntoIter where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { } #[stable(feature = "rust1", since = "1.0.0")] unsafe impl Sync for IntoIter where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { } #[stable(feature = "rust1", since = "1.0.0")] impl Iterator for IntoIter where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { type Item = T; @@ -322,7 +322,7 @@ where impl DoubleEndedIterator for IntoIter where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { #[inline] fn next_back(&mut self) -> Option { @@ -367,7 +367,7 @@ where impl ExactSizeIterator for IntoIter where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn is_empty(&self) -> bool { self.ptr == self.end @@ -376,7 +376,7 @@ where #[stable(feature = "fused", since = "1.26.0")] impl FusedIterator for IntoIter where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]: { } @@ -384,7 +384,7 @@ impl FusedIterator for IntoIter TrustedLen for IntoIter where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { } @@ -406,7 +406,7 @@ unsafe impl TrustedRandomAccessNoCo for IntoIter where T: NonDrop, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { const MAY_HAVE_SIDE_EFFECT: bool = false; } @@ -416,7 +416,7 @@ where impl Clone for IntoIter where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { #[cfg(not(test))] fn clone(&self) -> Self { @@ -432,18 +432,18 @@ where unsafe impl<#[may_dangle] T, A: Allocator, const COOP_PREFERRED: bool> Drop for IntoIter where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn drop(&mut self) { struct DropGuard<'a, T, A: Allocator, const COOP_PREFERRED: bool>( &'a mut IntoIter, ) where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:; + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:; impl Drop for DropGuard<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn drop(&mut self) { unsafe { @@ -475,7 +475,7 @@ where unsafe impl InPlaceIterable for IntoIter where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { } @@ -484,7 +484,7 @@ where unsafe impl SourceIter for IntoIter where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { type Source = Self; diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs index 30b57b8d32e95..3692169f7ae6e 100644 --- a/library/alloc/src/vec/mod.rs +++ b/library/alloc/src/vec/mod.rs @@ -403,7 +403,7 @@ pub struct Vec< //@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::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { buf: RawVec, len: usize, @@ -628,7 +628,7 @@ impl Vec { impl Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { /// Constructs a new, empty `Vec`. /// @@ -1644,7 +1644,9 @@ where // In cases when predicate and `drop` never panick, it will be optimized out. struct BackshiftOnDrop<'a, T, A: Allocator, const VEC_IS_COOP: bool = true> where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(VEC_IS_COOP)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::( + VEC_IS_COOP, + )]:, { v: &'a mut Vec, processed_len: usize, @@ -1654,7 +1656,9 @@ where impl Drop for BackshiftOnDrop<'_, T, A, VEC_IS_COOP> where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(VEC_IS_COOP)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::( + VEC_IS_COOP, + )]:, { fn drop(&mut self) { if self.deleted_cnt > 0 { @@ -1687,7 +1691,9 @@ where g: &mut BackshiftOnDrop<'_, T, A, VEC_IS_COOP>, ) where F: FnMut(&mut T) -> bool, - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(VEC_IS_COOP)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::( + VEC_IS_COOP, + )]:, { while g.processed_len != original_len { // SAFETY: Unchecked element must be valid. @@ -1782,7 +1788,9 @@ where /* INVARIANT: vec.len() > read >= write > write-1 >= 0 */ struct FillGapOnDrop<'a, T, A: core::alloc::Allocator, const COOP_PREFERRED: bool> where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::( + COOP_PREFERRED, + )]:, { /* Offset of the element we want to check if it is duplicate */ read: usize, @@ -1798,7 +1806,9 @@ where 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::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::( + COOP_PREFERRED, + )]:, { fn drop(&mut self) { /* This code gets executed when `same_bucket` panics */ @@ -2394,7 +2404,7 @@ where impl Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { /// Resizes the `Vec` in-place so that `len` is equal to `new_len`. /// @@ -2496,7 +2506,7 @@ where impl Vec<[T; N], A, COOP_PREFERRED> where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { /// Takes a `Vec<[T; N]>` and flattens it into a `Vec`. /// @@ -2560,7 +2570,7 @@ impl ExtendWith for ExtendElement { impl Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { #[cfg(not(no_global_oom_handling))] /// Extend the vector by `n` values, using the given generator. @@ -2595,7 +2605,7 @@ where impl Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { /// Removes consecutive repeated elements in the vector according to the /// [`PartialEq`] trait implementation. @@ -2638,7 +2648,7 @@ pub fn from_elem_in( alloc: A, ) -> Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { ::from_elem(elem, n, alloc) } @@ -2654,7 +2664,7 @@ trait ExtendFromWithinSpec { impl ExtendFromWithinSpec for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { default unsafe fn spec_extend_from_within(&mut self, src: Range) { // SAFETY: @@ -2677,7 +2687,7 @@ where impl ExtendFromWithinSpec for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { unsafe fn spec_extend_from_within(&mut self, src: Range) { let count = src.len(); @@ -2713,7 +2723,7 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl ops::Deref for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { type Target = [T]; @@ -2726,7 +2736,7 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl ops::DerefMut for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { #[inline] fn deref_mut(&mut self) -> &mut [T] { @@ -2742,7 +2752,7 @@ trait SpecCloneFrom { #[cfg(not(no_global_oom_handling))] impl SpecCloneFrom for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { default fn clone_from(this: &mut Self, other: &Self) { // drop anything that will not be overwritten @@ -2761,7 +2771,7 @@ where #[cfg(not(no_global_oom_handling))] impl SpecCloneFrom for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn clone_from(this: &mut Self, other: &Self) { this.clear(); @@ -2773,7 +2783,7 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl Clone for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { #[cfg(not(test))] fn clone(&self) -> Self { @@ -2811,7 +2821,7 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl Hash for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { #[inline] fn hash(&self, state: &mut H) { @@ -2827,7 +2837,7 @@ where impl, A: Allocator, const COOP_PREFERRED: bool> Index for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { type Output = I::Output; @@ -2845,7 +2855,7 @@ where impl, A: Allocator, const COOP_PREFERRED: bool> IndexMut for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { #[inline] fn index_mut(&mut self, index: I) -> &mut Self::Output { @@ -2865,7 +2875,7 @@ impl FromIterator for Vec { #[stable(feature = "rust1", since = "1.0.0")] impl IntoIterator for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { type Item = T; type IntoIter = IntoIter; @@ -2913,7 +2923,7 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl<'a, T, A: Allocator, const COOP_PREFERRED: bool> IntoIterator for &'a Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { type Item = &'a T; type IntoIter = slice::Iter<'a, T>; @@ -2927,7 +2937,7 @@ where impl<'a, T, A: Allocator, const COOP_PREFERRED: bool> IntoIterator for &'a mut Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { type Item = &'a mut T; type IntoIter = slice::IterMut<'a, T>; @@ -2941,7 +2951,7 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl Extend for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { #[inline] fn extend>(&mut self, iter: I) { @@ -2961,7 +2971,7 @@ where impl Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { // leaf method to which various SpecFrom/SpecExtend implementations delegate when // they have no further optimizations to apply @@ -3139,7 +3149,7 @@ where impl<'a, T: Copy + 'a, A: Allocator + 'a, const COOP_PREFERRED: bool> Extend<&'a T> for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn extend>(&mut self, iter: I) { self.spec_extend(iter.into_iter()) @@ -3161,7 +3171,7 @@ where impl PartialOrd for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { #[inline] fn partial_cmp(&self, other: &Self) -> Option { @@ -3171,7 +3181,7 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl Eq for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]: { } @@ -3179,7 +3189,7 @@ impl Eq for Vec Ord for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { #[inline] fn cmp(&self, other: &Self) -> Ordering { @@ -3191,7 +3201,7 @@ where unsafe impl<#[may_dangle] T, A: Allocator, const COOP_PREFERRED: bool> Drop for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn drop(&mut self) { unsafe { @@ -3219,7 +3229,7 @@ impl const Default for Vec { impl fmt::Debug for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fmt::Debug::fmt(&**self, f) @@ -3230,7 +3240,7 @@ where impl AsRef> for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn as_ref(&self) -> &Vec { self @@ -3241,7 +3251,7 @@ where impl AsMut> for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn as_mut(&mut self) -> &mut Vec { self @@ -3251,7 +3261,7 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl AsRef<[T]> for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn as_ref(&self) -> &[T] { self @@ -3261,7 +3271,7 @@ where #[stable(feature = "vec_as_mut", since = "1.5.0")] impl AsMut<[T]> for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn as_mut(&mut self) -> &mut [T] { self @@ -3361,7 +3371,7 @@ where #[stable(feature = "vec_from_box", since = "1.18.0")] impl From> for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { /// Convert a boxed slice into a vector by transferring ownership of /// the existing heap allocation. @@ -3383,7 +3393,7 @@ where #[stable(feature = "box_from_vec", since = "1.20.0")] impl From> for Box<[T], A> where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { /// Convert a vector into a boxed slice. /// @@ -3427,7 +3437,7 @@ impl From<&str> for Vec { impl TryFrom> for [T; N] where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { type Error = Vec; diff --git a/library/alloc/src/vec/partial_eq.rs b/library/alloc/src/vec/partial_eq.rs index bcf52b7333218..7b364e8d4bacd 100644 --- a/library/alloc/src/vec/partial_eq.rs +++ b/library/alloc/src/vec/partial_eq.rs @@ -21,21 +21,21 @@ macro_rules! __impl_slice_eq1 { } } -__impl_slice_eq1! { [A1: Allocator, A2: Allocator, const COOP_PREFERRED1: bool, const COOP_PREFERRED2: bool] Vec, Vec, #[stable(feature = "rust1", since = "1.0.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED1)]:, [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED2)]: } -__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] Vec, &[U], #[stable(feature = "rust1", since = "1.0.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: } -__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] Vec, &mut [U], #[stable(feature = "rust1", since = "1.0.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: } -__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] &[T], Vec, #[stable(feature = "partialeq_vec_for_ref_slice", since = "1.46.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: } -__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] &mut [T], Vec, #[stable(feature = "partialeq_vec_for_ref_slice", since = "1.46.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: } -__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] Vec, [U], #[stable(feature = "partialeq_vec_for_slice", since = "1.48.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: } -__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] [T], Vec, #[stable(feature = "partialeq_vec_for_slice", since = "1.48.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: } +__impl_slice_eq1! { [A1: Allocator, A2: Allocator, const COOP_PREFERRED1: bool, const COOP_PREFERRED2: bool] Vec, Vec, #[stable(feature = "rust1", since = "1.0.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED1)]:, [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED2)]: } +__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] Vec, &[U], #[stable(feature = "rust1", since = "1.0.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]: } +__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] Vec, &mut [U], #[stable(feature = "rust1", since = "1.0.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]: } +__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] &[T], Vec, #[stable(feature = "partialeq_vec_for_ref_slice", since = "1.46.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]: } +__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] &mut [T], Vec, #[stable(feature = "partialeq_vec_for_ref_slice", since = "1.46.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]: } +__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] Vec, [U], #[stable(feature = "partialeq_vec_for_slice", since = "1.48.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]: } +__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] [T], Vec, #[stable(feature = "partialeq_vec_for_slice", since = "1.48.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]: } #[cfg(not(no_global_oom_handling))] -__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] Cow<'_, [T]>, Vec, #[stable(feature = "rust1", since = "1.0.0")], T: Clone, [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: } +__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] Cow<'_, [T]>, Vec, #[stable(feature = "rust1", since = "1.0.0")], T: Clone, [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]: } #[cfg(not(no_global_oom_handling))] __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], #[stable(feature = "rust1", since = "1.0.0")], T: Clone } -__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool, const N: usize] Vec, [U; N], #[stable(feature = "rust1", since = "1.0.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: } -__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool, const N: usize] Vec, &[U; N], #[stable(feature = "rust1", since = "1.0.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: } +__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool, const N: usize] Vec, [U; N], #[stable(feature = "rust1", since = "1.0.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]: } +__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool, const N: usize] Vec, &[U; N], #[stable(feature = "rust1", since = "1.0.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(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 73cf325889290..ea91491f62558 100644 --- a/library/alloc/src/vec/spec_extend.rs +++ b/library/alloc/src/vec/spec_extend.rs @@ -13,7 +13,7 @@ pub(super) trait SpecExtend { impl SpecExtend for Vec where I: Iterator, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { default fn spec_extend(&mut self, iter: I) { self.extend_desugared(iter) @@ -23,7 +23,7 @@ where impl SpecExtend for Vec where I: TrustedLen, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { default fn spec_extend(&mut self, iterator: I) { self.extend_trusted(iterator) @@ -33,7 +33,7 @@ where impl SpecExtend> for Vec where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn spec_extend(&mut self, mut iterator: IntoIter) { unsafe { @@ -48,7 +48,7 @@ impl<'a, T: 'a, I, A: Allocator + 'a, const COOP_PREFERRED: bool> SpecExtend<&'a where I: Iterator, T: Clone, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { default fn spec_extend(&mut self, iterator: I) { self.spec_extend(iterator.cloned()) @@ -59,7 +59,7 @@ impl<'a, T: 'a, A: Allocator + 'a, const COOP_PREFERRED: bool> SpecExtend<&'a T, for Vec where T: Copy, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(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 3766f6de061bb..4c29f6184c149 100644 --- a/library/alloc/src/vec/spec_from_elem.rs +++ b/library/alloc/src/vec/spec_from_elem.rs @@ -24,7 +24,7 @@ impl SpecFromElem for T { alloc: A, ) -> Vec where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { let mut v = Vec::with_capacity_in(n, alloc); v.extend_with(n, ExtendElement(elem)); @@ -40,7 +40,7 @@ impl SpecFromElem for T { alloc: A, ) -> Vec where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { if elem.is_zero() { return Vec { buf: RawVec::with_capacity_zeroed_in(n, alloc), len: n }; @@ -59,7 +59,7 @@ impl SpecFromElem for i8 { alloc: A, ) -> Vec where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { if elem == 0 { return Vec { buf: RawVec::with_capacity_zeroed_in(n, alloc), len: n }; @@ -81,7 +81,7 @@ impl SpecFromElem for u8 { alloc: A, ) -> Vec where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { if elem == 0 { return Vec { buf: RawVec::with_capacity_zeroed_in(n, alloc), len: n }; diff --git a/library/core/src/alloc/mod.rs b/library/core/src/alloc/mod.rs index d80f6dc17055a..eb7edf1600ef7 100644 --- a/library/core/src/alloc/mod.rs +++ b/library/core/src/alloc/mod.rs @@ -98,7 +98,7 @@ pub const fn co_alloc_metadata_num_slots() -> usize { #[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( +pub const fn co_alloc_metadata_num_slots_with_preference_specific( coop_preferred: bool, ) -> usize { if A::IS_CO_ALLOCATOR && coop_preferred { 1 } else { 0 } diff --git a/library/std/src/io/cursor.rs b/library/std/src/io/cursor.rs index 63045ebcb8157..f8d2ca1d3e74c 100644 --- a/library/std/src/io/cursor.rs +++ b/library/std/src/io/cursor.rs @@ -404,7 +404,7 @@ fn reserve_and_pad( buf_len: usize, ) -> io::Result where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { let pos: usize = (*pos_mut).try_into().map_err(|_| { io::const_io_error!( @@ -451,7 +451,7 @@ unsafe fn vec_write_unchecked( ) -> usize where A: Allocator, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { debug_assert!(vec.capacity() >= pos + buf.len()); vec.as_mut_ptr().add(pos).copy_from(buf.as_ptr(), buf.len()); @@ -474,7 +474,7 @@ fn vec_write( ) -> io::Result where A: Allocator, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { let buf_len = buf.len(); let mut pos = reserve_and_pad(pos_mut, vec, buf_len)?; @@ -510,7 +510,7 @@ fn vec_write_vectored( ) -> io::Result where A: Allocator, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(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. @@ -561,7 +561,7 @@ impl Write for Cursor<&mut [u8]> { impl Write for Cursor<&mut Vec> where A: Allocator, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn write(&mut self, buf: &[u8]) -> io::Result { vec_write(&mut self.pos, self.inner, buf) @@ -586,7 +586,7 @@ where impl Write for Cursor> where A: Allocator, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn write(&mut self, buf: &[u8]) -> io::Result { vec_write(&mut self.pos, &mut self.inner, buf) From f9d07dec76e88d2a75910247bb3f22461e56a64f Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 07:41:35 -0800 Subject: [PATCH 28/80] CoAlloc: VecDeque: Renamed ::core::alloc::co_alloc_metadata_num_slots_with_preference to ::core::alloc::co_alloc_metadata_num_slots_with_preference_specific. ICE --- .../alloc/src/collections/vec_deque/drain.rs | 24 ++++---- .../src/collections/vec_deque/into_iter.rs | 2 +- .../alloc/src/collections/vec_deque/macros.rs | 2 +- .../alloc/src/collections/vec_deque/mod.rs | 56 ++++++++++--------- .../src/collections/vec_deque/spec_extend.rs | 12 ++-- .../collections/vec_deque/spec_from_iter.rs | 6 +- 6 files changed, 52 insertions(+), 50 deletions(-) diff --git a/library/alloc/src/collections/vec_deque/drain.rs b/library/alloc/src/collections/vec_deque/drain.rs index 0bcf82e3ceff5..2004060c4bb96 100644 --- a/library/alloc/src/collections/vec_deque/drain.rs +++ b/library/alloc/src/collections/vec_deque/drain.rs @@ -21,7 +21,7 @@ pub struct Drain< #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global, const COOP_PREFERRED: bool = { alloc::SHORT_TERM_VEC_PREFERS_COOP }, > where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { // We can't just use a &mut VecDeque, as that would make Drain invariant over T // and we want it to be covariant instead @@ -39,7 +39,7 @@ pub struct Drain< impl<'a, T, A: Allocator, const COOP_PREFERRED: bool> Drain<'a, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { pub(super) unsafe fn new( deque: &'a mut VecDeque, @@ -97,7 +97,7 @@ where impl fmt::Debug for Drain<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_tuple("Drain") @@ -113,33 +113,33 @@ where unsafe impl Sync for Drain<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { } #[stable(feature = "drain", since = "1.6.0")] unsafe impl Send for Drain<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { } #[stable(feature = "drain", since = "1.6.0")] impl Drop for Drain<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn drop(&mut self) { 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::(COOP_PREFERRED)]:; + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(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::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn drop(&mut self) { if self.0.remaining != 0 { @@ -223,7 +223,7 @@ where #[stable(feature = "drain", since = "1.6.0")] impl Iterator for Drain<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { type Item = T; @@ -249,7 +249,7 @@ where impl DoubleEndedIterator for Drain<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { #[inline] fn next_back(&mut self) -> Option { @@ -266,12 +266,12 @@ where impl ExactSizeIterator for Drain<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { } #[stable(feature = "fused", since = "1.26.0")] impl FusedIterator for Drain<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(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 7924098c14db2..1c3bedd21e7e2 100644 --- a/library/alloc/src/collections/vec_deque/into_iter.rs +++ b/library/alloc/src/collections/vec_deque/into_iter.rs @@ -19,7 +19,7 @@ pub struct IntoIter< #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global, const COOP_PREFERRED: bool = true, > where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { inner: VecDeque, } diff --git a/library/alloc/src/collections/vec_deque/macros.rs b/library/alloc/src/collections/vec_deque/macros.rs index 68ee43152b5b5..77885e6811a3b 100644 --- a/library/alloc/src/collections/vec_deque/macros.rs +++ b/library/alloc/src/collections/vec_deque/macros.rs @@ -4,7 +4,7 @@ macro_rules! __impl_slice_eq1 { impl PartialEq<$rhs> for $lhs where T: PartialEq, - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(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 422d9287ab4a7..9107526f23cf5 100644 --- a/library/alloc/src/collections/vec_deque/mod.rs +++ b/library/alloc/src/collections/vec_deque/mod.rs @@ -98,7 +98,7 @@ pub struct VecDeque< #[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::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { // `self[0]`, if it exists, is `buf[head]`. // `head < buf.capacity()`, unless `buf.capacity() == 0` when `head == 0`. @@ -114,7 +114,7 @@ pub struct VecDeque< impl Clone for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn clone(&self) -> Self { let mut deq = Self::with_capacity_in(self.len(), self.allocator().clone()); @@ -132,7 +132,7 @@ where unsafe impl<#[may_dangle] T, A: Allocator, const COOP_PREFERRED: bool> Drop for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn drop(&mut self) { /// Runs the destructor for all items in the slice when it gets dropped (normally or @@ -168,7 +168,7 @@ impl Default for VecDeque VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { /// Marginally more convenient #[inline] @@ -460,7 +460,7 @@ where ) -> usize { struct Guard<'a, T, A: Allocator, const COOP_PREFERRED: bool> where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { deque: &'a mut VecDeque, written: usize, @@ -468,7 +468,7 @@ where 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::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn drop(&mut self) { self.deque.len += self.written; @@ -549,7 +549,7 @@ where impl VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { /// Creates an empty deque. /// @@ -588,7 +588,7 @@ where impl VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { /// Creates an empty deque. /// @@ -2626,7 +2626,7 @@ where impl VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(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` @@ -2675,7 +2675,7 @@ fn wrap_index(logical_index: usize, capacity: usize) -> usize { impl PartialEq for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn eq(&self, other: &Self) -> bool { if self.len != other.len() { @@ -2716,7 +2716,7 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl Eq for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]: { } @@ -2731,7 +2731,7 @@ __impl_slice_eq1! { [const N: usize] VecDeque, &mut [U; N] impl PartialOrd for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn partial_cmp(&self, other: &Self) -> Option { self.iter().partial_cmp(other.iter()) @@ -2741,7 +2741,7 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl Ord for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { #[inline] fn cmp(&self, other: &Self) -> Ordering { @@ -2752,7 +2752,7 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl Hash for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn hash(&self, state: &mut H) { state.write_length_prefix(self.len); @@ -2769,7 +2769,7 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl Index for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { type Output = T; @@ -2782,7 +2782,7 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl IndexMut for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { #[inline] fn index_mut(&mut self, index: usize) -> &mut T { @@ -2793,7 +2793,7 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl FromIterator for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn from_iter>(iter: I) -> VecDeque { SpecFromIter::spec_from_iter(iter.into_iter()) @@ -2803,7 +2803,7 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl IntoIterator for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { type Item = T; type IntoIter = IntoIter; @@ -2819,7 +2819,7 @@ where impl<'a, T, A: Allocator, const COOP_PREFERRED: bool> IntoIterator for &'a VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { type Item = &'a T; type IntoIter = Iter<'a, T>; @@ -2833,7 +2833,7 @@ where impl<'a, T, A: Allocator, const COOP_PREFERRED: bool> IntoIterator for &'a mut VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { type Item = &'a mut T; type IntoIter = IterMut<'a, T>; @@ -2846,7 +2846,7 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl Extend for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn extend>(&mut self, iter: I) { >::spec_extend(self, iter.into_iter()); @@ -2867,7 +2867,7 @@ where impl<'a, T: 'a + Copy, A: Allocator, const COOP_PREFERRED: bool> Extend<&'a T> for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn extend>(&mut self, iter: I) { self.spec_extend(iter.into_iter()); @@ -2888,7 +2888,7 @@ where impl fmt::Debug for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_list().entries(self.iter()).finish() @@ -2899,7 +2899,7 @@ where impl From> for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { /// Turn a [`Vec`] into a [`VecDeque`]. /// @@ -2912,7 +2912,9 @@ where #[inline] fn from(other: Vec) -> Self where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(OTHER_COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::( + OTHER_COOP_PREFERRED, + )]:, { 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) } } @@ -2923,7 +2925,7 @@ where impl From> for Vec where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { /// Turn a [`VecDeque`] into a [`Vec`]. /// @@ -2979,7 +2981,7 @@ where impl From<[T; N]> for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { /// Converts a `[T; N]` into a `VecDeque`. /// diff --git a/library/alloc/src/collections/vec_deque/spec_extend.rs b/library/alloc/src/collections/vec_deque/spec_extend.rs index b1a9d23fd4a99..973de88ffb172 100644 --- a/library/alloc/src/collections/vec_deque/spec_extend.rs +++ b/library/alloc/src/collections/vec_deque/spec_extend.rs @@ -17,7 +17,7 @@ impl SpecExtend for VecDeque where I: Iterator, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { default fn spec_extend(&mut self, mut iter: I) { // This function should be the moral equivalent of: @@ -31,7 +31,7 @@ where deque: &mut VecDeque, element: T, ) where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { // SAFETY: Because of the precondition, it's guaranteed that there is space // in the logical array after the last element. @@ -63,7 +63,7 @@ impl SpecExtend for VecDeque where I: TrustedLen, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { default fn spec_extend(&mut self, iter: I) { // This is the case for a TrustedLen iterator. @@ -99,7 +99,7 @@ where impl SpecExtend> for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { fn spec_extend(&mut self, mut iterator: vec::IntoIter) { let slice = iterator.as_slice(); @@ -118,7 +118,7 @@ impl<'a, T: 'a, I, A: Allocator, const COOP_PREFERRED: bool> SpecExtend<&'a T, I where I: Iterator, T: Copy, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { default fn spec_extend(&mut self, iterator: I) { self.spec_extend(iterator.copied()) @@ -129,7 +129,7 @@ impl<'a, T: 'a, A: Allocator, const COOP_PREFERRED: bool> SpecExtend<&'a T, slic for VecDeque where T: Copy, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(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 85dd756337350..086a1fa74566c 100644 --- a/library/alloc/src/collections/vec_deque/spec_from_iter.rs +++ b/library/alloc/src/collections/vec_deque/spec_from_iter.rs @@ -11,7 +11,7 @@ impl SpecFromIter for VecDeque where I: Iterator, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { default fn spec_from_iter(iterator: I) -> Self { // Since converting is O(1) now, just re-use the `Vec` logic for @@ -25,7 +25,7 @@ where impl SpecFromIter> for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { #[inline] fn spec_from_iter(iterator: crate::vec::IntoIter) -> Self { @@ -36,7 +36,7 @@ where impl SpecFromIter> for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { #[inline] fn spec_from_iter(iterator: IntoIter) -> Self { From dab8ad418ebdf51cac2eb679eb636a7e22019763 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 07:42:04 -0800 Subject: [PATCH 29/80] CoAlloc: Minor VecDeque. ICE --- library/alloc/src/collections/vec_deque/mod.rs | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/library/alloc/src/collections/vec_deque/mod.rs b/library/alloc/src/collections/vec_deque/mod.rs index 9107526f23cf5..95ca394c67fb9 100644 --- a/library/alloc/src/collections/vec_deque/mod.rs +++ b/library/alloc/src/collections/vec_deque/mod.rs @@ -158,10 +158,13 @@ where } #[stable(feature = "rust1", since = "1.0.0")] -impl Default for VecDeque { +impl Default for VecDeque +where + [(); crate::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:, +{ /// Creates an empty deque. #[inline] - fn default() -> VecDeque { + fn default() -> VecDeque { VecDeque::new() } } @@ -2978,10 +2981,10 @@ where } #[stable(feature = "std_collections_from_array", since = "1.56.0")] -impl From<[T; N]> - for VecDeque +impl From<[T; N]> + for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); crate::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:, { /// Converts a `[T; N]` into a `VecDeque`. /// From 621d05cd4ba223e7f40a8e93d916a542edd8e269 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 07:42:40 -0800 Subject: [PATCH 30/80] CoAlloc: Vec: Tidy. ICE --- library/alloc/src/vec/mod.rs | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs index 3692169f7ae6e..b92d2da5a6693 100644 --- a/library/alloc/src/vec/mod.rs +++ b/library/alloc/src/vec/mod.rs @@ -439,7 +439,10 @@ pub type WeVec = Vec 127 }>; // Inherent methods //////////////////////////////////////////////////////////////////////////////// -impl Vec { +impl Vec +where + [(); crate::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:, +{ /// Constructs a new, empty `Vec`. /// /// The vector will not allocate until elements are pushed onto it. @@ -3216,11 +3219,14 @@ where #[stable(feature = "rust1", since = "1.0.0")] #[rustc_const_unstable(feature = "const_default_impls", issue = "87864")] -impl const Default for Vec { +impl const Default for Vec +where + [(); crate::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:, +{ /// Creates an empty `Vec`. /// /// The vector will not allocate until elements are pushed onto it. - fn default() -> Vec { + fn default() -> Vec { Vec::new() } } From c5fcbb0a87549e31a81a8a0bc200f4a539b18235 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 07:45:22 -0800 Subject: [PATCH 31/80] CoAlloc: Vec: Working around ICE rust-lang/rust issue #106473 ICE. WIP --- library/alloc/src/vec/in_place_collect.rs | 2 +- library/alloc/src/vec/mod.rs | 12 ++++++------ library/alloc/src/vec/spec_from_iter.rs | 4 ++-- library/alloc/src/vec/spec_from_iter_nested.rs | 4 ++-- library/proc_macro/src/bridge/mod.rs | 4 ++-- library/proc_macro/src/bridge/rpc.rs | 4 ++-- library/proc_macro/src/diagnostic.rs | 2 +- 7 files changed, 16 insertions(+), 16 deletions(-) diff --git a/library/alloc/src/vec/in_place_collect.rs b/library/alloc/src/vec/in_place_collect.rs index 87d61deb1eb2f..cdaf3c43e824d 100644 --- a/library/alloc/src/vec/in_place_collect.rs +++ b/library/alloc/src/vec/in_place_collect.rs @@ -150,7 +150,7 @@ pub(super) trait InPlaceIterableMarker {} impl InPlaceIterableMarker for T where T: InPlaceIterable {} -impl SpecFromIter for Vec +impl SpecFromIter for Vec where I: Iterator + SourceIter + InPlaceIterableMarker, { diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs index b92d2da5a6693..74784a09e4edb 100644 --- a/library/alloc/src/vec/mod.rs +++ b/library/alloc/src/vec/mod.rs @@ -2868,7 +2868,7 @@ where #[cfg(not(no_global_oom_handling))] #[stable(feature = "rust1", since = "1.0.0")] -impl FromIterator for Vec { +impl FromIterator for Vec { #[inline] fn from_iter>(iter: I) -> Vec { >::from_iter(iter.into_iter()) @@ -3286,7 +3286,7 @@ where #[cfg(not(no_global_oom_handling))] #[stable(feature = "rust1", since = "1.0.0")] -impl From<&[T]> for Vec { +impl From<&[T]> for Vec { /// Allocate a `Vec` and fill it by cloning `s`'s items. /// /// # Examples @@ -3306,7 +3306,7 @@ impl From<&[T]> for Vec { #[cfg(not(no_global_oom_handling))] #[stable(feature = "vec_from_mut", since = "1.19.0")] -impl From<&mut [T]> for Vec { +impl From<&mut [T]> for Vec { /// Allocate a `Vec` and fill it by cloning `s`'s items. /// /// # Examples @@ -3326,7 +3326,7 @@ impl From<&mut [T]> for Vec { #[cfg(not(no_global_oom_handling))] #[stable(feature = "vec_from_array", since = "1.44.0")] -impl From<[T; N]> for Vec { +impl From<[T; N]> for Vec { /// Allocate a `Vec` and move `s`'s items into it. /// /// # Examples @@ -3349,7 +3349,7 @@ impl From<[T; N]> for Vec { } #[stable(feature = "vec_from_cow_slice", since = "1.14.0")] -impl<'a, T> From> for Vec +impl<'a, T> From> for Vec where [T]: ToOwned>, { @@ -3426,7 +3426,7 @@ where #[cfg(not(no_global_oom_handling))] #[stable(feature = "rust1", since = "1.0.0")] -impl From<&str> for Vec { +impl From<&str> for Vec { /// Allocate a `Vec` and fill it with a UTF-8 string. /// /// # Examples diff --git a/library/alloc/src/vec/spec_from_iter.rs b/library/alloc/src/vec/spec_from_iter.rs index efa6868473e49..7db120f1ff6c2 100644 --- a/library/alloc/src/vec/spec_from_iter.rs +++ b/library/alloc/src/vec/spec_from_iter.rs @@ -25,7 +25,7 @@ pub(super) trait SpecFromIter { fn from_iter(iter: I) -> Self; } -impl SpecFromIter for Vec +impl SpecFromIter for Vec where I: Iterator, { @@ -34,7 +34,7 @@ where } } -impl SpecFromIter> for Vec { +impl SpecFromIter> for Vec { fn from_iter(iterator: IntoIter) -> 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 diff --git a/library/alloc/src/vec/spec_from_iter_nested.rs b/library/alloc/src/vec/spec_from_iter_nested.rs index f915ebb86e5a5..9453f2dcd9828 100644 --- a/library/alloc/src/vec/spec_from_iter_nested.rs +++ b/library/alloc/src/vec/spec_from_iter_nested.rs @@ -13,7 +13,7 @@ pub(super) trait SpecFromIterNested { fn from_iter(iter: I) -> Self; } -impl SpecFromIterNested for Vec +impl SpecFromIterNested for Vec where I: Iterator, { @@ -45,7 +45,7 @@ where } } -impl SpecFromIterNested for Vec +impl SpecFromIterNested for Vec where I: TrustedLen, { 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 { } } -impl Mark for Vec { +impl Mark for Vec { type Unmarked = Vec; 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 Unmark for Vec { +impl Unmark for Vec { type Unmarked = Vec; 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 DecodeMut<'_, '_, S> for String { } } -impl> Encode for Vec { +impl> Encode for Vec { fn encode(self, w: &mut Writer, s: &mut S) { self.len().encode(w, s); for x in self { @@ -234,7 +234,7 @@ impl> Encode for Vec { } } -impl<'a, S, T: for<'s> DecodeMut<'a, 's, S>> DecodeMut<'a, '_, S> for Vec { +impl<'a, S, T: for<'s> DecodeMut<'a, 's, S>> DecodeMut<'a, '_, S> for Vec { 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 { +impl MultiSpan for Vec { fn into_spans(self) -> Vec { self } From 9db032e5fe06bed5bd0f592ddbd86c353979f15d Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 07:46:38 -0800 Subject: [PATCH 32/80] CoAlloc: Vec (NOT String): Working around ICE rust-lang/rust issue #106473 ICE. WIP --- library/alloc/src/ffi/c_str.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/alloc/src/ffi/c_str.rs b/library/alloc/src/ffi/c_str.rs index 11bd4c4dc1ba8..5948995f90c13 100644 --- a/library/alloc/src/ffi/c_str.rs +++ b/library/alloc/src/ffi/c_str.rs @@ -723,7 +723,7 @@ impl fmt::Debug for CString { } #[stable(feature = "cstring_into", since = "1.7.0")] -impl From for Vec { +impl From for Vec { /// Converts a [`CString`] into a [Vec]<[u8]>. /// /// The conversion consumes the [`CString`], and removes the terminating NUL byte. From ee19ed9bd7a4a90a7d0fd3cf0d421d3bd144315a Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 07:46:57 -0800 Subject: [PATCH 33/80] CoAlloc: BinaryHeap: Working around ICE rust-lang/rust issue #106473 ICE. WIP --- library/alloc/src/collections/binary_heap/mod.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/alloc/src/collections/binary_heap/mod.rs b/library/alloc/src/collections/binary_heap/mod.rs index f1b0cc4a72424..0a4a52e25c48f 100644 --- a/library/alloc/src/collections/binary_heap/mod.rs +++ b/library/alloc/src/collections/binary_heap/mod.rs @@ -1652,7 +1652,7 @@ impl From<[T; N]> for BinaryHeap { } #[stable(feature = "binary_heap_extras_15", since = "1.5.0")] -impl From> for Vec { +impl From> for Vec { /// Converts a `BinaryHeap` into a `Vec`. /// /// This conversion requires no data movement or allocation, and has From cae1a828108d155dcc45c7358f6db783371f878b Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 07:50:52 -0800 Subject: [PATCH 34/80] CoAlloc: Vec + related + FFI (NOT String-related): Macros instead of const for global COOP defaults (working around ICE). --- library/alloc/src/boxed.rs | 7 ++-- library/alloc/src/ffi/c_str.rs | 5 ++- library/alloc/src/lib.rs | 1 + library/alloc/src/raw_vec.rs | 5 +-- library/alloc/src/vec/drain.rs | 3 +- library/alloc/src/vec/in_place_collect.rs | 6 +++- library/alloc/src/vec/into_iter.rs | 3 +- library/alloc/src/vec/mod.rs | 36 ++++++++++++------- library/alloc/src/vec/spec_from_iter.rs | 8 +++-- .../alloc/src/vec/spec_from_iter_nested.rs | 8 +++-- library/core/src/alloc/mod.rs | 6 +++- 11 files changed, 62 insertions(+), 26 deletions(-) diff --git a/library/alloc/src/boxed.rs b/library/alloc/src/boxed.rs index 615744a2d60a3..86e9c96c5f42f 100644 --- a/library/alloc/src/boxed.rs +++ b/library/alloc/src/boxed.rs @@ -146,7 +146,6 @@ #![stable(feature = "rust1", since = "1.0.0")] -use core::alloc; use core::any::Any; use core::async_iter::AsyncIterator; use core::borrow; @@ -776,9 +775,10 @@ where #[unstable(feature = "allocator_api", issue = "32838")] // #[unstable(feature = "new_uninit", issue = "63291")] #[must_use] + #[allow(unused_braces)] pub fn new_uninit_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit], A> { unsafe { - RawVec::::with_capacity_in(len, alloc) + RawVec::::with_capacity_in(len, alloc) .into_box(len) } } @@ -807,9 +807,10 @@ where #[unstable(feature = "allocator_api", issue = "32838")] // #[unstable(feature = "new_uninit", issue = "63291")] #[must_use] + #[allow(unused_braces)] pub fn new_zeroed_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit], A> { unsafe { - RawVec::::with_capacity_zeroed_in( + RawVec::::with_capacity_zeroed_in( len, alloc, ) .into_box(len) diff --git a/library/alloc/src/ffi/c_str.rs b/library/alloc/src/ffi/c_str.rs index 5948995f90c13..dd2e6baab2776 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::Global; +use crate::DEFAULT_COOP_PREFERRED; #[cfg(target_has_atomic = "ptr")] use crate::sync::Arc; @@ -723,7 +725,8 @@ impl fmt::Debug for CString { } #[stable(feature = "cstring_into", since = "1.7.0")] -impl From for Vec { +#[allow(unused_braces)] +impl From for Vec { /// Converts a [`CString`] into a [Vec]<[u8]>. /// /// The conversion consumes the [`CString`], and removes the terminating NUL byte. diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs index 9400be19d6130..026e23e19b34a 100644 --- a/library/alloc/src/lib.rs +++ b/library/alloc/src/lib.rs @@ -185,6 +185,7 @@ #![feature(global_co_alloc_short_term_pref)] #![feature(hashmap_internals)] #![feature(lang_items)] +#![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::()` can be evaluated` // - cannot specialize on predicate `[(); _] well-formed` diff --git a/library/alloc/src/raw_vec.rs b/library/alloc/src/raw_vec.rs index f74e876b6cb9c..6a861b80c78f4 100644 --- a/library/alloc/src/raw_vec.rs +++ b/library/alloc/src/raw_vec.rs @@ -14,7 +14,7 @@ use crate::alloc::{Allocator, Global, Layout}; use crate::boxed::Box; use crate::collections::TryReserveError; use crate::collections::TryReserveErrorKind::*; -use crate::vec::DEFAULT_COOP_PREFERRED; +use crate::DEFAULT_COOP_PREFERRED; #[cfg(test)] mod tests; @@ -50,10 +50,11 @@ 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)] +#[allow(unused_braces)] pub(crate) struct RawVec< T, A: Allocator = Global, - const COOP_PREFERRED: bool = DEFAULT_COOP_PREFERRED, + const COOP_PREFERRED: bool = {DEFAULT_COOP_PREFERRED!()}, > where [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { diff --git a/library/alloc/src/vec/drain.rs b/library/alloc/src/vec/drain.rs index 2159edc7b1a23..72153029287bd 100644 --- a/library/alloc/src/vec/drain.rs +++ b/library/alloc/src/vec/drain.rs @@ -19,11 +19,12 @@ 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 = { alloc::SHORT_TERM_VEC_PREFERS_COOP }, + const COOP_PREFERRED: bool = { SHORT_TERM_VEC_PREFERS_COOP!() }, > where [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { diff --git a/library/alloc/src/vec/in_place_collect.rs b/library/alloc/src/vec/in_place_collect.rs index cdaf3c43e824d..6f3c44a8aa8b6 100644 --- a/library/alloc/src/vec/in_place_collect.rs +++ b/library/alloc/src/vec/in_place_collect.rs @@ -141,6 +141,9 @@ use core::iter::{InPlaceIterable, SourceIter, TrustedRandomAccessNoCoerce}; use core::mem::{self, ManuallyDrop, SizedTypeProperties}; use core::ptr::{self}; +use crate::Global; +use crate::DEFAULT_COOP_PREFERRED; + use super::{InPlaceDrop, InPlaceDstBufDrop, SpecFromIter, SpecFromIterNested, Vec}; /// Specialization marker for collecting an iterator pipeline into a Vec while reusing the @@ -150,7 +153,8 @@ pub(super) trait InPlaceIterableMarker {} impl InPlaceIterableMarker for T where T: InPlaceIterable {} -impl SpecFromIter for Vec +#[allow(unused_braces)] +impl SpecFromIter for Vec where I: Iterator + SourceIter + InPlaceIterableMarker, { diff --git a/library/alloc/src/vec/into_iter.rs b/library/alloc/src/vec/into_iter.rs index 98b7a7cda6731..7ca48fba02f06 100644 --- a/library/alloc/src/vec/into_iter.rs +++ b/library/alloc/src/vec/into_iter.rs @@ -28,10 +28,11 @@ use core::{alloc, array, fmt}; /// ``` #[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 = { alloc::SHORT_TERM_VEC_PREFERS_COOP }, + const COOP_PREFERRED: bool = { SHORT_TERM_VEC_PREFERS_COOP!() }, > where [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs index 74784a09e4edb..161adb40fdda5 100644 --- a/library/alloc/src/vec/mod.rs +++ b/library/alloc/src/vec/mod.rs @@ -148,6 +148,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`, short for 'vector'. /// /// # Examples @@ -397,11 +405,12 @@ mod spec_extend; #[stable(feature = "rust1", since = "1.0.0")] #[cfg_attr(not(test), rustc_diagnostic_item = "Vec")] #[rustc_insignificant_dtor] +#[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, + const COOP_PREFERRED: bool = {DEFAULT_COOP_PREFERRED!()}, > where [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { @@ -409,10 +418,6 @@ pub struct Vec< len: usize, } -/// 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; - #[unstable(feature = "global_co_alloc_covec", issue = "none")] pub type CoVec = Vec; @@ -426,8 +431,9 @@ pub type PlVec = - Vec; + Vec; /// "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). @@ -2868,7 +2874,8 @@ where #[cfg(not(no_global_oom_handling))] #[stable(feature = "rust1", since = "1.0.0")] -impl FromIterator for Vec { +#[allow(unused_braces)] +impl FromIterator for Vec { #[inline] fn from_iter>(iter: I) -> Vec { >::from_iter(iter.into_iter()) @@ -3286,7 +3293,8 @@ where #[cfg(not(no_global_oom_handling))] #[stable(feature = "rust1", since = "1.0.0")] -impl From<&[T]> for Vec { +#[allow(unused_braces)] +impl From<&[T]> for Vec { /// Allocate a `Vec` and fill it by cloning `s`'s items. /// /// # Examples @@ -3306,7 +3314,8 @@ impl From<&[T]> for Vec { #[cfg(not(no_global_oom_handling))] #[stable(feature = "vec_from_mut", since = "1.19.0")] -impl From<&mut [T]> for Vec { +#[allow(unused_braces)] +impl From<&mut [T]> for Vec { /// Allocate a `Vec` and fill it by cloning `s`'s items. /// /// # Examples @@ -3326,7 +3335,8 @@ impl From<&mut [T]> for Vec { #[cfg(not(no_global_oom_handling))] #[stable(feature = "vec_from_array", since = "1.44.0")] -impl From<[T; N]> for Vec { +#[allow(unused_braces)] +impl From<[T; N]> for Vec { /// Allocate a `Vec` and move `s`'s items into it. /// /// # Examples @@ -3349,7 +3359,8 @@ impl From<[T; N]> for Vec } #[stable(feature = "vec_from_cow_slice", since = "1.14.0")] -impl<'a, T> From> for Vec +#[allow(unused_braces)] +impl<'a, T> From> for Vec where [T]: ToOwned>, { @@ -3426,7 +3437,8 @@ where #[cfg(not(no_global_oom_handling))] #[stable(feature = "rust1", since = "1.0.0")] -impl From<&str> for Vec { +#[allow(unused_braces)] +impl From<&str> for Vec { /// Allocate a `Vec` and fill it with a UTF-8 string. /// /// # Examples diff --git a/library/alloc/src/vec/spec_from_iter.rs b/library/alloc/src/vec/spec_from_iter.rs index 7db120f1ff6c2..06da451fe3932 100644 --- a/library/alloc/src/vec/spec_from_iter.rs +++ b/library/alloc/src/vec/spec_from_iter.rs @@ -1,5 +1,7 @@ use core::mem::ManuallyDrop; use core::ptr::{self}; +use crate::Global; +use crate::DEFAULT_COOP_PREFERRED; use super::{IntoIter, SpecExtend, SpecFromIterNested, Vec}; @@ -25,7 +27,8 @@ pub(super) trait SpecFromIter { fn from_iter(iter: I) -> Self; } -impl SpecFromIter for Vec +#[allow(unused_braces)] +impl SpecFromIter for Vec where I: Iterator, { @@ -34,7 +37,8 @@ where } } -impl SpecFromIter> for Vec { +#[allow(unused_braces)] +impl SpecFromIter> for Vec { fn from_iter(iterator: IntoIter) -> 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 diff --git a/library/alloc/src/vec/spec_from_iter_nested.rs b/library/alloc/src/vec/spec_from_iter_nested.rs index 9453f2dcd9828..7408155ff870a 100644 --- a/library/alloc/src/vec/spec_from_iter_nested.rs +++ b/library/alloc/src/vec/spec_from_iter_nested.rs @@ -3,6 +3,8 @@ use core::iter::TrustedLen; use core::ptr; use crate::raw_vec::RawVec; +use crate::Global; +use crate::DEFAULT_COOP_PREFERRED; use super::{SpecExtend, Vec}; @@ -13,7 +15,8 @@ pub(super) trait SpecFromIterNested { fn from_iter(iter: I) -> Self; } -impl SpecFromIterNested for Vec +#[allow(unused_braces)] +impl SpecFromIterNested for Vec where I: Iterator, { @@ -45,7 +48,8 @@ where } } -impl SpecFromIterNested for Vec +#[allow(unused_braces)] +impl SpecFromIterNested for Vec where I: TrustedLen, { diff --git a/library/core/src/alloc/mod.rs b/library/core/src/alloc/mod.rs index eb7edf1600ef7..bcdc8292ff8c1 100644 --- a/library/core/src/alloc/mod.rs +++ b/library/core/src/alloc/mod.rs @@ -81,7 +81,11 @@ pub struct SliceAndMeta { } #[unstable(feature = "global_co_alloc_short_term_pref", issue = "none")] -pub const SHORT_TERM_VEC_PREFERS_COOP: bool = true; +//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)] From 6d5e8659086bc331f239f965f5e6088fd7e20702 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 07:51:52 -0800 Subject: [PATCH 35/80] CoAlloc: VecDeque: Macros instead of const for global COOP defaults (working around ICE). --- library/alloc/src/collections/vec_deque/drain.rs | 3 ++- library/alloc/src/collections/vec_deque/mod.rs | 5 +++-- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/library/alloc/src/collections/vec_deque/drain.rs b/library/alloc/src/collections/vec_deque/drain.rs index 2004060c4bb96..1bfeaf5a5d3fc 100644 --- a/library/alloc/src/collections/vec_deque/drain.rs +++ b/library/alloc/src/collections/vec_deque/drain.rs @@ -15,11 +15,12 @@ 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 = { alloc::SHORT_TERM_VEC_PREFERS_COOP }, + const COOP_PREFERRED: bool = { SHORT_TERM_VEC_PREFERS_COOP!() }, > where [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { diff --git a/library/alloc/src/collections/vec_deque/mod.rs b/library/alloc/src/collections/vec_deque/mod.rs index 95ca394c67fb9..93ae1f7d1b6ce 100644 --- a/library/alloc/src/collections/vec_deque/mod.rs +++ b/library/alloc/src/collections/vec_deque/mod.rs @@ -7,7 +7,7 @@ #![feature(global_co_alloc)] #![stable(feature = "rust1", since = "1.0.0")] -use crate::vec::DEFAULT_COOP_PREFERRED; +use crate::DEFAULT_COOP_PREFERRED; use core::alloc; use core::cmp::{self, Ordering}; use core::fmt; @@ -93,10 +93,11 @@ 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, + const COOP_PREFERRED: bool = {DEFAULT_COOP_PREFERRED!()}, > where [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { From 061fe5d8c069296dba1618c75bcc75e26cf1d213 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 07:52:07 -0800 Subject: [PATCH 36/80] CoAlloc: BinaryHeap: Macros instead of const for global COOP defaults (working around ICE). --- library/alloc/src/collections/binary_heap/mod.rs | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/library/alloc/src/collections/binary_heap/mod.rs b/library/alloc/src/collections/binary_heap/mod.rs index 0a4a52e25c48f..bc08a604b8cd0 100644 --- a/library/alloc/src/collections/binary_heap/mod.rs +++ b/library/alloc/src/collections/binary_heap/mod.rs @@ -148,13 +148,14 @@ use core::mem::{self, swap, ManuallyDrop}; use core::num::NonZeroUsize; use core::ops::{Deref, DerefMut}; use core::ptr; -use core::{alloc, fmt}; +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; @@ -1243,7 +1244,8 @@ impl BinaryHeap { /// ``` #[inline] #[stable(feature = "drain", since = "1.6.0")] - pub fn drain(&mut self) -> Drain<'_, T, { alloc::SHORT_TERM_VEC_PREFERS_COOP }> { + #[allow(unused_braces)] + pub fn drain(&mut self) -> Drain<'_, T, { SHORT_TERM_VEC_PREFERS_COOP!() }> { Drain { iter: self.data.drain(..) } } @@ -1652,7 +1654,8 @@ impl From<[T; N]> for BinaryHeap { } #[stable(feature = "binary_heap_extras_15", since = "1.5.0")] -impl From> for Vec { +#[allow(unused_braces)] +impl From> for Vec { /// Converts a `BinaryHeap` into a `Vec`. /// /// This conversion requires no data movement or allocation, and has From 20ade76fd724343d159c8c82eb4b2ae4a468f5c6 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 07:53:22 -0800 Subject: [PATCH 37/80] CoAlloc: TODO replace co_alloc_metadata_num_slots_with_preference_global(...) --- library/alloc/src/lib.rs | 3 ++- library/alloc/src/raw_vec.rs | 2 +- library/core/src/alloc/mod.rs | 5 +++-- 3 files changed, 6 insertions(+), 4 deletions(-) diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs index 026e23e19b34a..a775d995500ee 100644 --- a/library/alloc/src/lib.rs +++ b/library/alloc/src/lib.rs @@ -291,5 +291,6 @@ use crate::alloc::Global; /// See also `core::alloc::co_alloc_metadata_num_slots_with_preference`. #[unstable(feature = "global_co_alloc", issue = "none")] pub const fn co_alloc_metadata_num_slots_with_preference_global(coop_preferred: bool) -> usize { - if Global::IS_CO_ALLOCATOR && coop_preferred { 1 } else { 0 } + // FIXME or replace any calls with core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED). Then rename co_alloc_metadata_num_slots_with_preference_specific to co_alloc_metadata_num_slots_with_preference. See raw_vec.rs. + if /*Global::IS_CO_ALLOCATOR*/ true && coop_preferred { 1 } else { 0 } } diff --git a/library/alloc/src/raw_vec.rs b/library/alloc/src/raw_vec.rs index 6a861b80c78f4..c431b87ee4538 100644 --- a/library/alloc/src/raw_vec.rs +++ b/library/alloc/src/raw_vec.rs @@ -70,7 +70,7 @@ pub(crate) struct RawVec< impl RawVec where - [(); crate::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, { /// HACK(Centril): This exists because stable `const fn` can only call stable `const fn`, so /// they cannot call `Self::new()`. diff --git a/library/core/src/alloc/mod.rs b/library/core/src/alloc/mod.rs index bcdc8292ff8c1..0599b79a99417 100644 --- a/library/core/src/alloc/mod.rs +++ b/library/core/src/alloc/mod.rs @@ -93,8 +93,9 @@ pub type SliceAndMetaResult = Result; #[unstable(feature = "global_co_alloc", issue = "none")] pub const fn co_alloc_metadata_num_slots() -> usize { - if true { - panic!("FIXME - consider removing co_alloc_metadata_num_slots()"); + // @FIXME later + if false { + panic!("FIXME - consider replacing co_alloc_metadata_num_slots() with co_alloc_metadata_num_slots_with_preference_specific(bool), and adding const flags as appropriate."); } if A::IS_CO_ALLOCATOR { 1 } else { 0 } } From e516e620eddeed23ab450c619cec5b0a450e746a Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 20:54:42 -0800 Subject: [PATCH 38/80] CoAlloc: Vec + core: Renamed co_alloc_metadata_num_slots_with_preference_specific(...) to co_alloc_metadata_num_slots_with_preference(...) --- library/alloc/src/raw_vec.rs | 20 +++---- library/alloc/src/slice.rs | 22 +++---- library/alloc/src/vec/drain.rs | 28 ++++----- library/alloc/src/vec/drain_filter.rs | 12 ++-- library/alloc/src/vec/into_iter.rs | 36 +++++------ library/alloc/src/vec/mod.rs | 80 ++++++++++++------------- library/alloc/src/vec/partial_eq.rs | 20 +++---- library/alloc/src/vec/spec_extend.rs | 10 ++-- library/alloc/src/vec/spec_from_elem.rs | 8 +-- library/core/src/alloc/mod.rs | 2 +- library/std/src/io/cursor.rs | 12 ++-- 11 files changed, 125 insertions(+), 125 deletions(-) diff --git a/library/alloc/src/raw_vec.rs b/library/alloc/src/raw_vec.rs index c431b87ee4538..cb0cb4216a5a9 100644 --- a/library/alloc/src/raw_vec.rs +++ b/library/alloc/src/raw_vec.rs @@ -56,7 +56,7 @@ pub(crate) struct RawVec< A: Allocator = Global, const COOP_PREFERRED: bool = {DEFAULT_COOP_PREFERRED!()}, > where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { ptr: Unique, cap: usize, @@ -65,12 +65,12 @@ pub(crate) struct RawVec< //pub(crate) meta: [GlobalCoAllocMeta; {if core::any::TypeId::of::()==core::any::TypeId::of::() {1} else {0}}], //pub(crate) meta: [GlobalCoAllocMeta; mem::size_of::()], pub(crate) metas: [GlobalCoAllocMeta; - alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)], + alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)], } impl RawVec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { /// HACK(Centril): This exists because stable `const fn` can only call stable `const fn`, so /// they cannot call `Self::new()`. @@ -120,7 +120,7 @@ where impl RawVec where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { // Tiny Vecs are dumb. Skip to: // - 8 if the element size is 1, because any heap allocators is likely @@ -144,7 +144,7 @@ where cap: 0, alloc, metas: [GlobalCoAllocMeta {/*one: 1*/ /* , two: 2, three: 3, four: 4*/}; - alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)], + alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)], } } @@ -223,7 +223,7 @@ where cap: capacity, alloc, metas: [GlobalCoAllocMeta {/*one: 1*/ /*, two: 2, three: 3, four: 4*/}; - alloc::co_alloc_metadata_num_slots_with_preference_specific::( + alloc::co_alloc_metadata_num_slots_with_preference::( COOP_PREFERRED, )], } @@ -247,7 +247,7 @@ where cap: capacity, alloc, metas: [GlobalCoAllocMeta {/*one: 1*/ /*, two: 2, three: 3, four: 4*/}; - alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)], + alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)], } } @@ -317,7 +317,7 @@ where len: usize, additional: usize, ) where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { handle_reserve(slf.grow_amortized(len, additional)); } @@ -393,7 +393,7 @@ where impl RawVec where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(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`. @@ -515,7 +515,7 @@ where unsafe impl<#[may_dangle] T, A: Allocator, const COOP_PREFERRED: bool> Drop for RawVec where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { /// Frees the memory owned by the `RawVec` *without* trying to drop its contents. default fn drop(&mut self) { diff --git a/library/alloc/src/slice.rs b/library/alloc/src/slice.rs index e621f900c6036..538fc9b67fe4a 100644 --- a/library/alloc/src/slice.rs +++ b/library/alloc/src/slice.rs @@ -101,7 +101,7 @@ pub(crate) mod hack { b: Box<[T], A>, ) -> Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::( + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::( COOP_PREFERRED, )]:, { @@ -119,7 +119,7 @@ pub(crate) mod hack { alloc: A, ) -> Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::( + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::( COOP_PREFERRED, )]:, { @@ -134,7 +134,7 @@ pub(crate) mod hack { ) -> Vec where Self: Sized, - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::( + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::( COOP_PREFERRED, )]:; } @@ -147,13 +147,13 @@ pub(crate) mod hack { alloc: A, ) -> Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::( + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::( COOP_PREFERRED, )]:, { struct DropGuard<'a, T, A: Allocator, const COOP_PREFERRED: bool> where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::( + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::( COOP_PREFERRED, )]:, { @@ -162,7 +162,7 @@ pub(crate) mod hack { } 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_specific::( + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::( COOP_PREFERRED, )]:, { @@ -202,7 +202,7 @@ pub(crate) mod hack { alloc: A, ) -> Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::( + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::( COOP_PREFERRED, )]:, { @@ -486,7 +486,7 @@ impl [T] { ) -> Vec where T: Clone, - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::( + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::( COOP_PREFERRED, )]:, { @@ -515,7 +515,7 @@ impl [T] { self: Box, ) -> Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::( + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::( COOP_PREFERRED, )]:, { @@ -834,7 +834,7 @@ impl> Join<&[T]> for [V] { #[stable(feature = "rust1", since = "1.0.0")] impl Borrow<[T]> for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn borrow(&self) -> &[T] { &self[..] @@ -844,7 +844,7 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl BorrowMut<[T]> for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn borrow_mut(&mut self) -> &mut [T] { &mut self[..] diff --git a/library/alloc/src/vec/drain.rs b/library/alloc/src/vec/drain.rs index 72153029287bd..05fee754beec8 100644 --- a/library/alloc/src/vec/drain.rs +++ b/library/alloc/src/vec/drain.rs @@ -26,7 +26,7 @@ pub struct Drain< #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator + 'a = Global, const COOP_PREFERRED: bool = { SHORT_TERM_VEC_PREFERS_COOP!() }, > where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { /// Index of tail to preserve pub(super) tail_start: usize, @@ -41,7 +41,7 @@ pub struct Drain< impl fmt::Debug for Drain<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_tuple("Drain").field(&self.iter.as_slice()).finish() @@ -50,7 +50,7 @@ where impl<'a, T, A: Allocator, const COOP_PREFERRED: bool> Drain<'a, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { /// Returns the remaining items of this iterator as a slice. /// @@ -152,7 +152,7 @@ where #[stable(feature = "vec_drain_as_slice", since = "1.46.0")] 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_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn as_ref(&self) -> &[T] { self.as_slice() @@ -163,21 +163,21 @@ where unsafe impl Sync for Drain<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { } #[stable(feature = "drain", since = "1.6.0")] unsafe impl Send for Drain<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { } #[stable(feature = "drain", since = "1.6.0")] impl Iterator for Drain<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { type Item = T; @@ -195,7 +195,7 @@ where impl DoubleEndedIterator for Drain<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { #[inline] fn next_back(&mut self) -> Option { @@ -206,7 +206,7 @@ where #[stable(feature = "drain", since = "1.6.0")] impl Drop for Drain<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn drop(&mut self) { /// Moves back the un-`Drain`ed elements to restore the original `Vec`. @@ -214,12 +214,12 @@ where &'r mut Drain<'a, T, A, COOP_PREFERRED>, ) where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:; + [(); alloc::co_alloc_metadata_num_slots_with_preference::(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_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn drop(&mut self) { if self.0.tail_len > 0 { @@ -287,7 +287,7 @@ where impl ExactSizeIterator for Drain<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn is_empty(&self) -> bool { self.iter.is_empty() @@ -298,12 +298,12 @@ where unsafe impl TrustedLen for Drain<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { } #[stable(feature = "fused", since = "1.26.0")] impl FusedIterator for Drain<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { } diff --git a/library/alloc/src/vec/drain_filter.rs b/library/alloc/src/vec/drain_filter.rs index 29cf29e2532d9..89baafca46729 100644 --- a/library/alloc/src/vec/drain_filter.rs +++ b/library/alloc/src/vec/drain_filter.rs @@ -27,7 +27,7 @@ pub struct DrainFilter< const COOP_PREFERRED: bool = true, > where F: FnMut(&mut T) -> bool, - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { pub(super) vec: &'a mut Vec, /// The index of the item that will be inspected by the next call to `next`. @@ -49,7 +49,7 @@ pub struct DrainFilter< impl DrainFilter<'_, T, F, A, COOP_PREFERRED> where F: FnMut(&mut T) -> bool, - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { /// Returns a reference to the underlying allocator. #[unstable(feature = "allocator_api", issue = "32838")] @@ -119,7 +119,7 @@ impl Iterator for DrainFilter<'_, T, F, A, COOP_PREFERRED> where F: FnMut(&mut T) -> bool, - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { type Item = T; @@ -159,13 +159,13 @@ impl Drop for DrainFilter<'_, T, F, A, COOP_PREFERRED> where F: FnMut(&mut T) -> bool, - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn drop(&mut self) { 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_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { drain: &'b mut DrainFilter<'a, T, F, A, COOP_PREFERRED>, } @@ -174,7 +174,7 @@ where for BackshiftOnDrop<'a, 'b, T, F, A, COOP_PREFERRED> where F: FnMut(&mut T) -> bool, - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn drop(&mut self) { unsafe { diff --git a/library/alloc/src/vec/into_iter.rs b/library/alloc/src/vec/into_iter.rs index 7ca48fba02f06..5afb11ee7ba24 100644 --- a/library/alloc/src/vec/into_iter.rs +++ b/library/alloc/src/vec/into_iter.rs @@ -34,7 +34,7 @@ pub struct IntoIter< #[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_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { pub(super) buf: NonNull, pub(super) phantom: PhantomData, @@ -52,7 +52,7 @@ pub struct IntoIter< impl fmt::Debug for IntoIter where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_tuple("IntoIter").field(&self.as_slice()).finish() @@ -61,7 +61,7 @@ where impl IntoIter where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { /// Returns the remaining items of this iterator as a slice. /// @@ -180,7 +180,7 @@ where #[stable(feature = "vec_intoiter_as_ref", since = "1.46.0")] impl AsRef<[T]> for IntoIter where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn as_ref(&self) -> &[T] { self.as_slice() @@ -191,21 +191,21 @@ where unsafe impl Send for IntoIter where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { } #[stable(feature = "rust1", since = "1.0.0")] unsafe impl Sync for IntoIter where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { } #[stable(feature = "rust1", since = "1.0.0")] impl Iterator for IntoIter where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { type Item = T; @@ -323,7 +323,7 @@ where impl DoubleEndedIterator for IntoIter where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { #[inline] fn next_back(&mut self) -> Option { @@ -368,7 +368,7 @@ where impl ExactSizeIterator for IntoIter where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn is_empty(&self) -> bool { self.ptr == self.end @@ -377,7 +377,7 @@ where #[stable(feature = "fused", since = "1.26.0")] impl FusedIterator for IntoIter where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { } @@ -385,7 +385,7 @@ impl FusedIterator for IntoIter TrustedLen for IntoIter where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { } @@ -407,7 +407,7 @@ unsafe impl TrustedRandomAccessNoCo for IntoIter where T: NonDrop, - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { const MAY_HAVE_SIDE_EFFECT: bool = false; } @@ -417,7 +417,7 @@ where impl Clone for IntoIter where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { #[cfg(not(test))] fn clone(&self) -> Self { @@ -433,18 +433,18 @@ where unsafe impl<#[may_dangle] T, A: Allocator, const COOP_PREFERRED: bool> Drop for IntoIter where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn drop(&mut self) { struct DropGuard<'a, T, A: Allocator, const COOP_PREFERRED: bool>( &'a mut IntoIter, ) where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:; + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:; impl Drop for DropGuard<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn drop(&mut self) { unsafe { @@ -476,7 +476,7 @@ where unsafe impl InPlaceIterable for IntoIter where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { } @@ -485,7 +485,7 @@ where unsafe impl SourceIter for IntoIter where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { type Source = Self; diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs index 161adb40fdda5..1116cc50e4275 100644 --- a/library/alloc/src/vec/mod.rs +++ b/library/alloc/src/vec/mod.rs @@ -412,7 +412,7 @@ pub struct Vec< //@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_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { buf: RawVec, len: usize, @@ -637,7 +637,7 @@ where impl Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { /// Constructs a new, empty `Vec`. /// @@ -1653,7 +1653,7 @@ where // In cases when predicate and `drop` never panick, it will be optimized out. struct BackshiftOnDrop<'a, T, A: Allocator, const VEC_IS_COOP: bool = true> where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::( + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::( VEC_IS_COOP, )]:, { @@ -1665,7 +1665,7 @@ where impl Drop for BackshiftOnDrop<'_, T, A, VEC_IS_COOP> where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::( + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::( VEC_IS_COOP, )]:, { @@ -1700,7 +1700,7 @@ where g: &mut BackshiftOnDrop<'_, T, A, VEC_IS_COOP>, ) where F: FnMut(&mut T) -> bool, - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::( + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::( VEC_IS_COOP, )]:, { @@ -1797,7 +1797,7 @@ where /* INVARIANT: vec.len() > read >= write > write-1 >= 0 */ struct FillGapOnDrop<'a, T, A: core::alloc::Allocator, const COOP_PREFERRED: bool> where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::( + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::( COOP_PREFERRED, )]:, { @@ -1815,7 +1815,7 @@ where 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_specific::( + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::( COOP_PREFERRED, )]:, { @@ -2413,7 +2413,7 @@ where impl Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { /// Resizes the `Vec` in-place so that `len` is equal to `new_len`. /// @@ -2515,7 +2515,7 @@ where impl Vec<[T; N], A, COOP_PREFERRED> where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { /// Takes a `Vec<[T; N]>` and flattens it into a `Vec`. /// @@ -2579,7 +2579,7 @@ impl ExtendWith for ExtendElement { impl Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { #[cfg(not(no_global_oom_handling))] /// Extend the vector by `n` values, using the given generator. @@ -2614,7 +2614,7 @@ where impl Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { /// Removes consecutive repeated elements in the vector according to the /// [`PartialEq`] trait implementation. @@ -2657,7 +2657,7 @@ pub fn from_elem_in( alloc: A, ) -> Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { ::from_elem(elem, n, alloc) } @@ -2673,7 +2673,7 @@ trait ExtendFromWithinSpec { impl ExtendFromWithinSpec for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { default unsafe fn spec_extend_from_within(&mut self, src: Range) { // SAFETY: @@ -2696,7 +2696,7 @@ where impl ExtendFromWithinSpec for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { unsafe fn spec_extend_from_within(&mut self, src: Range) { let count = src.len(); @@ -2732,7 +2732,7 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl ops::Deref for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { type Target = [T]; @@ -2745,7 +2745,7 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl ops::DerefMut for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { #[inline] fn deref_mut(&mut self) -> &mut [T] { @@ -2761,7 +2761,7 @@ trait SpecCloneFrom { #[cfg(not(no_global_oom_handling))] impl SpecCloneFrom for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { default fn clone_from(this: &mut Self, other: &Self) { // drop anything that will not be overwritten @@ -2780,7 +2780,7 @@ where #[cfg(not(no_global_oom_handling))] impl SpecCloneFrom for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn clone_from(this: &mut Self, other: &Self) { this.clear(); @@ -2792,7 +2792,7 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl Clone for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { #[cfg(not(test))] fn clone(&self) -> Self { @@ -2830,7 +2830,7 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl Hash for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { #[inline] fn hash(&self, state: &mut H) { @@ -2846,7 +2846,7 @@ where impl, A: Allocator, const COOP_PREFERRED: bool> Index for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { type Output = I::Output; @@ -2864,7 +2864,7 @@ where impl, A: Allocator, const COOP_PREFERRED: bool> IndexMut for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { #[inline] fn index_mut(&mut self, index: I) -> &mut Self::Output { @@ -2885,7 +2885,7 @@ impl FromIterator for Vec { #[stable(feature = "rust1", since = "1.0.0")] impl IntoIterator for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { type Item = T; type IntoIter = IntoIter; @@ -2933,7 +2933,7 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl<'a, T, A: Allocator, const COOP_PREFERRED: bool> IntoIterator for &'a Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { type Item = &'a T; type IntoIter = slice::Iter<'a, T>; @@ -2947,7 +2947,7 @@ where impl<'a, T, A: Allocator, const COOP_PREFERRED: bool> IntoIterator for &'a mut Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { type Item = &'a mut T; type IntoIter = slice::IterMut<'a, T>; @@ -2961,7 +2961,7 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl Extend for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { #[inline] fn extend>(&mut self, iter: I) { @@ -2981,7 +2981,7 @@ where impl Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { // leaf method to which various SpecFrom/SpecExtend implementations delegate when // they have no further optimizations to apply @@ -3159,7 +3159,7 @@ where impl<'a, T: Copy + 'a, A: Allocator + 'a, const COOP_PREFERRED: bool> Extend<&'a T> for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn extend>(&mut self, iter: I) { self.spec_extend(iter.into_iter()) @@ -3181,7 +3181,7 @@ where impl PartialOrd for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { #[inline] fn partial_cmp(&self, other: &Self) -> Option { @@ -3191,7 +3191,7 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl Eq for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]: + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { } @@ -3199,7 +3199,7 @@ impl Eq for Vec Ord for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { #[inline] fn cmp(&self, other: &Self) -> Ordering { @@ -3211,7 +3211,7 @@ where unsafe impl<#[may_dangle] T, A: Allocator, const COOP_PREFERRED: bool> Drop for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn drop(&mut self) { unsafe { @@ -3242,7 +3242,7 @@ where impl fmt::Debug for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { fmt::Debug::fmt(&**self, f) @@ -3253,7 +3253,7 @@ where impl AsRef> for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn as_ref(&self) -> &Vec { self @@ -3264,7 +3264,7 @@ where impl AsMut> for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn as_mut(&mut self) -> &mut Vec { self @@ -3274,7 +3274,7 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl AsRef<[T]> for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn as_ref(&self) -> &[T] { self @@ -3284,7 +3284,7 @@ where #[stable(feature = "vec_as_mut", since = "1.5.0")] impl AsMut<[T]> for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn as_mut(&mut self) -> &mut [T] { self @@ -3388,7 +3388,7 @@ where #[stable(feature = "vec_from_box", since = "1.18.0")] impl From> for Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { /// Convert a boxed slice into a vector by transferring ownership of /// the existing heap allocation. @@ -3410,7 +3410,7 @@ where #[stable(feature = "box_from_vec", since = "1.20.0")] impl From> for Box<[T], A> where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { /// Convert a vector into a boxed slice. /// @@ -3455,7 +3455,7 @@ impl From<&str> for Vec { impl TryFrom> for [T; N] where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { type Error = Vec; diff --git a/library/alloc/src/vec/partial_eq.rs b/library/alloc/src/vec/partial_eq.rs index 7b364e8d4bacd..bcf52b7333218 100644 --- a/library/alloc/src/vec/partial_eq.rs +++ b/library/alloc/src/vec/partial_eq.rs @@ -21,21 +21,21 @@ macro_rules! __impl_slice_eq1 { } } -__impl_slice_eq1! { [A1: Allocator, A2: Allocator, const COOP_PREFERRED1: bool, const COOP_PREFERRED2: bool] Vec, Vec, #[stable(feature = "rust1", since = "1.0.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED1)]:, [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED2)]: } -__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] Vec, &[U], #[stable(feature = "rust1", since = "1.0.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]: } -__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] Vec, &mut [U], #[stable(feature = "rust1", since = "1.0.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]: } -__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] &[T], Vec, #[stable(feature = "partialeq_vec_for_ref_slice", since = "1.46.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]: } -__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] &mut [T], Vec, #[stable(feature = "partialeq_vec_for_ref_slice", since = "1.46.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]: } -__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] Vec, [U], #[stable(feature = "partialeq_vec_for_slice", since = "1.48.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]: } -__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] [T], Vec, #[stable(feature = "partialeq_vec_for_slice", since = "1.48.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]: } +__impl_slice_eq1! { [A1: Allocator, A2: Allocator, const COOP_PREFERRED1: bool, const COOP_PREFERRED2: bool] Vec, Vec, #[stable(feature = "rust1", since = "1.0.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED1)]:, [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED2)]: } +__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] Vec, &[U], #[stable(feature = "rust1", since = "1.0.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: } +__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] Vec, &mut [U], #[stable(feature = "rust1", since = "1.0.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: } +__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] &[T], Vec, #[stable(feature = "partialeq_vec_for_ref_slice", since = "1.46.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: } +__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] &mut [T], Vec, #[stable(feature = "partialeq_vec_for_ref_slice", since = "1.46.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: } +__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] Vec, [U], #[stable(feature = "partialeq_vec_for_slice", since = "1.48.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: } +__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] [T], Vec, #[stable(feature = "partialeq_vec_for_slice", since = "1.48.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: } #[cfg(not(no_global_oom_handling))] -__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] Cow<'_, [T]>, Vec, #[stable(feature = "rust1", since = "1.0.0")], T: Clone, [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]: } +__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool] Cow<'_, [T]>, Vec, #[stable(feature = "rust1", since = "1.0.0")], T: Clone, [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: } #[cfg(not(no_global_oom_handling))] __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], #[stable(feature = "rust1", since = "1.0.0")], T: Clone } -__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool, const N: usize] Vec, [U; N], #[stable(feature = "rust1", since = "1.0.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]: } -__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool, const N: usize] Vec, &[U; N], #[stable(feature = "rust1", since = "1.0.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]: } +__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool, const N: usize] Vec, [U; N], #[stable(feature = "rust1", since = "1.0.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: } +__impl_slice_eq1! { [A: Allocator, const COOP_PREFERRED: bool, const N: usize] Vec, &[U; N], #[stable(feature = "rust1", since = "1.0.0")], [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(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 ea91491f62558..73cf325889290 100644 --- a/library/alloc/src/vec/spec_extend.rs +++ b/library/alloc/src/vec/spec_extend.rs @@ -13,7 +13,7 @@ pub(super) trait SpecExtend { impl SpecExtend for Vec where I: Iterator, - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { default fn spec_extend(&mut self, iter: I) { self.extend_desugared(iter) @@ -23,7 +23,7 @@ where impl SpecExtend for Vec where I: TrustedLen, - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { default fn spec_extend(&mut self, iterator: I) { self.extend_trusted(iterator) @@ -33,7 +33,7 @@ where impl SpecExtend> for Vec where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn spec_extend(&mut self, mut iterator: IntoIter) { unsafe { @@ -48,7 +48,7 @@ impl<'a, T: 'a, I, A: Allocator + 'a, const COOP_PREFERRED: bool> SpecExtend<&'a where I: Iterator, T: Clone, - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { default fn spec_extend(&mut self, iterator: I) { self.spec_extend(iterator.cloned()) @@ -59,7 +59,7 @@ impl<'a, T: 'a, A: Allocator + 'a, const COOP_PREFERRED: bool> SpecExtend<&'a T, for Vec where T: Copy, - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(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 4c29f6184c149..3766f6de061bb 100644 --- a/library/alloc/src/vec/spec_from_elem.rs +++ b/library/alloc/src/vec/spec_from_elem.rs @@ -24,7 +24,7 @@ impl SpecFromElem for T { alloc: A, ) -> Vec where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { let mut v = Vec::with_capacity_in(n, alloc); v.extend_with(n, ExtendElement(elem)); @@ -40,7 +40,7 @@ impl SpecFromElem for T { alloc: A, ) -> Vec where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { if elem.is_zero() { return Vec { buf: RawVec::with_capacity_zeroed_in(n, alloc), len: n }; @@ -59,7 +59,7 @@ impl SpecFromElem for i8 { alloc: A, ) -> Vec where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { if elem == 0 { return Vec { buf: RawVec::with_capacity_zeroed_in(n, alloc), len: n }; @@ -81,7 +81,7 @@ impl SpecFromElem for u8 { alloc: A, ) -> Vec where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { if elem == 0 { return Vec { buf: RawVec::with_capacity_zeroed_in(n, alloc), len: n }; diff --git a/library/core/src/alloc/mod.rs b/library/core/src/alloc/mod.rs index 0599b79a99417..7be3f9cd24b3b 100644 --- a/library/core/src/alloc/mod.rs +++ b/library/core/src/alloc/mod.rs @@ -103,7 +103,7 @@ pub const fn co_alloc_metadata_num_slots() -> usize { #[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_specific( +pub const fn co_alloc_metadata_num_slots_with_preference( coop_preferred: bool, ) -> usize { if A::IS_CO_ALLOCATOR && coop_preferred { 1 } else { 0 } diff --git a/library/std/src/io/cursor.rs b/library/std/src/io/cursor.rs index f8d2ca1d3e74c..63045ebcb8157 100644 --- a/library/std/src/io/cursor.rs +++ b/library/std/src/io/cursor.rs @@ -404,7 +404,7 @@ fn reserve_and_pad( buf_len: usize, ) -> io::Result where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { let pos: usize = (*pos_mut).try_into().map_err(|_| { io::const_io_error!( @@ -451,7 +451,7 @@ unsafe fn vec_write_unchecked( ) -> usize where A: Allocator, - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { debug_assert!(vec.capacity() >= pos + buf.len()); vec.as_mut_ptr().add(pos).copy_from(buf.as_ptr(), buf.len()); @@ -474,7 +474,7 @@ fn vec_write( ) -> io::Result where A: Allocator, - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { let buf_len = buf.len(); let mut pos = reserve_and_pad(pos_mut, vec, buf_len)?; @@ -510,7 +510,7 @@ fn vec_write_vectored( ) -> io::Result where A: Allocator, - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(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. @@ -561,7 +561,7 @@ impl Write for Cursor<&mut [u8]> { impl Write for Cursor<&mut Vec> where A: Allocator, - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn write(&mut self, buf: &[u8]) -> io::Result { vec_write(&mut self.pos, self.inner, buf) @@ -586,7 +586,7 @@ where impl Write for Cursor> where A: Allocator, - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn write(&mut self, buf: &[u8]) -> io::Result { vec_write(&mut self.pos, &mut self.inner, buf) From 9d9e75db4887e10e076e29d06163aa5487985d12 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 20:54:59 -0800 Subject: [PATCH 39/80] CoAlloc: VecDeque: Renamed co_alloc_metadata_num_slots_with_preference_specific(...) to co_alloc_metadata_num_slots_with_preference(...) --- .../alloc/src/collections/vec_deque/drain.rs | 24 ++++----- .../src/collections/vec_deque/into_iter.rs | 2 +- .../alloc/src/collections/vec_deque/mod.rs | 52 +++++++++---------- .../src/collections/vec_deque/spec_extend.rs | 12 ++--- .../collections/vec_deque/spec_from_iter.rs | 6 +-- 5 files changed, 48 insertions(+), 48 deletions(-) diff --git a/library/alloc/src/collections/vec_deque/drain.rs b/library/alloc/src/collections/vec_deque/drain.rs index 1bfeaf5a5d3fc..cd0e6caace3f4 100644 --- a/library/alloc/src/collections/vec_deque/drain.rs +++ b/library/alloc/src/collections/vec_deque/drain.rs @@ -22,7 +22,7 @@ pub struct Drain< #[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_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { // We can't just use a &mut VecDeque, as that would make Drain invariant over T // and we want it to be covariant instead @@ -40,7 +40,7 @@ pub struct Drain< impl<'a, T, A: Allocator, const COOP_PREFERRED: bool> Drain<'a, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { pub(super) unsafe fn new( deque: &'a mut VecDeque, @@ -98,7 +98,7 @@ where impl fmt::Debug for Drain<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_tuple("Drain") @@ -114,33 +114,33 @@ where unsafe impl Sync for Drain<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { } #[stable(feature = "drain", since = "1.6.0")] unsafe impl Send for Drain<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { } #[stable(feature = "drain", since = "1.6.0")] impl Drop for Drain<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn drop(&mut self) { 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_specific::(COOP_PREFERRED)]:; + [(); alloc::co_alloc_metadata_num_slots_with_preference::(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_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn drop(&mut self) { if self.0.remaining != 0 { @@ -224,7 +224,7 @@ where #[stable(feature = "drain", since = "1.6.0")] impl Iterator for Drain<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { type Item = T; @@ -250,7 +250,7 @@ where impl DoubleEndedIterator for Drain<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { #[inline] fn next_back(&mut self) -> Option { @@ -267,12 +267,12 @@ where impl ExactSizeIterator for Drain<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { } #[stable(feature = "fused", since = "1.26.0")] impl FusedIterator for Drain<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(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 1c3bedd21e7e2..7924098c14db2 100644 --- a/library/alloc/src/collections/vec_deque/into_iter.rs +++ b/library/alloc/src/collections/vec_deque/into_iter.rs @@ -19,7 +19,7 @@ pub struct IntoIter< #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global, const COOP_PREFERRED: bool = true, > where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { inner: VecDeque, } diff --git a/library/alloc/src/collections/vec_deque/mod.rs b/library/alloc/src/collections/vec_deque/mod.rs index 93ae1f7d1b6ce..ffceae18a6cff 100644 --- a/library/alloc/src/collections/vec_deque/mod.rs +++ b/library/alloc/src/collections/vec_deque/mod.rs @@ -99,7 +99,7 @@ pub struct VecDeque< #[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_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { // `self[0]`, if it exists, is `buf[head]`. // `head < buf.capacity()`, unless `buf.capacity() == 0` when `head == 0`. @@ -115,7 +115,7 @@ pub struct VecDeque< impl Clone for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn clone(&self) -> Self { let mut deq = Self::with_capacity_in(self.len(), self.allocator().clone()); @@ -133,7 +133,7 @@ where unsafe impl<#[may_dangle] T, A: Allocator, const COOP_PREFERRED: bool> Drop for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn drop(&mut self) { /// Runs the destructor for all items in the slice when it gets dropped (normally or @@ -172,7 +172,7 @@ where impl VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { /// Marginally more convenient #[inline] @@ -464,7 +464,7 @@ where ) -> usize { struct Guard<'a, T, A: Allocator, const COOP_PREFERRED: bool> where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { deque: &'a mut VecDeque, written: usize, @@ -472,7 +472,7 @@ where 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_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn drop(&mut self) { self.deque.len += self.written; @@ -553,7 +553,7 @@ where impl VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { /// Creates an empty deque. /// @@ -592,7 +592,7 @@ where impl VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { /// Creates an empty deque. /// @@ -2630,7 +2630,7 @@ where impl VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(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` @@ -2679,7 +2679,7 @@ fn wrap_index(logical_index: usize, capacity: usize) -> usize { impl PartialEq for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn eq(&self, other: &Self) -> bool { if self.len != other.len() { @@ -2720,7 +2720,7 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl Eq for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]: + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { } @@ -2735,7 +2735,7 @@ __impl_slice_eq1! { [const N: usize] VecDeque, &mut [U; N] impl PartialOrd for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn partial_cmp(&self, other: &Self) -> Option { self.iter().partial_cmp(other.iter()) @@ -2745,7 +2745,7 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl Ord for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { #[inline] fn cmp(&self, other: &Self) -> Ordering { @@ -2756,7 +2756,7 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl Hash for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn hash(&self, state: &mut H) { state.write_length_prefix(self.len); @@ -2773,7 +2773,7 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl Index for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { type Output = T; @@ -2786,7 +2786,7 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl IndexMut for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { #[inline] fn index_mut(&mut self, index: usize) -> &mut T { @@ -2797,7 +2797,7 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl FromIterator for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn from_iter>(iter: I) -> VecDeque { SpecFromIter::spec_from_iter(iter.into_iter()) @@ -2807,7 +2807,7 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl IntoIterator for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { type Item = T; type IntoIter = IntoIter; @@ -2823,7 +2823,7 @@ where impl<'a, T, A: Allocator, const COOP_PREFERRED: bool> IntoIterator for &'a VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { type Item = &'a T; type IntoIter = Iter<'a, T>; @@ -2837,7 +2837,7 @@ where impl<'a, T, A: Allocator, const COOP_PREFERRED: bool> IntoIterator for &'a mut VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { type Item = &'a mut T; type IntoIter = IterMut<'a, T>; @@ -2850,7 +2850,7 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl Extend for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn extend>(&mut self, iter: I) { >::spec_extend(self, iter.into_iter()); @@ -2871,7 +2871,7 @@ where impl<'a, T: 'a + Copy, A: Allocator, const COOP_PREFERRED: bool> Extend<&'a T> for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn extend>(&mut self, iter: I) { self.spec_extend(iter.into_iter()); @@ -2892,7 +2892,7 @@ where impl fmt::Debug for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_list().entries(self.iter()).finish() @@ -2903,7 +2903,7 @@ where impl From> for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { /// Turn a [`Vec`] into a [`VecDeque`]. /// @@ -2916,7 +2916,7 @@ where #[inline] fn from(other: Vec) -> Self where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::( + [(); alloc::co_alloc_metadata_num_slots_with_preference::( OTHER_COOP_PREFERRED, )]:, { @@ -2929,7 +2929,7 @@ where impl From> for Vec where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { /// Turn a [`VecDeque`] into a [`Vec`]. /// diff --git a/library/alloc/src/collections/vec_deque/spec_extend.rs b/library/alloc/src/collections/vec_deque/spec_extend.rs index 973de88ffb172..b1a9d23fd4a99 100644 --- a/library/alloc/src/collections/vec_deque/spec_extend.rs +++ b/library/alloc/src/collections/vec_deque/spec_extend.rs @@ -17,7 +17,7 @@ impl SpecExtend for VecDeque where I: Iterator, - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { default fn spec_extend(&mut self, mut iter: I) { // This function should be the moral equivalent of: @@ -31,7 +31,7 @@ where deque: &mut VecDeque, element: T, ) where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { // SAFETY: Because of the precondition, it's guaranteed that there is space // in the logical array after the last element. @@ -63,7 +63,7 @@ impl SpecExtend for VecDeque where I: TrustedLen, - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { default fn spec_extend(&mut self, iter: I) { // This is the case for a TrustedLen iterator. @@ -99,7 +99,7 @@ where impl SpecExtend> for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn spec_extend(&mut self, mut iterator: vec::IntoIter) { let slice = iterator.as_slice(); @@ -118,7 +118,7 @@ impl<'a, T: 'a, I, A: Allocator, const COOP_PREFERRED: bool> SpecExtend<&'a T, I where I: Iterator, T: Copy, - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { default fn spec_extend(&mut self, iterator: I) { self.spec_extend(iterator.copied()) @@ -129,7 +129,7 @@ impl<'a, T: 'a, A: Allocator, const COOP_PREFERRED: bool> SpecExtend<&'a T, slic for VecDeque where T: Copy, - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(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 086a1fa74566c..85dd756337350 100644 --- a/library/alloc/src/collections/vec_deque/spec_from_iter.rs +++ b/library/alloc/src/collections/vec_deque/spec_from_iter.rs @@ -11,7 +11,7 @@ impl SpecFromIter for VecDeque where I: Iterator, - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { default fn spec_from_iter(iterator: I) -> Self { // Since converting is O(1) now, just re-use the `Vec` logic for @@ -25,7 +25,7 @@ where impl SpecFromIter> for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { #[inline] fn spec_from_iter(iterator: crate::vec::IntoIter) -> Self { @@ -36,7 +36,7 @@ where impl SpecFromIter> for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { #[inline] fn spec_from_iter(iterator: IntoIter) -> Self { From 9fd925db79b676307248c6b2852d91eb376cfd16 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 20:58:47 -0800 Subject: [PATCH 40/80] CoAlloc: Vec + Box + Rc: Fixing COOP_PREFERRED (and similar). --- library/alloc/src/boxed.rs | 8 +++++--- library/alloc/src/lib.rs | 2 +- library/alloc/src/rc.rs | 4 ++-- library/alloc/src/vec/drain.rs | 2 +- library/alloc/src/vec/in_place_drop.rs | 3 ++- library/alloc/src/vec/into_iter.rs | 3 ++- library/alloc/src/vec/mod.rs | 20 +++++++++++++------- library/alloc/src/vec/spec_from_elem.rs | 2 +- library/alloc/src/vec/splice.rs | 24 +++++++++++++----------- library/core/src/alloc/mod.rs | 2 +- 10 files changed, 41 insertions(+), 29 deletions(-) diff --git a/library/alloc/src/boxed.rs b/library/alloc/src/boxed.rs index 86e9c96c5f42f..9d455b0568364 100644 --- a/library/alloc/src/boxed.rs +++ b/library/alloc/src/boxed.rs @@ -641,7 +641,8 @@ impl Box<[T]> { #[unstable(feature = "new_uninit", issue = "63291")] #[must_use] pub fn new_uninit_slice(len: usize) -> Box<[mem::MaybeUninit]> { - 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::::with_capacity(len).into_box(len) } } /// Constructs a new boxed slice with uninitialized contents, with the memory @@ -666,7 +667,8 @@ impl Box<[T]> { #[unstable(feature = "new_uninit", issue = "63291")] #[must_use] pub fn new_zeroed_slice(len: usize) -> Box<[mem::MaybeUninit]> { - 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::::with_capacity_zeroed(len).into_box(len) } } /// Constructs a new boxed slice with uninitialized contents. Returns an error if @@ -1687,7 +1689,7 @@ impl TryFrom> for Box<[T; N]> { impl TryFrom> for Box<[T; N]> where - [(); crate::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { type Error = Vec; diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs index a775d995500ee..c8035bd295f58 100644 --- a/library/alloc/src/lib.rs +++ b/library/alloc/src/lib.rs @@ -291,6 +291,6 @@ use crate::alloc::Global; /// See also `core::alloc::co_alloc_metadata_num_slots_with_preference`. #[unstable(feature = "global_co_alloc", issue = "none")] pub const fn co_alloc_metadata_num_slots_with_preference_global(coop_preferred: bool) -> usize { - // FIXME or replace any calls with core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED). Then rename co_alloc_metadata_num_slots_with_preference_specific to co_alloc_metadata_num_slots_with_preference. See raw_vec.rs. + // FIXME or replace any calls with core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED). See raw_vec.rs. if /*Global::IS_CO_ALLOCATOR*/ true && coop_preferred { 1 } else { 0 } } diff --git a/library/alloc/src/rc.rs b/library/alloc/src/rc.rs index aeffaf7afbcd5..e4bf9d5fe2fba 100644 --- a/library/alloc/src/rc.rs +++ b/library/alloc/src/rc.rs @@ -1989,7 +1989,7 @@ impl From> for Rc { #[stable(feature = "shared_from_slice", since = "1.21.0")] impl From> for Rc<[T]> where - [(); crate::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { /// Allocate a reference-counted slice and move `v`'s items into it. /// @@ -2004,7 +2004,7 @@ where #[inline] fn from(mut v: Vec) -> Rc<[T]> where - [(); crate::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { unsafe { let rc = Rc::copy_from_slice(&v); diff --git a/library/alloc/src/vec/drain.rs b/library/alloc/src/vec/drain.rs index 05fee754beec8..a219ca302d4c4 100644 --- a/library/alloc/src/vec/drain.rs +++ b/library/alloc/src/vec/drain.rs @@ -26,7 +26,7 @@ pub struct Drain< #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator + 'a = Global, const COOP_PREFERRED: bool = { SHORT_TERM_VEC_PREFERS_COOP!() }, > where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { /// Index of tail to preserve pub(super) tail_start: usize, diff --git a/library/alloc/src/vec/in_place_drop.rs b/library/alloc/src/vec/in_place_drop.rs index 25ca33c6a7bf0..6788b59f3a020 100644 --- a/library/alloc/src/vec/in_place_drop.rs +++ b/library/alloc/src/vec/in_place_drop.rs @@ -34,6 +34,7 @@ pub(super) struct InPlaceDstBufDrop { impl Drop for InPlaceDstBufDrop { #[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::::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 5afb11ee7ba24..569cc61635296 100644 --- a/library/alloc/src/vec/into_iter.rs +++ b/library/alloc/src/vec/into_iter.rs @@ -451,7 +451,8 @@ where // `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( + // @FIXME pass true instead of COOP_PREFERRED - use e.g.: if COOP_PREFERRED {let _ = RawVec::::from_raw_parts_in(..) } else { let _ = from_raw_parts_in_coop(...)} } + let _ = RawVec::::from_raw_parts_in( self.0.buf.as_ptr(), self.0.cap, alloc, diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs index 1116cc50e4275..bb083cbe15a07 100644 --- a/library/alloc/src/vec/mod.rs +++ b/library/alloc/src/vec/mod.rs @@ -447,7 +447,7 @@ pub type WeVec = Vec 127 }>; impl Vec where - [(); crate::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { /// Constructs a new, empty `Vec`. /// @@ -2060,9 +2060,11 @@ where /// assert_eq!(v, &[]); /// ``` #[stable(feature = "drain", since = "1.6.0")] - pub fn drain(&mut self, range: R) -> Drain<'_, T, A> + pub fn drain(&mut self, range: R) -> Drain<'_, T, A, COOP_PREFERRED> where R: RangeBounds, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(SHORT_TERM_VEC_PREFERS_COOP!())]:, + { // Memory safety // @@ -2557,7 +2559,7 @@ where // - `new_cap` refers to the same sized allocation as `cap` because // `new_cap * size_of::()` == `cap * size_of::<[T; N]>()` // - `len` <= `cap`, so `len * N` <= `cap * N`. - unsafe { Vec::::from_raw_parts_in(ptr.cast(), new_len, new_cap, alloc) } + unsafe { Vec::::from_raw_parts_in(ptr.cast(), new_len, new_cap, alloc) } } } @@ -2886,9 +2888,11 @@ impl FromIterator for Vec { impl IntoIterator for Vec where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(SHORT_TERM_VEC_PREFERS_COOP!())]:, + { type Item = T; - type IntoIter = IntoIter; + type IntoIter = IntoIter; /// 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 @@ -3080,10 +3084,11 @@ where #[cfg(not(no_global_oom_handling))] #[inline] #[stable(feature = "vec_splice", since = "1.21.0")] - pub fn splice(&mut self, range: R, replace_with: I) -> Splice<'_, I::IntoIter, A> + pub fn splice(&mut self, range: R, replace_with: I) -> Splice<'_, I::IntoIter, A, COOP_PREFERRED> where R: RangeBounds, I: IntoIterator, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(true)]:, { Splice { drain: self.drain(range), replace_with: replace_with.into_iter() } } @@ -3133,9 +3138,10 @@ where /// assert_eq!(odds, vec![1, 3, 5, 9, 11, 13, 15]); /// ``` #[unstable(feature = "drain_filter", reason = "recently added", issue = "43244")] - pub fn drain_filter(&mut self, filter: F) -> DrainFilter<'_, T, F, A> + pub fn drain_filter(&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::(true)]:, { let old_len = self.len(); @@ -3228,7 +3234,7 @@ where #[rustc_const_unstable(feature = "const_default_impls", issue = "87864")] impl const Default for Vec where - [(); crate::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { /// Creates an empty `Vec`. /// diff --git a/library/alloc/src/vec/spec_from_elem.rs b/library/alloc/src/vec/spec_from_elem.rs index 3766f6de061bb..bc4169a24f0b2 100644 --- a/library/alloc/src/vec/spec_from_elem.rs +++ b/library/alloc/src/vec/spec_from_elem.rs @@ -14,7 +14,7 @@ pub(super) trait SpecFromElem: Sized { alloc: A, ) -> Vec where - [(); alloc::co_alloc_metadata_num_slots::(COOP_PREFERRED)]:; + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:; } impl SpecFromElem for T { diff --git a/library/alloc/src/vec/splice.rs b/library/alloc/src/vec/splice.rs index d8569a6e89c62..185f09be55287 100644 --- a/library/alloc/src/vec/splice.rs +++ b/library/alloc/src/vec/splice.rs @@ -23,17 +23,19 @@ pub struct Splice< 'a, I: Iterator + 'a, #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator + 'a = Global, + const COOP_PREFERRED: bool = false > where - [(); core::alloc::co_alloc_metadata_num_slots::()]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + //FIXME: If using SHORT_TERM_VEC_PREFERS_COOP!() instead of true, and the same for `drain` below, then this failed with: `derive` cannot be used on item swith type macros { - pub(super) drain: Drain<'a, I::Item, A>, + pub(super) drain: Drain<'a, I::Item, A, COOP_PREFERRED>, pub(super) replace_with: I, } #[stable(feature = "vec_splice", since = "1.21.0")] -impl Iterator for Splice<'_, I, A> +impl Iterator for Splice<'_, I, A, COOP_PREFERRED> where - [(); core::alloc::co_alloc_metadata_num_slots::()]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { type Item = I::Item; @@ -47,9 +49,9 @@ where } #[stable(feature = "vec_splice", since = "1.21.0")] -impl DoubleEndedIterator for Splice<'_, I, A> +impl DoubleEndedIterator for Splice<'_, I, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots::()]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn next_back(&mut self) -> Option { self.drain.next_back() @@ -57,15 +59,15 @@ where } #[stable(feature = "vec_splice", since = "1.21.0")] -impl ExactSizeIterator for Splice<'_, I, A> where - [(); alloc::co_alloc_metadata_num_slots::()]: +impl ExactSizeIterator for Splice<'_, I, A, COOP_PREFERRED> where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { } #[stable(feature = "vec_splice", since = "1.21.0")] -impl Drop for Splice<'_, I, A> +impl Drop for Splice<'_, I, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots::()]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn drop(&mut self) { self.drain.by_ref().for_each(drop); @@ -115,7 +117,7 @@ where /// Private helper methods for `Splice::drop` impl Drain<'_, T, A> where - [(); alloc::co_alloc_metadata_num_slots::()]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(true)]:, { /// The range from `self.vec.len` to `self.tail_start` contains elements /// that have been moved out. diff --git a/library/core/src/alloc/mod.rs b/library/core/src/alloc/mod.rs index 7be3f9cd24b3b..ae4bad73a98ae 100644 --- a/library/core/src/alloc/mod.rs +++ b/library/core/src/alloc/mod.rs @@ -95,7 +95,7 @@ pub type SliceAndMetaResult = Result; pub const fn co_alloc_metadata_num_slots() -> usize { // @FIXME later if false { - panic!("FIXME - consider replacing co_alloc_metadata_num_slots() with co_alloc_metadata_num_slots_with_preference_specific(bool), and adding const flags as appropriate."); + 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 } } From 8d02835c17f198a029388acb972e0c114e81b14c Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 20:59:38 -0800 Subject: [PATCH 41/80] CoAlloc: VecDeque: Fixing COOP_PREFERRED (and similar). --- .../src/collections/vec_deque/into_iter.rs | 28 +++++++------- .../alloc/src/collections/vec_deque/macros.rs | 2 +- .../alloc/src/collections/vec_deque/mod.rs | 38 +++++++++++-------- 3 files changed, 38 insertions(+), 30 deletions(-) diff --git a/library/alloc/src/collections/vec_deque/into_iter.rs b/library/alloc/src/collections/vec_deque/into_iter.rs index 7924098c14db2..38aba07585a90 100644 --- a/library/alloc/src/collections/vec_deque/into_iter.rs +++ b/library/alloc/src/collections/vec_deque/into_iter.rs @@ -26,7 +26,7 @@ pub struct IntoIter< impl IntoIter where - [(); alloc::co_alloc_metadata_num_slots::()]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { pub(super) fn new(inner: VecDeque) -> Self { IntoIter { inner } @@ -38,9 +38,9 @@ where } #[stable(feature = "collection_debug", since = "1.17.0")] -impl fmt::Debug for IntoIter +impl fmt::Debug for IntoIter where - [(); alloc::co_alloc_metadata_num_slots::()]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_tuple("IntoIter").field(&self.inner).finish() @@ -48,9 +48,9 @@ where } #[stable(feature = "rust1", since = "1.0.0")] -impl Iterator for IntoIter +impl Iterator for IntoIter where - [(); alloc::co_alloc_metadata_num_slots::()]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { type Item = T; @@ -67,9 +67,9 @@ where } #[stable(feature = "rust1", since = "1.0.0")] -impl DoubleEndedIterator for IntoIter +impl DoubleEndedIterator for IntoIter where - [(); alloc::co_alloc_metadata_num_slots::()]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { #[inline] fn next_back(&mut self) -> Option { @@ -78,9 +78,9 @@ where } #[stable(feature = "rust1", since = "1.0.0")] -impl ExactSizeIterator for IntoIter +impl ExactSizeIterator for IntoIter where - [(); alloc::co_alloc_metadata_num_slots::()]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn is_empty(&self) -> bool { self.inner.is_empty() @@ -88,13 +88,15 @@ where } #[stable(feature = "fused", since = "1.26.0")] -impl FusedIterator for IntoIter where - [(); alloc::co_alloc_metadata_num_slots::()]: +impl FusedIterator for IntoIter +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { } #[unstable(feature = "trusted_len", issue = "37572")] -unsafe impl TrustedLen for IntoIter where - [(); alloc::co_alloc_metadata_num_slots::()]: +unsafe impl TrustedLen for IntoIter +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { } diff --git a/library/alloc/src/collections/vec_deque/macros.rs b/library/alloc/src/collections/vec_deque/macros.rs index 77885e6811a3b..68ee43152b5b5 100644 --- a/library/alloc/src/collections/vec_deque/macros.rs +++ b/library/alloc/src/collections/vec_deque/macros.rs @@ -4,7 +4,7 @@ macro_rules! __impl_slice_eq1 { impl PartialEq<$rhs> for $lhs where T: PartialEq, - [(); core::alloc::co_alloc_metadata_num_slots_with_preference_specific::(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(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 ffceae18a6cff..073bac85894d9 100644 --- a/library/alloc/src/collections/vec_deque/mod.rs +++ b/library/alloc/src/collections/vec_deque/mod.rs @@ -161,7 +161,7 @@ where #[stable(feature = "rust1", since = "1.0.0")] impl Default for VecDeque where - [(); crate::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { /// Creates an empty deque. #[inline] @@ -568,7 +568,9 @@ where #[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 { + pub const fn new() -> VecDeque + where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + { // FIXME: This should just be `VecDeque::new_in(Global)` once that hits stable. VecDeque { head: 0, len: 0, buf: RawVec::NEW } } @@ -1403,6 +1405,7 @@ where pub fn drain(&mut self, range: R) -> Drain<'_, T, A> where R: RangeBounds, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(SHORT_TERM_VEC_PREFERS_COOP!())]:, { // Memory safety // @@ -2799,7 +2802,7 @@ impl FromIterator for VecDeque(COOP_PREFERRED)]:, { - fn from_iter>(iter: I) -> VecDeque { + fn from_iter>(iter: I) -> VecDeque { SpecFromIter::spec_from_iter(iter.into_iter()) } } @@ -2810,11 +2813,11 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { type Item = T; - type IntoIter = IntoIter; + type IntoIter = IntoIter; /// Consumes the deque into a front-to-back iterator yielding elements by /// value. - fn into_iter(self) -> IntoIter { + fn into_iter(self) -> IntoIter { IntoIter::new(self) } } @@ -2900,10 +2903,13 @@ where } #[stable(feature = "vecdeque_vec_conversions", since = "1.10.0")] -impl From> +impl From> for VecDeque where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::( + OTHER_COOP_PREFERRED, + )]:, { /// Turn a [`Vec`] into a [`VecDeque`]. /// @@ -2914,11 +2920,7 @@ where /// and to not re-allocate the `Vec`'s buffer or allocate /// any additional memory. #[inline] - fn from(other: Vec) -> Self - where - [(); alloc::co_alloc_metadata_num_slots_with_preference::( - OTHER_COOP_PREFERRED, - )]:, + fn from(other: Vec) -> 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) } } @@ -2926,10 +2928,11 @@ where } #[stable(feature = "vecdeque_vec_conversions", since = "1.10.0")] -impl From> +impl From> for Vec where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(VECDEQUE_COOP_PREFERRED)]:, { /// Turn a [`VecDeque`] into a [`Vec`]. /// @@ -2960,9 +2963,12 @@ where /// assert_eq!(vec, [8, 9, 1, 2, 3, 4]); /// assert_eq!(vec.as_ptr(), ptr); /// ``` - fn from( - mut other: VecDeque, - ) -> Self { + fn from( + mut other: VecDeque, + ) -> Self + where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(VECDEQUE_COOP_PREFERRED)]:, + { other.make_contiguous(); unsafe { @@ -2985,7 +2991,7 @@ where impl From<[T; N]> for VecDeque where - [(); crate::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { /// Converts a `[T; N]` into a `VecDeque`. /// From 6a82ca6c8ee2732b2ed22d8dc906b8871e9bcfa5 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 21:00:01 -0800 Subject: [PATCH 42/80] CoAlloc: BinaryHeap: Fixing COOP_PREFERRED (and similar). --- .../alloc/src/collections/binary_heap/mod.rs | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-) diff --git a/library/alloc/src/collections/binary_heap/mod.rs b/library/alloc/src/collections/binary_heap/mod.rs index bc08a604b8cd0..1290a449facd2 100644 --- a/library/alloc/src/collections/binary_heap/mod.rs +++ b/library/alloc/src/collections/binary_heap/mod.rs @@ -1527,7 +1527,7 @@ unsafe impl TrustedLen for IntoIterSorted {} #[derive(Debug)] pub struct Drain<'a, T: 'a, const COOP_PREFERRED: bool> where - [(); crate::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { iter: vec::Drain<'a, T, Global, COOP_PREFERRED>, } @@ -1535,7 +1535,7 @@ where #[stable(feature = "drain", since = "1.6.0")] impl Iterator for Drain<'_, T, COOP_PREFERRED> where - [(); crate::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { type Item = T; @@ -1551,7 +1551,10 @@ where } #[stable(feature = "drain", since = "1.6.0")] -impl DoubleEndedIterator for Drain<'_, T, COOP_PREFERRED> { +impl DoubleEndedIterator for Drain<'_, T, COOP_PREFERRED> +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ #[inline] fn next_back(&mut self) -> Option { self.iter.next_back() @@ -1559,14 +1562,20 @@ impl DoubleEndedIterator for Drain<'_, T, COOP_PR } #[stable(feature = "drain", since = "1.6.0")] -impl ExactSizeIterator for Drain<'_, T, COOP_PREFERRED> { +impl ExactSizeIterator for Drain<'_, T, COOP_PREFERRED> +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ fn is_empty(&self) -> bool { self.iter.is_empty() } } #[stable(feature = "fused", since = "1.26.0")] -impl FusedIterator for Drain<'_, T, COOP_PREFERRED> {} +impl FusedIterator for Drain<'_, T, COOP_PREFERRED> +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{} /// A draining iterator over the elements of a `BinaryHeap`. /// From 734816229288b7d7839f3d96383bdc10356e8fd7 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 21:02:00 -0800 Subject: [PATCH 43/80] CoAlloc: Vec + Box: Fixing COOP_PREFERRED. --- library/alloc/src/boxed.rs | 18 +++++++++++++----- library/alloc/src/vec/in_place_drop.rs | 1 + library/alloc/src/vec/mod.rs | 8 ++++++-- 3 files changed, 20 insertions(+), 7 deletions(-) diff --git a/library/alloc/src/boxed.rs b/library/alloc/src/boxed.rs index 9d455b0568364..32277063ac0b0 100644 --- a/library/alloc/src/boxed.rs +++ b/library/alloc/src/boxed.rs @@ -778,7 +778,10 @@ where // #[unstable(feature = "new_uninit", issue = "63291")] #[must_use] #[allow(unused_braces)] - pub fn new_uninit_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit], A> { + pub fn new_uninit_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit], A> + where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(SHORT_TERM_VEC_PREFERS_COOP!())]:, + { unsafe { RawVec::::with_capacity_in(len, alloc) .into_box(len) @@ -810,7 +813,10 @@ where // #[unstable(feature = "new_uninit", issue = "63291")] #[must_use] #[allow(unused_braces)] - pub fn new_zeroed_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit], A> { + pub fn new_zeroed_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit], A> + where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(SHORT_TERM_VEC_PREFERS_COOP!())]:, + { unsafe { RawVec::::with_capacity_zeroed_in( len, alloc, @@ -1521,7 +1527,8 @@ impl 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::::with_capacity(len); unsafe { ptr::copy_nonoverlapping(slice.as_ptr(), buf.ptr(), len); buf.into_box(slice.len()).assume_init() @@ -2050,11 +2057,12 @@ impl FromIterator for Box<[I]> { #[stable(feature = "box_slice_clone", since = "1.3.0")] impl Clone for Box<[T], A> where - [(); core::alloc::co_alloc_metadata_num_slots::()]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(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::(alloc).into_boxed_slice() } fn clone_from(&mut self, other: &Self) { diff --git a/library/alloc/src/vec/in_place_drop.rs b/library/alloc/src/vec/in_place_drop.rs index 6788b59f3a020..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. diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs index bb083cbe15a07..a1e329679e6b7 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; @@ -2877,9 +2878,12 @@ where #[cfg(not(no_global_oom_handling))] #[stable(feature = "rust1", since = "1.0.0")] #[allow(unused_braces)] -impl FromIterator for Vec { +impl FromIterator for Vec +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + { #[inline] - fn from_iter>(iter: I) -> Vec { + fn from_iter>(iter: I) -> Vec { >::from_iter(iter.into_iter()) } } From 51889f12a90ecc7dd39f32886dd7fb622a38fe06 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 21:02:46 -0800 Subject: [PATCH 44/80] CoAlloc: VecDeque: Fixing COOP_PREFERRED. --- library/alloc/src/collections/vec_deque/spec_from_iter.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 85dd756337350..b9f77ffa07503 100644 --- a/library/alloc/src/collections/vec_deque/spec_from_iter.rs +++ b/library/alloc/src/collections/vec_deque/spec_from_iter.rs @@ -18,7 +18,7 @@ where // 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::::from_iter(iterator).into() } } From a772e0f3761bbf169e87e9460ed8e8f06265e695 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 21:03:37 -0800 Subject: [PATCH 45/80] CoAlloc: Vec: Fixing COOP_PREFERRED. --- library/alloc/src/vec/in_place_collect.rs | 8 ++++---- library/alloc/src/vec/spec_from_iter.rs | 11 +++++++---- 2 files changed, 11 insertions(+), 8 deletions(-) diff --git a/library/alloc/src/vec/in_place_collect.rs b/library/alloc/src/vec/in_place_collect.rs index 6f3c44a8aa8b6..6d9e3b825c376 100644 --- a/library/alloc/src/vec/in_place_collect.rs +++ b/library/alloc/src/vec/in_place_collect.rs @@ -137,13 +137,11 @@ //! } //! vec.truncate(write_idx); //! ``` +use core::alloc::{self, Allocator}; use core::iter::{InPlaceIterable, SourceIter, TrustedRandomAccessNoCoerce}; use core::mem::{self, ManuallyDrop, SizedTypeProperties}; use core::ptr::{self}; -use crate::Global; -use crate::DEFAULT_COOP_PREFERRED; - use super::{InPlaceDrop, InPlaceDstBufDrop, SpecFromIter, SpecFromIterNested, Vec}; /// Specialization marker for collecting an iterator pipeline into a Vec while reusing the @@ -154,9 +152,11 @@ pub(super) trait InPlaceIterableMarker {} impl InPlaceIterableMarker for T where T: InPlaceIterable {} #[allow(unused_braces)] -impl SpecFromIter for Vec +impl SpecFromIter for Vec where I: Iterator + SourceIter + InPlaceIterableMarker, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(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/spec_from_iter.rs b/library/alloc/src/vec/spec_from_iter.rs index 06da451fe3932..9ed63aceb77a0 100644 --- a/library/alloc/src/vec/spec_from_iter.rs +++ b/library/alloc/src/vec/spec_from_iter.rs @@ -1,7 +1,6 @@ +use core::alloc::{self, Allocator}; use core::mem::ManuallyDrop; use core::ptr::{self}; -use crate::Global; -use crate::DEFAULT_COOP_PREFERRED; use super::{IntoIter, SpecExtend, SpecFromIterNested, Vec}; @@ -28,9 +27,10 @@ pub(super) trait SpecFromIter { } #[allow(unused_braces)] -impl SpecFromIter for Vec +impl SpecFromIter for Vec where I: Iterator, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { default fn from_iter(iterator: I) -> Self { SpecFromIterNested::from_iter(iterator) @@ -38,7 +38,10 @@ where } #[allow(unused_braces)] -impl SpecFromIter> for Vec { +impl SpecFromIter> for Vec +where +[(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{ fn from_iter(iterator: IntoIter) -> 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 From 1647c550db14d0a431d11bdfae45481fd03e67d1 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 21:04:21 -0800 Subject: [PATCH 46/80] CoAlloc: VecDeque: Fixing COOP_PREFERRED. --- library/alloc/src/collections/vec_deque/spec_from_iter.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) 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 b9f77ffa07503..fe5a1f169f56f 100644 --- a/library/alloc/src/collections/vec_deque/spec_from_iter.rs +++ b/library/alloc/src/collections/vec_deque/spec_from_iter.rs @@ -22,18 +22,18 @@ where } } -impl SpecFromIter> +impl SpecFromIter> for VecDeque where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { #[inline] - fn spec_from_iter(iterator: crate::vec::IntoIter) -> Self { + fn spec_from_iter(iterator: crate::vec::IntoIter) -> Self { iterator.into_vecdeque() } } -impl SpecFromIter> +impl SpecFromIter> for VecDeque where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, From 6720d1e4c000ec1e94f2535bc8a63ab9ad21c6e6 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 21:06:06 -0800 Subject: [PATCH 47/80] CoAlloc: VecDeque: Fixing COOP_PREFERRED --- library/alloc/src/collections/vec_deque/mod.rs | 15 ++++++++------- .../src/collections/vec_deque/spec_from_iter.rs | 2 +- 2 files changed, 9 insertions(+), 8 deletions(-) diff --git a/library/alloc/src/collections/vec_deque/mod.rs b/library/alloc/src/collections/vec_deque/mod.rs index 073bac85894d9..af17728fed5c0 100644 --- a/library/alloc/src/collections/vec_deque/mod.rs +++ b/library/alloc/src/collections/vec_deque/mod.rs @@ -166,7 +166,7 @@ where /// Creates an empty deque. #[inline] fn default() -> VecDeque { - VecDeque::new() + VecDeque::::new() } } @@ -554,6 +554,7 @@ where impl VecDeque where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { /// Creates an empty deque. /// @@ -587,8 +588,8 @@ where #[inline] #[stable(feature = "rust1", since = "1.0.0")] #[must_use] - pub fn with_capacity(capacity: usize) -> VecDeque { - Self::with_capacity_in(capacity, Global) + pub fn with_capacity(capacity: usize) -> VecDeque { + VecDeque::::with_capacity_in(capacity, Global) } } @@ -1402,7 +1403,7 @@ where /// ``` #[inline] #[stable(feature = "drain", since = "1.6.0")] - pub fn drain(&mut self, range: R) -> Drain<'_, T, A> + pub fn drain(&mut self, range: R) -> Drain<'_, T, A, COOP_PREFERRED> where R: RangeBounds, [(); alloc::co_alloc_metadata_num_slots_with_preference::(SHORT_TERM_VEC_PREFERS_COOP!())]:, @@ -2923,7 +2924,7 @@ where fn from(other: Vec) -> 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::::from_raw_parts_in(ptr, cap, alloc) } } } } @@ -2982,7 +2983,7 @@ where ptr::copy(buf.add(other.head), buf, len); } // @FIXME: COOP - Vec::from_raw_parts_in(buf, len, cap, alloc) + Vec::::from_raw_parts_in(buf, len, cap, alloc) } } } @@ -3003,7 +3004,7 @@ where /// assert_eq!(deq1, deq2); /// ``` fn from(arr: [T; N]) -> Self { - let mut deq = VecDeque::with_capacity(N); + let mut deq = VecDeque::::with_capacity(N); let arr = ManuallyDrop::new(arr); if !::IS_ZST { // SAFETY: VecDeque::with_capacity ensures that there is enough capacity. 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 fe5a1f169f56f..450a64b792c5b 100644 --- a/library/alloc/src/collections/vec_deque/spec_from_iter.rs +++ b/library/alloc/src/collections/vec_deque/spec_from_iter.rs @@ -39,7 +39,7 @@ where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { #[inline] - fn spec_from_iter(iterator: IntoIter) -> Self { + fn spec_from_iter(iterator: IntoIter) -> Self { iterator.into_vecdeque() } } From 59f9ed549e4704346db30701903d4c905b06ee4e Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 21:06:57 -0800 Subject: [PATCH 48/80] CoAlloc: Slice: Fixing COOP_PREFERRED --- library/alloc/src/slice.rs | 36 ++++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/library/alloc/src/slice.rs b/library/alloc/src/slice.rs index 538fc9b67fe4a..832eb71ce110f 100644 --- a/library/alloc/src/slice.rs +++ b/library/alloc/src/slice.rs @@ -911,12 +911,48 @@ where } }; +//<<<<<<< HEAD let run_alloc_fn = |len: usize| -> *mut sort::TimSortRun { // SAFETY: Creating the layout is safe as long as merge_sort never calls this with an // obscene length or 0. unsafe { alloc::alloc(alloc::Layout::array::(len).unwrap_unchecked()) as *mut sort::TimSortRun +/*======= + // Allocate a buffer to use as scratch memory. We keep the length 0 so we can keep in it + // 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`. + // `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::::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. + // `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. + let mut start = end - 1; + if start > 0 { + start -= 1; + unsafe { + if is_less(v.get_unchecked(start + 1), v.get_unchecked(start)) { + while start > 0 && is_less(v.get_unchecked(start), v.get_unchecked(start - 1)) { + start -= 1; + } + v[start..end].reverse(); + } else { + while start > 0 && !is_less(v.get_unchecked(start), v.get_unchecked(start - 1)) + { + start -= 1; + } + } + } +>>>>>>> 6bd68177557 (CoAlloc: Slice: Fixing COOP_PREFERRED)*/ } }; From d84940360149a3fce403f0c9df72fe10171f12a1 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 21:08:03 -0800 Subject: [PATCH 49/80] CoAlloc: Vec: Fixing COOP_PREFERRED --- library/alloc/src/vec/mod.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs index a1e329679e6b7..7935a71008aae 100644 --- a/library/alloc/src/vec/mod.rs +++ b/library/alloc/src/vec/mod.rs @@ -424,6 +424,7 @@ pub type CoVec; /// "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 = Vec; From 452bf1941c6fa7fc0ee8809f297b22dbc69360fb Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 21:09:48 -0800 Subject: [PATCH 50/80] CoAlloc: minor cleanup --- library/alloc/src/lib.rs | 6 ------ 1 file changed, 6 deletions(-) diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs index c8035bd295f58..64cde38960319 100644 --- a/library/alloc/src/lib.rs +++ b/library/alloc/src/lib.rs @@ -288,9 +288,3 @@ pub(crate) mod test_helpers { use crate::alloc::Global; -/// See also `core::alloc::co_alloc_metadata_num_slots_with_preference`. -#[unstable(feature = "global_co_alloc", issue = "none")] -pub const fn co_alloc_metadata_num_slots_with_preference_global(coop_preferred: bool) -> usize { - // FIXME or replace any calls with core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED). See raw_vec.rs. - if /*Global::IS_CO_ALLOCATOR*/ true && coop_preferred { 1 } else { 0 } -} From e8d07dff2bcb40f194fc1a784b9f9a9fb143cd37 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 21:10:07 -0800 Subject: [PATCH 51/80] CoAlloc: Vec: COOP_PREFERRED --- library/alloc/src/vec/spec_from_iter.rs | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/library/alloc/src/vec/spec_from_iter.rs b/library/alloc/src/vec/spec_from_iter.rs index 9ed63aceb77a0..2da172c8ea499 100644 --- a/library/alloc/src/vec/spec_from_iter.rs +++ b/library/alloc/src/vec/spec_from_iter.rs @@ -1,4 +1,5 @@ use core::alloc::{self, Allocator}; +use crate::alloc::Global; use core::mem::ManuallyDrop; use core::ptr::{self}; @@ -38,9 +39,9 @@ where } #[allow(unused_braces)] -impl SpecFromIter> for Vec +impl SpecFromIter> for Vec where -[(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +[(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn from_iter(iterator: IntoIter) -> Self { // A common case is passing a vector into a function which immediately @@ -62,7 +63,7 @@ where } } - let mut vec = Vec::new(); + let mut vec = Vec::::new(); // must delegate to spec_extend() since extend() itself delegates // to spec_from for empty Vecs vec.spec_extend(iterator); From ee2504b0e74f6fca433647df018ad6959ffd8d9e Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 21:11:33 -0800 Subject: [PATCH 52/80] CoAlloc: Vec: COOP_PREFERRED --- library/alloc/src/vec/in_place_collect.rs | 7 ++++--- library/alloc/src/vec/into_iter.rs | 2 +- library/alloc/src/vec/mod.rs | 6 +++--- library/alloc/src/vec/spec_from_iter.rs | 6 +++--- library/alloc/src/vec/spec_from_iter_nested.rs | 6 ++++-- 5 files changed, 15 insertions(+), 12 deletions(-) diff --git a/library/alloc/src/vec/in_place_collect.rs b/library/alloc/src/vec/in_place_collect.rs index 6d9e3b825c376..69f8ea9a61d3b 100644 --- a/library/alloc/src/vec/in_place_collect.rs +++ b/library/alloc/src/vec/in_place_collect.rs @@ -137,7 +137,8 @@ //! } //! vec.truncate(write_idx); //! ``` -use core::alloc::{self, Allocator}; +use core::alloc; +use crate::alloc::Global; use core::iter::{InPlaceIterable, SourceIter, TrustedRandomAccessNoCoerce}; use core::mem::{self, ManuallyDrop, SizedTypeProperties}; use core::ptr::{self}; @@ -152,10 +153,10 @@ pub(super) trait InPlaceIterableMarker {} impl InPlaceIterableMarker for T where T: InPlaceIterable {} #[allow(unused_braces)] -impl SpecFromIter for Vec +impl SpecFromIter for Vec where I: Iterator + SourceIter + InPlaceIterableMarker, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { default fn from_iter(mut iterator: I) -> Self { diff --git a/library/alloc/src/vec/into_iter.rs b/library/alloc/src/vec/into_iter.rs index 569cc61635296..9e54f6db5d34b 100644 --- a/library/alloc/src/vec/into_iter.rs +++ b/library/alloc/src/vec/into_iter.rs @@ -421,7 +421,7 @@ where { #[cfg(not(test))] fn clone(&self) -> Self { - self.as_slice().to_vec_in(self.alloc.deref().clone()).into_iter() + self.as_slice().to_vec_in::(self.alloc.deref().clone()).into_iter() } #[cfg(test)] fn clone(&self) -> Self { diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs index 7935a71008aae..b5b5836ee2101 100644 --- a/library/alloc/src/vec/mod.rs +++ b/library/alloc/src/vec/mod.rs @@ -2879,12 +2879,12 @@ where #[cfg(not(no_global_oom_handling))] #[stable(feature = "rust1", since = "1.0.0")] #[allow(unused_braces)] -impl FromIterator for Vec +impl FromIterator for Vec where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { #[inline] - fn from_iter>(iter: I) -> Vec { + fn from_iter>(iter: I) -> Vec { >::from_iter(iter.into_iter()) } } diff --git a/library/alloc/src/vec/spec_from_iter.rs b/library/alloc/src/vec/spec_from_iter.rs index 2da172c8ea499..6f414082ab292 100644 --- a/library/alloc/src/vec/spec_from_iter.rs +++ b/library/alloc/src/vec/spec_from_iter.rs @@ -1,4 +1,4 @@ -use core::alloc::{self, Allocator}; +use core::alloc; use crate::alloc::Global; use core::mem::ManuallyDrop; use core::ptr::{self}; @@ -28,10 +28,10 @@ pub(super) trait SpecFromIter { } #[allow(unused_braces)] -impl SpecFromIter for Vec +impl SpecFromIter for Vec where I: Iterator, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { default fn from_iter(iterator: I) -> Self { SpecFromIterNested::from_iter(iterator) diff --git a/library/alloc/src/vec/spec_from_iter_nested.rs b/library/alloc/src/vec/spec_from_iter_nested.rs index 7408155ff870a..bbfb9605a6d00 100644 --- a/library/alloc/src/vec/spec_from_iter_nested.rs +++ b/library/alloc/src/vec/spec_from_iter_nested.rs @@ -1,3 +1,4 @@ +use core::alloc; use core::cmp; use core::iter::TrustedLen; use core::ptr; @@ -16,9 +17,10 @@ pub(super) trait SpecFromIterNested { } #[allow(unused_braces)] -impl SpecFromIterNested for Vec +impl SpecFromIterNested for Vec where I: Iterator, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { default fn from_iter(mut iterator: I) -> Self { // Unroll the first iteration, as the vector is going to be @@ -43,7 +45,7 @@ where }; // must delegate to spec_extend() since extend() itself delegates // to spec_from for empty Vecs - as SpecExtend>::spec_extend(&mut vector, iterator); + as SpecExtend>::spec_extend(&mut vector, iterator); vector } } From 4185a1fe9f5237b3dd8e13956d3ecfaf33495289 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 21:11:42 -0800 Subject: [PATCH 53/80] CoAlloc: VecDeque: COOP_PREFERRED --- .../alloc/src/collections/vec_deque/mod.rs | 6 ++--- .../collections/vec_deque/spec_from_iter.rs | 26 +++++++++---------- 2 files changed, 16 insertions(+), 16 deletions(-) diff --git a/library/alloc/src/collections/vec_deque/mod.rs b/library/alloc/src/collections/vec_deque/mod.rs index af17728fed5c0..34f82acb166d4 100644 --- a/library/alloc/src/collections/vec_deque/mod.rs +++ b/library/alloc/src/collections/vec_deque/mod.rs @@ -2799,11 +2799,11 @@ where } #[stable(feature = "rust1", since = "1.0.0")] -impl FromIterator for VecDeque +impl FromIterator for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { - fn from_iter>(iter: I) -> VecDeque { + fn from_iter>(iter: I) -> VecDeque { SpecFromIter::spec_from_iter(iter.into_iter()) } } 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 450a64b792c5b..ecfe79799aa91 100644 --- a/library/alloc/src/collections/vec_deque/spec_from_iter.rs +++ b/library/alloc/src/collections/vec_deque/spec_from_iter.rs @@ -1,5 +1,5 @@ use super::{IntoIter, VecDeque}; -use crate::alloc::Allocator; +use crate::Global; use core::alloc; /// Specialization trait used for `VecDeque::from_iter` @@ -7,39 +7,39 @@ pub(super) trait SpecFromIter { fn spec_from_iter(iter: I) -> Self; } -impl SpecFromIter - for VecDeque +impl SpecFromIter + for VecDeque where I: Iterator, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(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::::from_iter(iterator).into() } } -impl SpecFromIter> - for VecDeque +impl SpecFromIter> + for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { #[inline] - fn spec_from_iter(iterator: crate::vec::IntoIter) -> Self { + fn spec_from_iter(iterator: crate::vec::IntoIter) -> Self { iterator.into_vecdeque() } } -impl SpecFromIter> - for VecDeque +impl SpecFromIter> + for VecDeque where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { #[inline] - fn spec_from_iter(iterator: IntoIter) -> Self { + fn spec_from_iter(iterator: IntoIter) -> Self { iterator.into_vecdeque() } } From 069376753212b8cda5cb8ea7c3fc5072baedd599 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 21:12:32 -0800 Subject: [PATCH 54/80] CoAlloc: library/alloc: minor cleanup --- library/alloc/src/lib.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs index 64cde38960319..bf68c9773e72d 100644 --- a/library/alloc/src/lib.rs +++ b/library/alloc/src/lib.rs @@ -286,5 +286,4 @@ pub(crate) mod test_helpers { rand::SeedableRng::from_seed(seed) } -use crate::alloc::Global; From f47ce34f8afe64bbe2ccfea5912e38dbed076fe0 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 21:13:28 -0800 Subject: [PATCH 55/80] CoAlloc: library/alloc: Re-added a closing curly bracket in mod test_helpers = Fixing my earlier merge mess up. --- library/alloc/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs index bf68c9773e72d..8e74717255203 100644 --- a/library/alloc/src/lib.rs +++ b/library/alloc/src/lib.rs @@ -285,5 +285,5 @@ pub(crate) mod test_helpers { let seed: [u8; 16] = seed_vec.as_slice().try_into().unwrap(); rand::SeedableRng::from_seed(seed) } - +} From 86f332d79e62bdb0e111ace81fce87220524685b Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 21:24:22 -0800 Subject: [PATCH 56/80] CoAlloc: Vec + slice: COOP_PREFERRED --- library/alloc/src/slice.rs | 7 +++++-- library/alloc/src/vec/spec_from_iter_nested.rs | 2 +- 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/library/alloc/src/slice.rs b/library/alloc/src/slice.rs index 832eb71ce110f..d214fb8b920e0 100644 --- a/library/alloc/src/slice.rs +++ b/library/alloc/src/slice.rs @@ -456,11 +456,14 @@ impl [T] { #[rustc_conversion_suggestion] #[stable(feature = "rust1", since = "1.0.0")] #[inline] - pub fn to_vec(&self) -> Vec + pub fn to_vec(&self) -> Vec where T: Clone, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::( + COOP_PREFERRED, + )]:, { - self.to_vec_in(Global) + self.to_vec_in::(Global) } /// Copies `self` into a new `Vec` with an allocator. diff --git a/library/alloc/src/vec/spec_from_iter_nested.rs b/library/alloc/src/vec/spec_from_iter_nested.rs index bbfb9605a6d00..3ccd2da20df49 100644 --- a/library/alloc/src/vec/spec_from_iter_nested.rs +++ b/library/alloc/src/vec/spec_from_iter_nested.rs @@ -4,7 +4,7 @@ use core::iter::TrustedLen; use core::ptr; use crate::raw_vec::RawVec; -use crate::Global; +use crate::alloc::Global; use crate::DEFAULT_COOP_PREFERRED; use super::{SpecExtend, Vec}; From e097c2f8afe4593d9165cf18b18549860e4c6c7f Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 21:25:06 -0800 Subject: [PATCH 57/80] CoAlloc: library/alloc/src/ffi: minor --- library/alloc/src/ffi/c_str.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/alloc/src/ffi/c_str.rs b/library/alloc/src/ffi/c_str.rs index dd2e6baab2776..15b06e787fc66 100644 --- a/library/alloc/src/ffi/c_str.rs +++ b/library/alloc/src/ffi/c_str.rs @@ -17,7 +17,7 @@ use core::ptr; use core::slice; use core::slice::memchr; use core::str::{self, Utf8Error}; -use crate::Global; +use crate::alloc::Global; use crate::DEFAULT_COOP_PREFERRED; #[cfg(target_has_atomic = "ptr")] From c146757682aec191994939fce129b25f3e248e79 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 21:25:35 -0800 Subject: [PATCH 58/80] CoAlloc: VecDeque: minor --- library/alloc/src/collections/vec_deque/spec_from_iter.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 ecfe79799aa91..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,5 +1,5 @@ use super::{IntoIter, VecDeque}; -use crate::Global; +use crate::alloc::Global; use core::alloc; /// Specialization trait used for `VecDeque::from_iter` From 6ec79e7a30b87e3c92b21cffefe99495bf9643bb Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 21:26:41 -0800 Subject: [PATCH 59/80] CoAlloc: Vec: COOP_PREFERRED --- library/alloc/src/vec/into_iter.rs | 12 +++++++++++- library/alloc/src/vec/splice.rs | 4 ++-- 2 files changed, 13 insertions(+), 3 deletions(-) diff --git a/library/alloc/src/vec/into_iter.rs b/library/alloc/src/vec/into_iter.rs index 9e54f6db5d34b..2ec439748f68a 100644 --- a/library/alloc/src/vec/into_iter.rs +++ b/library/alloc/src/vec/into_iter.rs @@ -131,7 +131,17 @@ where // 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::::NEW.ptr()) + if COOP_PREFERRED { + NonNull::new_unchecked(RawVec::::NEW.ptr()) + } else { + NonNull::new_unchecked(RawVec::::NEW.ptr()) + } + }; self.ptr = self.buf.as_ptr(); self.end = self.buf.as_ptr(); diff --git a/library/alloc/src/vec/splice.rs b/library/alloc/src/vec/splice.rs index 185f09be55287..96ca11edaf6a1 100644 --- a/library/alloc/src/vec/splice.rs +++ b/library/alloc/src/vec/splice.rs @@ -115,9 +115,9 @@ where } /// Private helper methods for `Splice::drop` -impl Drain<'_, T, A> +impl Drain<'_, T, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(true)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { /// The range from `self.vec.len` to `self.tail_start` contains elements /// that have been moved out. From cb22e2f6c45f16ecde538135dc1fbd05918a1bab Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 21:40:29 -0800 Subject: [PATCH 60/80] CoAlloc: Vec + Box: COOP_PREFERRED for various traits --- library/alloc/src/boxed.rs | 10 ++++++---- library/alloc/src/vec/into_iter.rs | 8 +++++++- library/alloc/src/vec/mod.rs | 4 ---- library/alloc/src/vec/splice.rs | 1 - 4 files changed, 13 insertions(+), 10 deletions(-) diff --git a/library/alloc/src/boxed.rs b/library/alloc/src/boxed.rs index 32277063ac0b0..3806d42973c86 100644 --- a/library/alloc/src/boxed.rs +++ b/library/alloc/src/boxed.rs @@ -780,10 +780,11 @@ where #[allow(unused_braces)] pub fn new_uninit_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit], A> where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(SHORT_TERM_VEC_PREFERS_COOP!())]:, + // 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::(false)]:, { unsafe { - RawVec::::with_capacity_in(len, alloc) + RawVec::::with_capacity_in(len, alloc) .into_box(len) } } @@ -815,10 +816,11 @@ where #[allow(unused_braces)] pub fn new_zeroed_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit], A> where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(SHORT_TERM_VEC_PREFERS_COOP!())]:, + // 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::(false)]:, { unsafe { - RawVec::::with_capacity_zeroed_in( + RawVec::::with_capacity_zeroed_in( len, alloc, ) .into_box(len) diff --git a/library/alloc/src/vec/into_iter.rs b/library/alloc/src/vec/into_iter.rs index 2ec439748f68a..f4d5676f01e55 100644 --- a/library/alloc/src/vec/into_iter.rs +++ b/library/alloc/src/vec/into_iter.rs @@ -431,7 +431,13 @@ where { #[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 = slice.to_vec_in::(self.alloc.deref().clone()); + let _iter: IntoIter = vec.into_iter(); + + //self.as_slice().to_vec_in::(self.alloc.deref().clone()).into_iter() + loop {} } #[cfg(test)] fn clone(&self) -> Self { diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs index b5b5836ee2101..22721680e7522 100644 --- a/library/alloc/src/vec/mod.rs +++ b/library/alloc/src/vec/mod.rs @@ -2065,8 +2065,6 @@ where pub fn drain(&mut self, range: R) -> Drain<'_, T, A, COOP_PREFERRED> where R: RangeBounds, - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(SHORT_TERM_VEC_PREFERS_COOP!())]:, - { // Memory safety // @@ -2893,8 +2891,6 @@ where impl IntoIterator for Vec where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(SHORT_TERM_VEC_PREFERS_COOP!())]:, - { type Item = T; type IntoIter = IntoIter; diff --git a/library/alloc/src/vec/splice.rs b/library/alloc/src/vec/splice.rs index 96ca11edaf6a1..92fcaf4382dca 100644 --- a/library/alloc/src/vec/splice.rs +++ b/library/alloc/src/vec/splice.rs @@ -26,7 +26,6 @@ pub struct Splice< const COOP_PREFERRED: bool = false > where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, - //FIXME: If using SHORT_TERM_VEC_PREFERS_COOP!() instead of true, and the same for `drain` below, then this failed with: `derive` cannot be used on item swith type macros { pub(super) drain: Drain<'a, I::Item, A, COOP_PREFERRED>, pub(super) replace_with: I, From d74d5be927f5b573a5a7a707b0366b85825623e8 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 21:41:00 -0800 Subject: [PATCH 61/80] CoAlloc: VecDeque: minor cleanup --- library/alloc/src/collections/vec_deque/mod.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/library/alloc/src/collections/vec_deque/mod.rs b/library/alloc/src/collections/vec_deque/mod.rs index 34f82acb166d4..3a64f52ffb925 100644 --- a/library/alloc/src/collections/vec_deque/mod.rs +++ b/library/alloc/src/collections/vec_deque/mod.rs @@ -1406,7 +1406,6 @@ where pub fn drain(&mut self, range: R) -> Drain<'_, T, A, COOP_PREFERRED> where R: RangeBounds, - [(); alloc::co_alloc_metadata_num_slots_with_preference::(SHORT_TERM_VEC_PREFERS_COOP!())]:, { // Memory safety // From df419ce655173b7cd24ad73f736c44f3a8485a0a Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Thu, 12 Jan 2023 17:35:21 -0800 Subject: [PATCH 62/80] CoVec, PlVec, DefVec, WeVec. Cleanup. --- library/alloc/src/vec/mod.rs | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs index 22721680e7522..97d1845171937 100644 --- a/library/alloc/src/vec/mod.rs +++ b/library/alloc/src/vec/mod.rs @@ -419,14 +419,15 @@ pub struct Vec< len: usize, } +/// "Cooperative" Vector. Preferring co-alloc API (if Global alloc supports it). #[unstable(feature = "global_co_alloc_covec", issue = "none")] -pub type CoVec = +pub type CoVec = Vec; /// "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 = +pub type PlVec = Vec; /// "Default" Vec. Either "cooperative" or not - as specified by `DEFAULT_COOP_PREFERRED`. The @@ -434,14 +435,14 @@ pub type PlVec = +pub type DefVec = Vec; /// "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 = Vec 127 }>; +pub type WeVec = Vec 127 }>; //////////////////////////////////////////////////////////////////////////////// // Inherent methods From a3c765eb26d3a5eed141a667a14faf9958e1b709 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Sun, 22 Jan 2023 21:46:08 -0800 Subject: [PATCH 63/80] CoAlloc: Vec: added new_co() --- library/alloc/src/macros.rs | 2 +- library/alloc/src/vec/mod.rs | 30 +++++++++++++------ library/alloc/src/vec/spec_from_iter.rs | 2 +- .../alloc/src/vec/spec_from_iter_nested.rs | 2 +- 4 files changed, 24 insertions(+), 12 deletions(-) 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/vec/mod.rs b/library/alloc/src/vec/mod.rs index 97d1845171937..6abf1d820ec1a 100644 --- a/library/alloc/src/vec/mod.rs +++ b/library/alloc/src/vec/mod.rs @@ -444,14 +444,7 @@ pub type DefVec = #[unstable(feature = "global_co_alloc_vec", issue = "none")] pub type WeVec = Vec 127 }>; -//////////////////////////////////////////////////////////////////////////////// -// Inherent methods -//////////////////////////////////////////////////////////////////////////////// - -impl Vec -where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, -{ +impl Vec { /// Constructs a new, empty `Vec`. /// /// The vector will not allocate until elements are pushed onto it. @@ -467,6 +460,25 @@ where #[stable(feature = "rust1", since = "1.0.0")] #[must_use] pub const fn new() -> Self { + #[allow(unused_braces)] + Vec::::new_co() + } +} + +//////////////////////////////////////////////////////////////////////////////// +// Inherent methods +//////////////////////////////////////////////////////////////////////////////// + +impl Vec +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(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 } } @@ -3242,7 +3254,7 @@ where /// /// The vector will not allocate until elements are pushed onto it. fn default() -> Vec { - Vec::new() + Vec::new_co() } } diff --git a/library/alloc/src/vec/spec_from_iter.rs b/library/alloc/src/vec/spec_from_iter.rs index 6f414082ab292..e0befdb22962d 100644 --- a/library/alloc/src/vec/spec_from_iter.rs +++ b/library/alloc/src/vec/spec_from_iter.rs @@ -63,7 +63,7 @@ where } } - let mut vec = Vec::::new(); + let mut vec = Vec::::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 3ccd2da20df49..ff774e4534bf7 100644 --- a/library/alloc/src/vec/spec_from_iter_nested.rs +++ b/library/alloc/src/vec/spec_from_iter_nested.rs @@ -29,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 = From 86d380abe6c36fcad1343599adff1c2fa7e6ed20 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Mon, 23 Jan 2023 07:28:43 -0800 Subject: [PATCH 64/80] CoAlloc: std/src/lib.rs: minor --- library/std/src/lib.rs | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs index 99cc018631048..919e43805f08d 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)] From 94f4fddc30a153766e33b1a76b0fa1ab850bcfed Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Mon, 23 Jan 2023 07:31:07 -0800 Subject: [PATCH 65/80] CoAlloc: FFI: minor --- library/std/src/ffi/os_str.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/library/std/src/ffi/os_str.rs b/library/std/src/ffi/os_str.rs index 80ed34157e6dc..6ab6323e19c83 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; From 9d808d1e1c97f1f0f1ed417263ffac9e699bccfa Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Mon, 23 Jan 2023 07:31:32 -0800 Subject: [PATCH 66/80] CoAlloc: VecDeque (io::Read + io::Write for VecDeque): minor --- library/std/src/io/impls.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/library/std/src/io/impls.rs b/library/std/src/io/impls.rs index 8671ebf5c8141..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; @@ -419,7 +419,7 @@ where #[stable(feature = "vecdeque_read_write", since = "1.63.0")] impl Read for VecDeque where - [(); co_alloc_metadata_num_slots_with_preference::(_COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(_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 @@ -446,7 +446,7 @@ where #[stable(feature = "vecdeque_read_write", since = "1.63.0")] impl Write for VecDeque where - [(); co_alloc_metadata_num_slots_with_preference::(_COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(_COOP_PREFERRED)]:, { #[inline] fn write(&mut self, buf: &[u8]) -> io::Result { From 3059f6077cccf90f83ae14a8a97b2da4594e6e69 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Mon, 23 Jan 2023 07:32:16 -0800 Subject: [PATCH 67/80] CoAlloc: sys ... thread dtor: minor --- library/std/src/sys/unix/thread_local_dtor.rs | 12 +++++++++--- library/std/src/sys_common/thread_local_dtor.rs | 1 - 2 files changed, 9 insertions(+), 4 deletions(-) diff --git a/library/std/src/sys/unix/thread_local_dtor.rs b/library/std/src/sys/unix/thread_local_dtor.rs index 37e5571a7cd45..3ea3f6b0f453e 100644 --- a/library/std/src/sys/unix/thread_local_dtor.rs +++ b/library/std/src/sys/unix/thread_local_dtor.rs @@ -1,12 +1,9 @@ #![cfg(target_thread_local)] #![unstable(feature = "thread_local_internals", issue = "none")] -#![feature(global_co_alloc_plvec)] //! Provides thread-local destructors without an associated "key", which //! can be more efficient. -use core::alloc::PlVec; - // Since what appears to be glibc 2.18 this symbol has been shipped which // GCC and clang both use to invoke destructors in thread_local globals, so // let's do the same! @@ -74,6 +71,15 @@ pub unsafe fn register_dtor(t: *mut u8, dtor: unsafe extern "C" fn(*mut u8)) { REGISTERED.set(true); } + type List = alloc::vec::PlVec<(*mut u8, unsafe extern "C" fn(*mut u8))>; + + #[thread_local] + static DTORS: Cell<*mut List> = Cell::new(ptr::null_mut()); + if DTORS.get().is_null() { + let v: Box = box Vec::new(); + DTORS.set(Box::into_raw(v)); + } + extern "C" { fn _tlv_atexit(dtor: unsafe extern "C" fn(*mut u8), arg: *mut u8); } diff --git a/library/std/src/sys_common/thread_local_dtor.rs b/library/std/src/sys_common/thread_local_dtor.rs index 43b7b0bb00468..6ec2f3cd11601 100644 --- a/library/std/src/sys_common/thread_local_dtor.rs +++ b/library/std/src/sys_common/thread_local_dtor.rs @@ -12,7 +12,6 @@ #![unstable(feature = "thread_local_internals", issue = "none")] #![allow(dead_code)] -#![feature(global_co_alloc_plvec)] use crate::ptr; use crate::sys_common::thread_local_key::StaticKey; From da31fd7de4024607a48aa1b4e209a5f37331d194 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Mon, 23 Jan 2023 07:33:36 -0800 Subject: [PATCH 68/80] CoAlloc: alloc: minor --- library/alloc/src/lib.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs index 8e74717255203..b41f5045069bd 100644 --- a/library/alloc/src/lib.rs +++ b/library/alloc/src/lib.rs @@ -191,6 +191,7 @@ // - cannot specialize on predicate `[(); _] well-formed` // - cannot specialize on predicate `the constant `core::alloc::co_alloc_metadata_num_slots::()` can be evaluated` //#![feature(min_specialization)] +#![feature(associated_type_defaults)] #![feature(specialization)] #![feature(negative_impls)] #![feature(never_type)] From 36cb2848c74035084ecda66f8939ee9afc83acca Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Mon, 23 Jan 2023 10:02:48 -0800 Subject: [PATCH 69/80] CoAlloc: library/core: tidy --- library/core/src/alloc/mod.rs | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/library/core/src/alloc/mod.rs b/library/core/src/alloc/mod.rs index ae4bad73a98ae..c0d2af6098378 100644 --- a/library/core/src/alloc/mod.rs +++ b/library/core/src/alloc/mod.rs @@ -84,7 +84,9 @@ pub struct SliceAndMeta { //pub const SHORT_TERM_VEC_PREFERS_COOP: bool = true; #[macro_export] macro_rules! SHORT_TERM_VEC_PREFERS_COOP { - () => {true} + () => { + true + }; } #[unstable(feature = "global_co_alloc_meta", issue = "none")] @@ -95,7 +97,9 @@ pub type SliceAndMetaResult = Result; pub const fn co_alloc_metadata_num_slots() -> 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."); + 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 } } From bc9bdc8f213482f3fe30f9a9a313c2d652c193bc Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Mon, 23 Jan 2023 10:03:51 -0800 Subject: [PATCH 70/80] CoAlloc: library/proc_macro: tidy --- library/proc_macro/src/bridge/rpc.rs | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/library/proc_macro/src/bridge/rpc.rs b/library/proc_macro/src/bridge/rpc.rs index c50eb9c620626..1c39e29ed1b43 100644 --- a/library/proc_macro/src/bridge/rpc.rs +++ b/library/proc_macro/src/bridge/rpc.rs @@ -234,7 +234,9 @@ impl> Encode for Vec { } } -impl<'a, S, T: for<'s> DecodeMut<'a, 's, S>> DecodeMut<'a, '_, S> for Vec { +impl<'a, S, T: for<'s> DecodeMut<'a, 's, S>> DecodeMut<'a, '_, S> + for Vec +{ fn decode(r: &mut Reader<'a>, s: &mut S) -> Self { let len = usize::decode(r, s); let mut vec = Vec::with_capacity(len); From 1a84ad6e281ee37a573a08e3c27c10b552874936 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Mon, 23 Jan 2023 11:05:50 -0800 Subject: [PATCH 71/80] CoAlloc: Vec, Box + related slice.rs: tidy --- library/alloc/src/boxed.rs | 20 +--- library/alloc/src/lib.rs | 1 - library/alloc/src/raw_vec.rs | 6 +- library/alloc/src/slice.rs | 110 +++++++----------- library/alloc/src/vec/in_place_collect.rs | 3 +- library/alloc/src/vec/in_place_drop.rs | 2 +- library/alloc/src/vec/into_iter.rs | 3 +- library/alloc/src/vec/mod.rs | 59 +++++----- library/alloc/src/vec/spec_from_iter.rs | 4 +- .../alloc/src/vec/spec_from_iter_nested.rs | 4 +- library/alloc/src/vec/splice.rs | 17 ++- 11 files changed, 99 insertions(+), 130 deletions(-) diff --git a/library/alloc/src/boxed.rs b/library/alloc/src/boxed.rs index 3806d42973c86..1daba5600696a 100644 --- a/library/alloc/src/boxed.rs +++ b/library/alloc/src/boxed.rs @@ -780,13 +780,10 @@ where #[allow(unused_braces)] pub fn new_uninit_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit], 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::(false)]:, + // 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::(false)]:, { - unsafe { - RawVec::::with_capacity_in(len, alloc) - .into_box(len) - } + unsafe { RawVec::::with_capacity_in(len, alloc).into_box(len) } } /// Constructs a new boxed slice with uninitialized contents in the provided allocator, @@ -816,15 +813,10 @@ where #[allow(unused_braces)] pub fn new_zeroed_slice_in(len: usize, alloc: A) -> Box<[mem::MaybeUninit], 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::(false)]:, + // 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::(false)]:, { - unsafe { - RawVec::::with_capacity_zeroed_in( - len, alloc, - ) - .into_box(len) - } + unsafe { RawVec::::with_capacity_zeroed_in(len, alloc).into_box(len) } } } diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs index b41f5045069bd..1166411f2c642 100644 --- a/library/alloc/src/lib.rs +++ b/library/alloc/src/lib.rs @@ -287,4 +287,3 @@ pub(crate) mod test_helpers { rand::SeedableRng::from_seed(seed) } } - diff --git a/library/alloc/src/raw_vec.rs b/library/alloc/src/raw_vec.rs index cb0cb4216a5a9..c3562e167a5bc 100644 --- a/library/alloc/src/raw_vec.rs +++ b/library/alloc/src/raw_vec.rs @@ -54,7 +54,7 @@ enum AllocInit { pub(crate) struct RawVec< T, A: Allocator = Global, - const COOP_PREFERRED: bool = {DEFAULT_COOP_PREFERRED!()}, + const COOP_PREFERRED: bool = { DEFAULT_COOP_PREFERRED!() }, > where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { @@ -223,9 +223,7 @@ where cap: capacity, alloc, metas: [GlobalCoAllocMeta {/*one: 1*/ /*, two: 2, three: 3, four: 4*/}; - alloc::co_alloc_metadata_num_slots_with_preference::( - COOP_PREFERRED, - )], + alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)], } } } diff --git a/library/alloc/src/slice.rs b/library/alloc/src/slice.rs index d214fb8b920e0..bcdc5ff91e26e 100644 --- a/library/alloc/src/slice.rs +++ b/library/alloc/src/slice.rs @@ -101,9 +101,7 @@ pub(crate) mod hack { b: Box<[T], A>, ) -> Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::( - COOP_PREFERRED, - )]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { unsafe { let len = b.len(); @@ -119,9 +117,7 @@ pub(crate) mod hack { alloc: A, ) -> Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::( - COOP_PREFERRED, - )]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { T::to_vec(s, alloc) } @@ -134,9 +130,7 @@ pub(crate) mod hack { ) -> Vec where Self: Sized, - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::( - COOP_PREFERRED, - )]:; + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:; } #[cfg(not(no_global_oom_handling))] @@ -147,24 +141,18 @@ pub(crate) mod hack { alloc: A, ) -> Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::( - COOP_PREFERRED, - )]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { struct DropGuard<'a, T, A: Allocator, const COOP_PREFERRED: bool> where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::( - COOP_PREFERRED, - )]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { vec: &'a mut Vec, num_init: usize, } 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::( - COOP_PREFERRED, - )]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { #[inline] fn drop(&mut self) { @@ -202,9 +190,7 @@ pub(crate) mod hack { alloc: A, ) -> Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::( - COOP_PREFERRED, - )]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { let mut v = Vec::with_capacity_in(s.len(), alloc); // SAFETY: @@ -459,9 +445,7 @@ impl [T] { pub fn to_vec(&self) -> Vec where T: Clone, - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::( - COOP_PREFERRED, - )]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { self.to_vec_in::(Global) } @@ -489,9 +473,7 @@ impl [T] { ) -> Vec where T: Clone, - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::( - COOP_PREFERRED, - )]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { // N.B., see the `hack` module in this file for more details. hack::to_vec(self, alloc) @@ -518,9 +500,7 @@ impl [T] { self: Box, ) -> Vec where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::( - COOP_PREFERRED, - )]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { // N.B., see the `hack` module in this file for more details. hack::into_vec(self) @@ -914,48 +894,48 @@ where } }; -//<<<<<<< HEAD + //<<<<<<< HEAD let run_alloc_fn = |len: usize| -> *mut sort::TimSortRun { // SAFETY: Creating the layout is safe as long as merge_sort never calls this with an // obscene length or 0. unsafe { alloc::alloc(alloc::Layout::array::(len).unwrap_unchecked()) as *mut sort::TimSortRun -/*======= - // Allocate a buffer to use as scratch memory. We keep the length 0 so we can keep in it - // 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`. - // `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::::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. - // `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. - let mut start = end - 1; - if start > 0 { - start -= 1; - unsafe { - if is_less(v.get_unchecked(start + 1), v.get_unchecked(start)) { - while start > 0 && is_less(v.get_unchecked(start), v.get_unchecked(start - 1)) { - start -= 1; - } - v[start..end].reverse(); - } else { - while start > 0 && !is_less(v.get_unchecked(start), v.get_unchecked(start - 1)) - { + /*======= + // Allocate a buffer to use as scratch memory. We keep the length 0 so we can keep in it + // 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`. + // `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::::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. + // `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. + let mut start = end - 1; + if start > 0 { start -= 1; - } - } - } ->>>>>>> 6bd68177557 (CoAlloc: Slice: Fixing COOP_PREFERRED)*/ + unsafe { + if is_less(v.get_unchecked(start + 1), v.get_unchecked(start)) { + while start > 0 && is_less(v.get_unchecked(start), v.get_unchecked(start - 1)) { + start -= 1; + } + v[start..end].reverse(); + } else { + while start > 0 && !is_less(v.get_unchecked(start), v.get_unchecked(start - 1)) + { + start -= 1; + } + } + } + >>>>>>> 6bd68177557 (CoAlloc: Slice: Fixing COOP_PREFERRED)*/ } }; diff --git a/library/alloc/src/vec/in_place_collect.rs b/library/alloc/src/vec/in_place_collect.rs index 69f8ea9a61d3b..3afbc754061c0 100644 --- a/library/alloc/src/vec/in_place_collect.rs +++ b/library/alloc/src/vec/in_place_collect.rs @@ -137,8 +137,8 @@ //! } //! vec.truncate(write_idx); //! ``` -use core::alloc; use crate::alloc::Global; +use core::alloc; use core::iter::{InPlaceIterable, SourceIter, TrustedRandomAccessNoCoerce}; use core::mem::{self, ManuallyDrop, SizedTypeProperties}; use core::ptr::{self}; @@ -157,7 +157,6 @@ impl SpecFromIter for Vec + SourceIter + InPlaceIterableMarker, [(); alloc::co_alloc_metadata_num_slots_with_preference::(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 871fd08b1f6b1..bf2d004e9db39 100644 --- a/library/alloc/src/vec/in_place_drop.rs +++ b/library/alloc/src/vec/in_place_drop.rs @@ -1,6 +1,6 @@ +use crate::alloc::Global; 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. diff --git a/library/alloc/src/vec/into_iter.rs b/library/alloc/src/vec/into_iter.rs index f4d5676f01e55..3555c64af9f8e 100644 --- a/library/alloc/src/vec/into_iter.rs +++ b/library/alloc/src/vec/into_iter.rs @@ -433,7 +433,8 @@ where fn clone(&self) -> Self { // @FIXME Remove the following extras - used for type checks only let slice = self.as_slice(); - let vec: crate::vec::Vec = slice.to_vec_in::(self.alloc.deref().clone()); + let vec: crate::vec::Vec = + slice.to_vec_in::(self.alloc.deref().clone()); let _iter: IntoIter = vec.into_iter(); //self.as_slice().to_vec_in::(self.alloc.deref().clone()).into_iter() diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs index 6abf1d820ec1a..1a19a7a1e547b 100644 --- a/library/alloc/src/vec/mod.rs +++ b/library/alloc/src/vec/mod.rs @@ -154,7 +154,9 @@ mod spec_extend; // pub const DEFAULT_COOP_PREFERRED: bool = true; #[macro_export] macro_rules! DEFAULT_COOP_PREFERRED { - () => {true} + () => { + true + }; } /// A contiguous growable array type, written as `Vec`, short for 'vector'. @@ -411,7 +413,7 @@ 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!()}, + const COOP_PREFERRED: bool = { DEFAULT_COOP_PREFERRED!() }, > where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { @@ -421,22 +423,19 @@ pub struct Vec< /// "Cooperative" Vector. Preferring co-alloc API (if Global alloc supports it). #[unstable(feature = "global_co_alloc_covec", issue = "none")] -pub type CoVec = - Vec; +pub type CoVec = Vec; /// "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 = - Vec; +pub type PlVec = Vec; /// "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 = - Vec; +pub type DefVec = Vec; /// "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). @@ -461,7 +460,7 @@ impl Vec { #[must_use] pub const fn new() -> Self { #[allow(unused_braces)] - Vec::::new_co() + Vec::::new_co() } } @@ -1668,9 +1667,7 @@ where // In cases when predicate and `drop` never panick, it will be optimized out. struct BackshiftOnDrop<'a, T, A: Allocator, const VEC_IS_COOP: bool = true> where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::( - VEC_IS_COOP, - )]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(VEC_IS_COOP)]:, { v: &'a mut Vec, processed_len: usize, @@ -1680,9 +1677,7 @@ where impl Drop for BackshiftOnDrop<'_, T, A, VEC_IS_COOP> where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::( - VEC_IS_COOP, - )]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(VEC_IS_COOP)]:, { fn drop(&mut self) { if self.deleted_cnt > 0 { @@ -1715,9 +1710,7 @@ where g: &mut BackshiftOnDrop<'_, T, A, VEC_IS_COOP>, ) where F: FnMut(&mut T) -> bool, - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::( - VEC_IS_COOP, - )]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(VEC_IS_COOP)]:, { while g.processed_len != original_len { // SAFETY: Unchecked element must be valid. @@ -1812,9 +1805,7 @@ where /* INVARIANT: vec.len() > read >= write > write-1 >= 0 */ struct FillGapOnDrop<'a, T, A: core::alloc::Allocator, const COOP_PREFERRED: bool> where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::( - COOP_PREFERRED, - )]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { /* Offset of the element we want to check if it is duplicate */ read: usize, @@ -1830,9 +1821,7 @@ where 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::( - COOP_PREFERRED, - )]:, + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn drop(&mut self) { /* This code gets executed when `same_bucket` panics */ @@ -2572,7 +2561,9 @@ where // - `new_cap` refers to the same sized allocation as `cap` because // `new_cap * size_of::()` == `cap * size_of::<[T; N]>()` // - `len` <= `cap`, so `len * N` <= `cap * N`. - unsafe { Vec::::from_raw_parts_in(ptr.cast(), new_len, new_cap, alloc) } + unsafe { + Vec::::from_raw_parts_in(ptr.cast(), new_len, new_cap, alloc) + } } } @@ -2893,7 +2884,7 @@ where impl FromIterator for Vec where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, - { +{ #[inline] fn from_iter>(iter: I) -> Vec { >::from_iter(iter.into_iter()) @@ -3098,7 +3089,11 @@ where #[cfg(not(no_global_oom_handling))] #[inline] #[stable(feature = "vec_splice", since = "1.21.0")] - pub fn splice(&mut self, range: R, replace_with: I) -> Splice<'_, I::IntoIter, A, COOP_PREFERRED> + pub fn splice( + &mut self, + range: R, + replace_with: I, + ) -> Splice<'_, I::IntoIter, A, COOP_PREFERRED> where R: RangeBounds, I: IntoIterator, @@ -3314,7 +3309,7 @@ where #[cfg(not(no_global_oom_handling))] #[stable(feature = "rust1", since = "1.0.0")] #[allow(unused_braces)] -impl From<&[T]> for Vec { +impl From<&[T]> for Vec { /// Allocate a `Vec` and fill it by cloning `s`'s items. /// /// # Examples @@ -3335,7 +3330,7 @@ impl From<&[T]> for Vec { #[cfg(not(no_global_oom_handling))] #[stable(feature = "vec_from_mut", since = "1.19.0")] #[allow(unused_braces)] -impl From<&mut [T]> for Vec { +impl From<&mut [T]> for Vec { /// Allocate a `Vec` and fill it by cloning `s`'s items. /// /// # Examples @@ -3356,7 +3351,7 @@ impl From<&mut [T]> for Vec { #[cfg(not(no_global_oom_handling))] #[stable(feature = "vec_from_array", since = "1.44.0")] #[allow(unused_braces)] -impl From<[T; N]> for Vec { +impl From<[T; N]> for Vec { /// Allocate a `Vec` and move `s`'s items into it. /// /// # Examples @@ -3380,7 +3375,7 @@ impl From<[T; N]> for Vec From> for Vec +impl<'a, T> From> for Vec where [T]: ToOwned>, { @@ -3458,7 +3453,7 @@ where #[cfg(not(no_global_oom_handling))] #[stable(feature = "rust1", since = "1.0.0")] #[allow(unused_braces)] -impl From<&str> for Vec { +impl From<&str> for Vec { /// Allocate a `Vec` and fill it with a UTF-8 string. /// /// # Examples diff --git a/library/alloc/src/vec/spec_from_iter.rs b/library/alloc/src/vec/spec_from_iter.rs index e0befdb22962d..e5d790878aabb 100644 --- a/library/alloc/src/vec/spec_from_iter.rs +++ b/library/alloc/src/vec/spec_from_iter.rs @@ -1,5 +1,5 @@ -use core::alloc; use crate::alloc::Global; +use core::alloc; use core::mem::ManuallyDrop; use core::ptr::{self}; @@ -41,7 +41,7 @@ where #[allow(unused_braces)] impl SpecFromIter> for Vec where -[(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { fn from_iter(iterator: IntoIter) -> Self { // A common case is passing a vector into a function which immediately diff --git a/library/alloc/src/vec/spec_from_iter_nested.rs b/library/alloc/src/vec/spec_from_iter_nested.rs index ff774e4534bf7..b71e86e83ba5a 100644 --- a/library/alloc/src/vec/spec_from_iter_nested.rs +++ b/library/alloc/src/vec/spec_from_iter_nested.rs @@ -3,8 +3,8 @@ use core::cmp; use core::iter::TrustedLen; use core::ptr; -use crate::raw_vec::RawVec; use crate::alloc::Global; +use crate::raw_vec::RawVec; use crate::DEFAULT_COOP_PREFERRED; use super::{SpecExtend, Vec}; @@ -51,7 +51,7 @@ where } #[allow(unused_braces)] -impl SpecFromIterNested for Vec +impl SpecFromIterNested for Vec where I: TrustedLen, { diff --git a/library/alloc/src/vec/splice.rs b/library/alloc/src/vec/splice.rs index 92fcaf4382dca..acf5553c9cfb4 100644 --- a/library/alloc/src/vec/splice.rs +++ b/library/alloc/src/vec/splice.rs @@ -23,7 +23,7 @@ pub struct Splice< 'a, I: Iterator + 'a, #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator + 'a = Global, - const COOP_PREFERRED: bool = false + const COOP_PREFERRED: bool = false, > where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { @@ -32,7 +32,8 @@ pub struct Splice< } #[stable(feature = "vec_splice", since = "1.21.0")] -impl Iterator for Splice<'_, I, A, COOP_PREFERRED> +impl Iterator + for Splice<'_, I, A, COOP_PREFERRED> where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { @@ -48,7 +49,8 @@ where } #[stable(feature = "vec_splice", since = "1.21.0")] -impl DoubleEndedIterator for Splice<'_, I, A, COOP_PREFERRED> +impl DoubleEndedIterator + for Splice<'_, I, A, COOP_PREFERRED> where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { @@ -58,13 +60,16 @@ where } #[stable(feature = "vec_splice", since = "1.21.0")] -impl ExactSizeIterator for Splice<'_, I, A, COOP_PREFERRED> where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: +impl ExactSizeIterator + for Splice<'_, I, A, COOP_PREFERRED> +where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { } #[stable(feature = "vec_splice", since = "1.21.0")] -impl Drop for Splice<'_, I, A, COOP_PREFERRED> +impl Drop + for Splice<'_, I, A, COOP_PREFERRED> where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { From eb83abaaa2452cdd8e455602239827d870596775 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Mon, 23 Jan 2023 12:22:54 -0800 Subject: [PATCH 72/80] CoAlloc: std: minor tidy --- library/std/src/io/impls.rs | 2 +- library/std/src/sys/hermit/thread_local_dtor.rs | 2 +- library/std/src/sys/solid/thread_local_dtor.rs | 3 ++- 3 files changed, 4 insertions(+), 3 deletions(-) diff --git a/library/std/src/io/impls.rs b/library/std/src/io/impls.rs index 64efd793b8c20..02cd7aa0d2cc0 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, self}; +use crate::alloc::{self, Allocator}; use crate::cmp; use crate::collections::VecDeque; use crate::fmt; diff --git a/library/std/src/sys/hermit/thread_local_dtor.rs b/library/std/src/sys/hermit/thread_local_dtor.rs index 9816a7f200b6f..09b2df46a0f29 100644 --- a/library/std/src/sys/hermit/thread_local_dtor.rs +++ b/library/std/src/sys/hermit/thread_local_dtor.rs @@ -6,8 +6,8 @@ // The this solution works like the implementation of macOS and // doesn't additional OS support -use core::alloc::PlVec; use crate::mem; +use core::alloc::PlVec; #[thread_local] static mut DTORS: PlVec<(*mut u8, unsafe extern "C" fn(*mut u8))> = PlVec::new(); diff --git a/library/std/src/sys/solid/thread_local_dtor.rs b/library/std/src/sys/solid/thread_local_dtor.rs index 5468264393b55..59263cd41c761 100644 --- a/library/std/src/sys/solid/thread_local_dtor.rs +++ b/library/std/src/sys/solid/thread_local_dtor.rs @@ -1,5 +1,6 @@ #![cfg(target_thread_local)] -#![unstable(feature = "thread_local_internals", issue = "none")]#![feature(global_co_alloc_plvec)] +#![unstable(feature = "thread_local_internals", issue = "none")] +#![feature(global_co_alloc_plvec)] #![feature(global_co_alloc_plvec)] // Simplify dtor registration by using a list of destructors. From 374e144016bd3d8ed9355dfbe446ec858f5e0d37 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Mon, 23 Jan 2023 12:23:11 -0800 Subject: [PATCH 73/80] CoAlloc: VecDeque: tidy --- .../src/collections/vec_deque/into_iter.rs | 17 ++++++---- .../alloc/src/collections/vec_deque/mod.rs | 32 +++++++++---------- .../collections/vec_deque/spec_from_iter.rs | 3 +- 3 files changed, 27 insertions(+), 25 deletions(-) diff --git a/library/alloc/src/collections/vec_deque/into_iter.rs b/library/alloc/src/collections/vec_deque/into_iter.rs index 38aba07585a90..d144942cd5617 100644 --- a/library/alloc/src/collections/vec_deque/into_iter.rs +++ b/library/alloc/src/collections/vec_deque/into_iter.rs @@ -38,7 +38,8 @@ where } #[stable(feature = "collection_debug", since = "1.17.0")] -impl fmt::Debug for IntoIter +impl fmt::Debug + for IntoIter where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { @@ -67,7 +68,8 @@ where } #[stable(feature = "rust1", since = "1.0.0")] -impl DoubleEndedIterator for IntoIter +impl DoubleEndedIterator + for IntoIter where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { @@ -78,7 +80,8 @@ where } #[stable(feature = "rust1", since = "1.0.0")] -impl ExactSizeIterator for IntoIter +impl ExactSizeIterator + for IntoIter where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { @@ -88,14 +91,14 @@ where } #[stable(feature = "fused", since = "1.26.0")] -impl FusedIterator for IntoIter -where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +impl FusedIterator for IntoIter where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: { } #[unstable(feature = "trusted_len", issue = "37572")] -unsafe impl TrustedLen for IntoIter +unsafe impl TrustedLen + for IntoIter where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { diff --git a/library/alloc/src/collections/vec_deque/mod.rs b/library/alloc/src/collections/vec_deque/mod.rs index 3a64f52ffb925..e46a13e204b9a 100644 --- a/library/alloc/src/collections/vec_deque/mod.rs +++ b/library/alloc/src/collections/vec_deque/mod.rs @@ -97,7 +97,7 @@ mod tests; pub struct VecDeque< T, #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global, - const COOP_PREFERRED: bool = {DEFAULT_COOP_PREFERRED!()}, + const COOP_PREFERRED: bool = { DEFAULT_COOP_PREFERRED!() }, > where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { @@ -570,7 +570,8 @@ where #[rustc_const_stable(feature = "const_vec_deque_new", since = "CURRENT_RUSTC_VERSION")] #[must_use] pub const fn new() -> VecDeque - where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + where + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { // FIXME: This should just be `VecDeque::new_in(Global)` once that hits stable. VecDeque { head: 0, len: 0, buf: RawVec::NEW } @@ -2903,13 +2904,11 @@ where } #[stable(feature = "vecdeque_vec_conversions", since = "1.10.0")] -impl From> - for VecDeque +impl + From> for VecDeque where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, - [(); alloc::co_alloc_metadata_num_slots_with_preference::( - OTHER_COOP_PREFERRED, - )]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(OTHER_COOP_PREFERRED)]:, { /// Turn a [`Vec`] into a [`VecDeque`]. /// @@ -2920,16 +2919,19 @@ where /// and to not re-allocate the `Vec`'s buffer or allocate /// any additional memory. #[inline] - fn from(other: Vec) -> Self - { + fn from(other: Vec) -> 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::::from_raw_parts_in(ptr, cap, alloc) }, + } } } #[stable(feature = "vecdeque_vec_conversions", since = "1.10.0")] -impl From> - for Vec +impl + From> for Vec where [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, [(); alloc::co_alloc_metadata_num_slots_with_preference::(VECDEQUE_COOP_PREFERRED)]:, @@ -2963,11 +2965,9 @@ where /// assert_eq!(vec, [8, 9, 1, 2, 3, 4]); /// assert_eq!(vec.as_ptr(), ptr); /// ``` - fn from( - mut other: VecDeque, - ) -> Self + fn from(mut other: VecDeque) -> Self where - [(); alloc::co_alloc_metadata_num_slots_with_preference::(VECDEQUE_COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(VECDEQUE_COOP_PREFERRED)]:, { other.make_contiguous(); 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 5da3faaabe2c6..b0380260fcc44 100644 --- a/library/alloc/src/collections/vec_deque/spec_from_iter.rs +++ b/library/alloc/src/collections/vec_deque/spec_from_iter.rs @@ -7,8 +7,7 @@ pub(super) trait SpecFromIter { fn spec_from_iter(iter: I) -> Self; } -impl SpecFromIter - for VecDeque +impl SpecFromIter for VecDeque where I: Iterator, [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, From f928542cc49ff6a41fc0504b1e3eeef88b69d137 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Mon, 23 Jan 2023 12:23:23 -0800 Subject: [PATCH 74/80] CoAlloc: BinaryHeap: tidy --- library/alloc/src/collections/binary_heap/mod.rs | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/library/alloc/src/collections/binary_heap/mod.rs b/library/alloc/src/collections/binary_heap/mod.rs index 1290a449facd2..05dfaa92f385b 100644 --- a/library/alloc/src/collections/binary_heap/mod.rs +++ b/library/alloc/src/collections/binary_heap/mod.rs @@ -143,12 +143,12 @@ #![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; @@ -1572,10 +1572,10 @@ where } #[stable(feature = "fused", since = "1.26.0")] -impl FusedIterator for Drain<'_, T, COOP_PREFERRED> -where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, -{} +impl FusedIterator for Drain<'_, T, COOP_PREFERRED> where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]: +{ +} /// A draining iterator over the elements of a `BinaryHeap`. /// @@ -1664,7 +1664,7 @@ impl From<[T; N]> for BinaryHeap { #[stable(feature = "binary_heap_extras_15", since = "1.5.0")] #[allow(unused_braces)] -impl From> for Vec { +impl From> for Vec { /// Converts a `BinaryHeap` into a `Vec`. /// /// This conversion requires no data movement or allocation, and has From 25f6d451fc854d65555ca860ca9d4a11b9a313e0 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Mon, 23 Jan 2023 12:34:08 -0800 Subject: [PATCH 75/80] CoAlloc: slice.rs: Cleanup (of old code already commented out) --- library/alloc/src/slice.rs | 36 ------------------------------------ 1 file changed, 36 deletions(-) diff --git a/library/alloc/src/slice.rs b/library/alloc/src/slice.rs index bcdc5ff91e26e..9dc32b64f36db 100644 --- a/library/alloc/src/slice.rs +++ b/library/alloc/src/slice.rs @@ -894,48 +894,12 @@ where } }; - //<<<<<<< HEAD let run_alloc_fn = |len: usize| -> *mut sort::TimSortRun { // SAFETY: Creating the layout is safe as long as merge_sort never calls this with an // obscene length or 0. unsafe { alloc::alloc(alloc::Layout::array::(len).unwrap_unchecked()) as *mut sort::TimSortRun - /*======= - // Allocate a buffer to use as scratch memory. We keep the length 0 so we can keep in it - // 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`. - // `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::::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. - // `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. - let mut start = end - 1; - if start > 0 { - start -= 1; - unsafe { - if is_less(v.get_unchecked(start + 1), v.get_unchecked(start)) { - while start > 0 && is_less(v.get_unchecked(start), v.get_unchecked(start - 1)) { - start -= 1; - } - v[start..end].reverse(); - } else { - while start > 0 && !is_less(v.get_unchecked(start), v.get_unchecked(start - 1)) - { - start -= 1; - } - } - } - >>>>>>> 6bd68177557 (CoAlloc: Slice: Fixing COOP_PREFERRED)*/ } }; From bb72710cd7f1ff8795b551568c22c2acfee38193 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Thu, 12 Jan 2023 23:16:40 -0800 Subject: [PATCH 76/80] CoAlloc: Uncommenting assert of BorrowType::TRAVERSAL_PERMIT. TODO Undo once compilable, FIXME --- library/alloc/src/collections/btree/node.rs | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) 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 NodeRef self, ) -> Result, 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 /// both, upon success, do nothing. pub fn descend(self) -> NodeRef { 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 From 35281156e72e4871af18d027addf6795ddde4881 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Mon, 23 Jan 2023 16:35:42 -0800 Subject: [PATCH 77/80] CoAlloc: Vec + related: cleanup. Now library/alloc compiles, but std/ does NOT. --- library/alloc/src/str.rs | 2 +- library/std/src/ffi/os_str.rs | 1 - 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/library/alloc/src/str.rs b/library/alloc/src/str.rs index eedf856f5d253..2a011103cecd0 100644 --- a/library/alloc/src/str.rs +++ b/library/alloc/src/str.rs @@ -136,7 +136,7 @@ where T: Copy, B: AsRef<[T]> + ?Sized, S: Borrow, - [(); alloc::co_alloc_metadata_num_slots_with_preference_global(COOP_PREFERRED)]:, + [(); alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, { let sep_len = sep.len(); let mut iter = slice.iter(); diff --git a/library/std/src/ffi/os_str.rs b/library/std/src/ffi/os_str.rs index 6ab6323e19c83..80ed34157e6dc 100644 --- a/library/std/src/ffi/os_str.rs +++ b/library/std/src/ffi/os_str.rs @@ -1,7 +1,6 @@ #[cfg(test)] mod tests; -use crate::alloc::Global; use crate::borrow::{Borrow, Cow}; use crate::cmp; use crate::collections::TryReserveError; From 20f03015d09a88adf7bfa5893df02e42eb88efa2 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Tue, 24 Jan 2023 11:45:12 -0800 Subject: [PATCH 78/80] CoAlloc: Vec, related + vec! macro: Separated co-alloc-aware functions to have unique names, so we have no conflicts, but source code backward-compatibility. --- library/alloc/src/macros.rs | 2 +- library/alloc/src/str.rs | 4 +- library/alloc/src/vec/mod.rs | 69 ++++++++++++++++++- .../alloc/src/vec/spec_from_iter_nested.rs | 2 +- library/std/src/lib.rs | 1 + .../std/src/sys_common/thread_local_dtor.rs | 2 +- 6 files changed, 73 insertions(+), 7 deletions(-) diff --git a/library/alloc/src/macros.rs b/library/alloc/src/macros.rs index c2f1e9df41c11..5198bf297d925 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_co()) + $crate::__rust_force_expr!($crate::vec::Vec::new()) ); ($elem:expr; $n:expr) => ( $crate::__rust_force_expr!($crate::vec::from_elem($elem, $n)) diff --git a/library/alloc/src/str.rs b/library/alloc/src/str.rs index 2a011103cecd0..b95ef1c5933f8 100644 --- a/library/alloc/src/str.rs +++ b/library/alloc/src/str.rs @@ -144,7 +144,7 @@ where // the first slice is the only one without a separator preceding it let first = match iter.next() { Some(first) => first, - None => return vec![], + None => return Vec::new_co(), }; // compute the exact total length of the joined Vec @@ -159,7 +159,7 @@ where .expect("attempt to join into collection with len > usize::MAX"); // prepare an uninitialized buffer - let mut result = Vec::with_capacity(reserved_len); + let mut result = Vec::with_capacity_co(reserved_len); debug_assert!(result.capacity() >= reserved_len); result.extend_from_slice(first.borrow().as_ref()); diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs index 1a19a7a1e547b..c41899bd0d606 100644 --- a/library/alloc/src/vec/mod.rs +++ b/library/alloc/src/vec/mod.rs @@ -444,6 +444,10 @@ pub type DefVec = Vec; pub type WeVec = Vec 127 }>; impl Vec { +/*impl Vec +where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, +{*/ /// Constructs a new, empty `Vec`. /// /// The vector will not allocate until elements are pushed onto it. @@ -461,13 +465,73 @@ impl Vec { pub const fn new() -> Self { #[allow(unused_braces)] Vec::::new_co() + //Self::new_co() + } + + /// Constructs a new, empty `Vec` with at least the specified capacity. + /// + /// The vector will be able to hold at least `capacity` elements without + /// reallocating. This method is allowed to allocate for more elements than + /// `capacity`. If `capacity` is 0, the vector will not allocate. + /// + /// It is important to note that although the returned vector has the + /// minimum *capacity* specified, the vector will have a zero *length*. For + /// an explanation of the difference between length and capacity, see + /// *[Capacity and reallocation]*. + /// + /// If it is important to know the exact allocated capacity of a `Vec`, + /// always use the [`capacity`] method after construction. + /// + /// For `Vec` where `T` is a zero-sized type, there will be no allocation + /// and the capacity will always be `usize::MAX`. + /// + /// [Capacity and reallocation]: #capacity-and-reallocation + /// [`capacity`]: Vec::capacity + /// + /// # Panics + /// + /// Panics if the new capacity exceeds `isize::MAX` bytes. + /// + /// # Examples + /// + /// ``` + /// let mut vec = Vec::with_capacity(10); + /// + /// // The vector contains no items, even though it has capacity for more + /// assert_eq!(vec.len(), 0); + /// assert!(vec.capacity() >= 10); + /// + /// // These are all done without reallocating... + /// for i in 0..10 { + /// vec.push(i); + /// } + /// assert_eq!(vec.len(), 10); + /// assert!(vec.capacity() >= 10); + /// + /// // ...but this may make the vector reallocate + /// vec.push(11); + /// assert_eq!(vec.len(), 11); + /// assert!(vec.capacity() >= 11); + /// + /// // A vector of a zero-sized type will always over-allocate, since no + /// // allocation is necessary + /// let vec_units = Vec::<()>::with_capacity(10); + /// assert_eq!(vec_units.capacity(), usize::MAX); + /// ``` #[cfg(not(no_global_oom_handling))] + #[inline] + #[stable(feature = "rust1", since = "1.0.0")] + #[must_use] + pub fn with_capacity(capacity: usize) -> Self { + Self::with_capacity_in(capacity, Global) } + } //////////////////////////////////////////////////////////////////////////////// // Inherent methods //////////////////////////////////////////////////////////////////////////////// +/**/ impl Vec where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, @@ -481,6 +545,7 @@ where Vec { buf: RawVec::NEW, len: 0 } } + // TODO @FIXME document co-allocation /// Constructs a new, empty `Vec` with at least the specified capacity. /// /// The vector will be able to hold at least `capacity` elements without @@ -533,9 +598,9 @@ where /// ``` #[cfg(not(no_global_oom_handling))] #[inline] - #[stable(feature = "rust1", since = "1.0.0")] + #[unstable(feature = "vec_new_co", reason = "confirm_or_fix_the_function_name", issue = "none")] #[must_use] - pub fn with_capacity(capacity: usize) -> Self { + pub fn with_capacity_co(capacity: usize) -> Self { Self::with_capacity_in(capacity, Global) } diff --git a/library/alloc/src/vec/spec_from_iter_nested.rs b/library/alloc/src/vec/spec_from_iter_nested.rs index b71e86e83ba5a..358c1b5a25f55 100644 --- a/library/alloc/src/vec/spec_from_iter_nested.rs +++ b/library/alloc/src/vec/spec_from_iter_nested.rs @@ -34,7 +34,7 @@ where let (lower, _) = iterator.size_hint(); let initial_capacity = cmp::max(RawVec::::MIN_NON_ZERO_CAP, lower.saturating_add(1)); - let mut vector = Vec::with_capacity(initial_capacity); + let mut vector = Vec::with_capacity_co(initial_capacity); unsafe { // SAFETY: We requested capacity at least 1 ptr::write(vector.as_mut_ptr(), element); diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs index 919e43805f08d..eea1e921ae37e 100644 --- a/library/std/src/lib.rs +++ b/library/std/src/lib.rs @@ -329,6 +329,7 @@ #![feature(try_reserve_kind)] #![feature(vec_into_raw_parts)] #![feature(slice_concat_trait)] +#![feature(vec_new_co)] // // Library features (unwind): #![feature(panic_unwind)] diff --git a/library/std/src/sys_common/thread_local_dtor.rs b/library/std/src/sys_common/thread_local_dtor.rs index 6ec2f3cd11601..dcab8a89e7f53 100644 --- a/library/std/src/sys_common/thread_local_dtor.rs +++ b/library/std/src/sys_common/thread_local_dtor.rs @@ -31,7 +31,7 @@ pub unsafe fn register_dtor_fallback(t: *mut u8, dtor: unsafe extern "C" fn(*mut static DTORS: StaticKey = StaticKey::new(Some(run_dtors)); type List = PlVec<(*mut u8, unsafe extern "C" fn(*mut u8))>; if DTORS.get().is_null() { - let v: Box = Box::new(Vec::new()); + let v: Box = Box::new(Vec::new_co()); DTORS.set(Box::into_raw(v) as *mut u8); } let list: &mut List = &mut *(DTORS.get() as *mut List); From 43855d4f1c864d8a44cec66aa7fe38e2111ad2c3 Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Tue, 24 Jan 2023 11:58:53 -0800 Subject: [PATCH 79/80] CoAlloc: library/proc_macro (+related library/alloc): Experimenting with importing DEFAULT_COOP_PREFERRED --- library/alloc/src/vec/mod.rs | 1 + library/proc_macro/src/bridge/rpc.rs | 5 ++++- library/proc_macro/src/lib.rs | 1 + 3 files changed, 6 insertions(+), 1 deletion(-) diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs index c41899bd0d606..6c44b1944c72d 100644 --- a/library/alloc/src/vec/mod.rs +++ b/library/alloc/src/vec/mod.rs @@ -150,6 +150,7 @@ use self::spec_extend::SpecExtend; mod spec_extend; /// Default `Vec`, `DefVec`, `DecVeque`, `DefDecVeq` "cooperation" (`COOP_PREFERRED`) generic parameter. +/// NOT for public use. It's exported only so that library/proc_macro (and other internals) can use this. TODO FIXME. #[unstable(feature = "global_co_alloc_def", issue = "none")] // pub const DEFAULT_COOP_PREFERRED: bool = true; #[macro_export] diff --git a/library/proc_macro/src/bridge/rpc.rs b/library/proc_macro/src/bridge/rpc.rs index 1c39e29ed1b43..fc69eee17e24f 100644 --- a/library/proc_macro/src/bridge/rpc.rs +++ b/library/proc_macro/src/bridge/rpc.rs @@ -5,6 +5,9 @@ use std::char; use std::io::Write; use std::num::NonZeroU32; use std::str; +//use std::alloc::Global; +use alloc::DEFAULT_COOP_PREFERRED; +use alloc::alloc::Global; pub(super) type Writer = super::buffer::Buffer; @@ -225,7 +228,7 @@ impl DecodeMut<'_, '_, S> for String { } } -impl> Encode for Vec { +impl> Encode for Vec { fn encode(self, w: &mut Writer, s: &mut S) { self.len().encode(w, s); for x in self { diff --git a/library/proc_macro/src/lib.rs b/library/proc_macro/src/lib.rs index f0e4f5d8a8013..6fdee1ae795f5 100644 --- a/library/proc_macro/src/lib.rs +++ b/library/proc_macro/src/lib.rs @@ -33,6 +33,7 @@ #![feature(min_specialization)] #![feature(strict_provenance)] #![recursion_limit = "256"] +#![feature(global_co_alloc_def)] #[unstable(feature = "proc_macro_internals", issue = "27812")] #[doc(hidden)] From ebb22649520d1774eb58dcde1de86122c621116d Mon Sep 17 00:00:00 2001 From: Peter Kehl Date: Wed, 25 Jan 2023 12:08:29 -0800 Subject: [PATCH 80/80] CoAlloc: Renamed feature global_co_alloc_def to global_co_alloc_default. tidy --- library/alloc/src/ffi/c_str.rs | 6 +++--- library/alloc/src/lib.rs | 2 +- library/alloc/src/vec/mod.rs | 15 +++++++-------- library/proc_macro/src/bridge/rpc.rs | 2 +- library/proc_macro/src/lib.rs | 2 +- 5 files changed, 13 insertions(+), 14 deletions(-) diff --git a/library/alloc/src/ffi/c_str.rs b/library/alloc/src/ffi/c_str.rs index 15b06e787fc66..084ecfdb99984 100644 --- a/library/alloc/src/ffi/c_str.rs +++ b/library/alloc/src/ffi/c_str.rs @@ -1,12 +1,14 @@ #[cfg(test)] mod tests; +use crate::alloc::Global; use crate::borrow::{Cow, ToOwned}; use crate::boxed::Box; use crate::rc::Rc; use crate::slice::hack::into_vec; use crate::string::String; use crate::vec::Vec; +use crate::DEFAULT_COOP_PREFERRED; use core::borrow::Borrow; use core::ffi::{c_char, CStr}; use core::fmt; @@ -17,8 +19,6 @@ 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; @@ -726,7 +726,7 @@ impl fmt::Debug for CString { #[stable(feature = "cstring_into", since = "1.7.0")] #[allow(unused_braces)] -impl From for Vec { +impl From for Vec { /// Converts a [`CString`] into a [Vec]<[u8]>. /// /// The conversion consumes the [`CString`], and removes the terminating NUL byte. diff --git a/library/alloc/src/lib.rs b/library/alloc/src/lib.rs index 1166411f2c642..b002c736d5b4c 100644 --- a/library/alloc/src/lib.rs +++ b/library/alloc/src/lib.rs @@ -185,7 +185,7 @@ #![feature(global_co_alloc_short_term_pref)] #![feature(hashmap_internals)] #![feature(lang_items)] -#![feature(global_co_alloc_def)] +#![feature(global_co_alloc_default)] // 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::()` can be evaluated` // - cannot specialize on predicate `[(); _] well-formed` diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs index 6c44b1944c72d..2c0540e515aba 100644 --- a/library/alloc/src/vec/mod.rs +++ b/library/alloc/src/vec/mod.rs @@ -150,8 +150,8 @@ use self::spec_extend::SpecExtend; mod spec_extend; /// Default `Vec`, `DefVec`, `DecVeque`, `DefDecVeq` "cooperation" (`COOP_PREFERRED`) generic parameter. -/// NOT for public use. It's exported only so that library/proc_macro (and other internals) can use this. TODO FIXME. -#[unstable(feature = "global_co_alloc_def", issue = "none")] +/// NOT for public use. It's exported only so that library/proc_macro (and other internals) can use this. FIXME. +#[unstable(feature = "global_co_alloc_default", issue = "none")] // pub const DEFAULT_COOP_PREFERRED: bool = true; #[macro_export] macro_rules! DEFAULT_COOP_PREFERRED { @@ -445,10 +445,10 @@ pub type DefVec = Vec; pub type WeVec = Vec 127 }>; impl Vec { -/*impl Vec -where - [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, -{*/ + /*impl Vec + where + [(); core::alloc::co_alloc_metadata_num_slots_with_preference::(COOP_PREFERRED)]:, + {*/ /// Constructs a new, empty `Vec`. /// /// The vector will not allocate until elements are pushed onto it. @@ -525,7 +525,6 @@ where pub fn with_capacity(capacity: usize) -> Self { Self::with_capacity_in(capacity, Global) } - } //////////////////////////////////////////////////////////////////////////////// @@ -546,7 +545,7 @@ where Vec { buf: RawVec::NEW, len: 0 } } - // TODO @FIXME document co-allocation + // @FIXME document co-allocation /// Constructs a new, empty `Vec` with at least the specified capacity. /// /// The vector will be able to hold at least `capacity` elements without diff --git a/library/proc_macro/src/bridge/rpc.rs b/library/proc_macro/src/bridge/rpc.rs index fc69eee17e24f..764367f88412d 100644 --- a/library/proc_macro/src/bridge/rpc.rs +++ b/library/proc_macro/src/bridge/rpc.rs @@ -6,8 +6,8 @@ use std::io::Write; use std::num::NonZeroU32; use std::str; //use std::alloc::Global; -use alloc::DEFAULT_COOP_PREFERRED; use alloc::alloc::Global; +use alloc::DEFAULT_COOP_PREFERRED; pub(super) type Writer = super::buffer::Buffer; diff --git a/library/proc_macro/src/lib.rs b/library/proc_macro/src/lib.rs index 6fdee1ae795f5..28e6ff79348d7 100644 --- a/library/proc_macro/src/lib.rs +++ b/library/proc_macro/src/lib.rs @@ -33,7 +33,7 @@ #![feature(min_specialization)] #![feature(strict_provenance)] #![recursion_limit = "256"] -#![feature(global_co_alloc_def)] +#![feature(global_co_alloc_default)] #[unstable(feature = "proc_macro_internals", issue = "27812")] #[doc(hidden)]