CoAlloc: RawVec + compiler 'tests'

Author: peter-lyons-kehl

compiler/rustc_ast/src/ast.rs

@@ -26,6 +26,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;
@@ -37,7 +38,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:
 ///
@@ -3112,26 +3112,26 @@ mod size_asserts {
     static_assert_size!(AssocItem, 104);
     static_assert_size!(AssocItemKind, 32);
     static_assert_size!(Attribute, 32);
-    static_assert_size!(Block, 48);
-    static_assert_size!(Expr, 72);
-    static_assert_size!(ExprKind, 40);
-    static_assert_size!(Fn, 184);
+    static_assert_size!(Block, 48 + mem::size_of::<GlobalCoAllocMeta>());
+    static_assert_size!(Expr, 72 + mem::size_of::<GlobalCoAllocMeta>());
+    static_assert_size!(ExprKind, 40 + mem::size_of::<GlobalCoAllocMeta>());
+    static_assert_size!(Fn, 184 + 2 * mem::size_of::<GlobalCoAllocMeta>());
     static_assert_size!(ForeignItem, 96);
     static_assert_size!(ForeignItemKind, 24);
     static_assert_size!(GenericArg, 24);
-    static_assert_size!(GenericBound, 72);
-    static_assert_size!(Generics, 72);
-    static_assert_size!(Impl, 184);
-    static_assert_size!(Item, 184);
-    static_assert_size!(ItemKind, 112);
+    static_assert_size!(GenericBound, 72 + mem::size_of::<GlobalCoAllocMeta>());
+    static_assert_size!(Generics, 72 + 2 * mem::size_of::<GlobalCoAllocMeta>());
+    static_assert_size!(Impl, 184 + 3 * mem::size_of::<GlobalCoAllocMeta>());
+    static_assert_size!(Item, 184 + 3 * mem::size_of::<GlobalCoAllocMeta>());
+    static_assert_size!(ItemKind, 112 + 3 * mem::size_of::<GlobalCoAllocMeta>());
     static_assert_size!(LitKind, 24);
     static_assert_size!(Local, 72);
     static_assert_size!(MetaItemLit, 40);
     static_assert_size!(Param, 40);
-    static_assert_size!(Pat, 88);
+    static_assert_size!(Pat, 88 + mem::size_of::<GlobalCoAllocMeta>());
     static_assert_size!(Path, 24);
     static_assert_size!(PathSegment, 24);
-    static_assert_size!(PatKind, 64);
+    static_assert_size!(PatKind, 64 + mem::size_of::<GlobalCoAllocMeta>());
     static_assert_size!(Stmt, 32);
     static_assert_size!(StmtKind, 16);
     static_assert_size!(Ty, 64);

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)]

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(local_key_cell_methods)]

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,
 };
@@ -3077,7 +3078,7 @@ mod size_asserts {
     use super::*;
     use rustc_data_structures::static_assert_size;
     // tidy-alphabetical-start
-    static_assert_size!(BasicBlockData<'_>, 144);
+    static_assert_size!(BasicBlockData<'_>, 144 + mem::size_of::<GlobalCoAllocMeta>());
     static_assert_size!(LocalDecl<'_>, 56);
     static_assert_size!(Statement<'_>, 32);
     static_assert_size!(StatementKind<'_>, 16);

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};
@@ -1284,6 +1286,6 @@ mod size_asserts {
     static_assert_size!(Operand<'_>, 24);
     static_assert_size!(Place<'_>, 16);
     static_assert_size!(PlaceElem<'_>, 24);
-    static_assert_size!(Rvalue<'_>, 40);
+    static_assert_size!(Rvalue<'_>, 40 + mem::size_of::<GlobalCoAllocMeta>());
     // tidy-alphabetical-end
 }

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)]

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, 120);
+    static_assert_size!(LazyAttrTokenStreamImpl, 120 + mem::size_of::<GlobalCoAllocMeta>());
     // tidy-alphabetical-end
 }

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;
@@ -167,7 +168,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<'_>, 312);
+rustc_data_structures::static_assert_size!(Parser<'_>, 312 + 4 * mem::size_of::<GlobalCoAllocMeta>());
 
 /// Stores span information about a closure.
 #[derive(Clone)]

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)]

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::<GlobalCoAllocMeta>());
 
 impl<'a, 'tcx> FulfillmentContext<'tcx> {
     /// Creates a new fulfillment context.

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)]

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<T, A: Allocator = Global> {
     ptr: Unique<T>,
     cap: usize,
     alloc: A,
+    #[allow(dead_code)]
+    pub(crate) meta: GlobalCoAllocMeta,
 }
 
 impl<T> RawVec<T, Global> {
@@ -120,7 +122,7 @@ impl<T, A: Allocator> RawVec<T, A> {
     /// the returned `RawVec`.
     pub const fn new_in(alloc: A) -> Self {
         // `cap: 0` means "unallocated". zero-sized types are ignored.
-        Self { ptr: Unique::dangling(), cap: 0, alloc }
+        Self { ptr: Unique::dangling(), cap: 0, alloc, meta: GlobalCoAllocMeta {/*one: 1*/ /* , two: 2, three: 3, four: 4*/} }
     }
 
     /// Like `with_capacity`, but parameterized over the choice of
@@ -197,6 +199,7 @@ impl<T, A: Allocator> RawVec<T, A> {
                 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<T, A: Allocator> RawVec<T, A> {
     /// guaranteed.
     #[inline]
     pub unsafe fn from_raw_parts_in(ptr: *mut T, capacity: usize, alloc: A) -> Self {
-        Self { ptr: unsafe { Unique::new_unchecked(ptr) }, cap: capacity, alloc }
+        Self { ptr: unsafe { Unique::new_unchecked(ptr) }, cap: capacity, alloc, meta: GlobalCoAllocMeta {/*one: 1*/ /*, two: 2, three: 3, four: 4*/} }
     }
 
     /// Gets a raw pointer to the start of the allocation. Note that this is
@@ -480,8 +483,18 @@ where
 }
 
 unsafe impl<#[may_dangle] T, A: Allocator> Drop for RawVec<T, A> {
+    /// 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<T, Global> {
     /// 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) }
         }

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;
@@ -2400,13 +2402,13 @@ mod size_asserts {
     // tidy-alphabetical-start
     static_assert_size!(Crate, 64); // frequently moved by-value
     static_assert_size!(DocFragment, 32);
-    static_assert_size!(GenericArg, 32);
+    static_assert_size!(GenericArg, 32 + mem::size_of::<GlobalCoAllocMeta>());
     static_assert_size!(GenericArgs, 32);
-    static_assert_size!(GenericParamDef, 56);
+    static_assert_size!(GenericParamDef, 56 + mem::size_of::<GlobalCoAllocMeta>());
     static_assert_size!(Generics, 16);
     static_assert_size!(Item, 56);
-    static_assert_size!(ItemKind, 64);
+    static_assert_size!(ItemKind, 64 + mem::size_of::<GlobalCoAllocMeta>());
     static_assert_size!(PathSegment, 40);
-    static_assert_size!(Type, 32);
+    static_assert_size!(Type, 32 + mem::size_of::<GlobalCoAllocMeta>());
     // tidy-alphabetical-end
 }

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::<GlobalCoAllocMeta>());
 
 /// Shared mutable state used in [`Context`] and elsewhere.
 pub(crate) struct SharedContext<'tcx> {

src/librustdoc/lib.rs

@@ -7,6 +7,7 @@
 #![feature(assert_matches)]
 #![feature(box_patterns)]
 #![feature(drain_filter)]
+#![feature(global_co_alloc_meta)]
 #![feature(is_terminal)]
 #![feature(let_chains)]
 #![feature(test)]