CoAlloc: compiler/ uses <Global as Allocator>::CoAllocMeta

Author: peter-lyons-kehl

compiler/rustc_middle/src/mir/mod.rs

@@ -13,7 +13,6 @@ use crate::ty::visit::{TypeVisitable, TypeVisitor};
 use crate::ty::{self, ir, 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;
@@ -35,6 +34,7 @@ use rustc_span::{Span, DUMMY_SP};
 
 use either::Either;
 
+use std::alloc::{Allocator, Global};
 use std::borrow::Cow;
 use std::fmt::{self, Debug, Display, Formatter, Write};
 use std::ops::{ControlFlow, Index, IndexMut};
@@ -3078,7 +3078,10 @@ mod size_asserts {
     use super::*;
     use rustc_data_structures::static_assert_size;
     // tidy-alphabetical-start
-    static_assert_size!(BasicBlockData<'_>, 144 + mem::size_of::<GlobalCoAllocMeta>());
+    static_assert_size!(
+        BasicBlockData<'_>,
+        144 + mem::size_of::<<Global as Allocator>::CoAllocMeta>()
+    );
     static_assert_size!(LocalDecl<'_>, 56);
     static_assert_size!(Statement<'_>, 32);
     static_assert_size!(StatementKind<'_>, 16);

compiler/rustc_middle/src/mir/syntax.rs

@@ -4,7 +4,6 @@
 //! The intention is that this file only contains datatype declarations, no code.
 
 use super::{BasicBlock, Constant, Field, Local, SwitchTargets, UserTypeProjection};
-use core::alloc::GlobalCoAllocMeta;
 use core::mem;
 
 use crate::mir::coverage::{CodeRegion, CoverageKind};
@@ -26,6 +25,8 @@ use rustc_span::symbol::Symbol;
 use rustc_span::Span;
 use rustc_target::asm::InlineAsmRegOrRegClass;
 
+use std::alloc::{Allocator, Global};
+
 /// Represents the "flavors" of MIR.
 ///
 /// All flavors of MIR use the same data structure, but there are some important differences. These
@@ -1286,6 +1287,6 @@ mod size_asserts {
     static_assert_size!(Operand<'_>, 24);
     static_assert_size!(Place<'_>, 16);
     static_assert_size!(PlaceElem<'_>, 24);
-    static_assert_size!(Rvalue<'_>, 40 + mem::size_of::<GlobalCoAllocMeta>());
+    static_assert_size!(Rvalue<'_>, 40 + mem::size_of::<<Global as Allocator>::CoAllocMeta>());
     // tidy-alphabetical-end
 }

compiler/rustc_parse/src/lib.rs

@@ -1,5 +1,6 @@
 //! The main parser interface.
 
+#![feature(allocator_api)]
 #![feature(array_windows)]
 #![feature(box_patterns)]
 #![feature(global_co_alloc_meta)]

compiler/rustc_parse/src/parser/attr_wrapper.rs

@@ -1,5 +1,4 @@
 use super::{Capturing, FlatToken, ForceCollect, Parser, ReplaceRange, TokenCursor, TrailingToken};
-use core::alloc::GlobalCoAllocMeta;
 use core::mem;
 use rustc_ast::token::{self, Delimiter, Token, TokenKind};
 use rustc_ast::tokenstream::{AttrTokenStream, AttributesData, ToAttrTokenStream};
@@ -10,6 +9,7 @@ use rustc_errors::PResult;
 use rustc_session::parse::ParseSess;
 use rustc_span::{sym, Span, DUMMY_SP};
 
+use std::alloc::{Allocator, Global};
 use std::ops::Range;
 
 /// A wrapper type to ensure that the parser handles outer attributes correctly.
@@ -471,6 +471,9 @@ mod size_asserts {
     use rustc_data_structures::static_assert_size;
     // tidy-alphabetical-start
     static_assert_size!(AttrWrapper, 16);
-    static_assert_size!(LazyAttrTokenStreamImpl, 120 + mem::size_of::<GlobalCoAllocMeta>());
+    static_assert_size!(
+        LazyAttrTokenStreamImpl,
+        120 + mem::size_of::<<Global as Allocator>::CoAllocMeta>()
+    );
     // tidy-alphabetical-end
 }

compiler/rustc_parse/src/parser/mod.rs

@@ -12,7 +12,6 @@ mod ty;
 
 use crate::lexer::UnmatchedBrace;
 pub use attr_wrapper::AttrWrapper;
-use core::alloc::GlobalCoAllocMeta;
 pub use diagnostics::AttemptLocalParseRecovery;
 pub(crate) use item::FnParseMode;
 pub use pat::{CommaRecoveryMode, RecoverColon, RecoverComma};
@@ -38,6 +37,7 @@ use rustc_session::parse::ParseSess;
 use rustc_span::source_map::{Span, DUMMY_SP};
 use rustc_span::symbol::{kw, sym, Ident, Symbol};
 
+use std::alloc::{Allocator, Global};
 use std::ops::Range;
 use std::{cmp, mem, slice};
 
@@ -170,7 +170,7 @@ pub struct Parser<'a> {
 #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
 rustc_data_structures::static_assert_size!(
     Parser<'_>,
-    312 + 4 * mem::size_of::<GlobalCoAllocMeta>()
+    312 + 4 * mem::size_of::<<Global as Allocator>::CoAllocMeta>()
 );
 
 /// Stores span information about a closure.

compiler/rustc_trait_selection/src/lib.rs

@@ -11,6 +11,7 @@
 //! This API is completely unstable and subject to change.
 
 #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
+#![feature(allocator_api)]
 #![feature(associated_type_bounds)]
 #![feature(box_patterns)]
 #![feature(control_flow_enum)]

compiler/rustc_trait_selection/src/traits/fulfill.rs

@@ -1,5 +1,4 @@
 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;
@@ -12,6 +11,7 @@ use rustc_middle::ty::abstract_const::NotConstEvaluatable;
 use rustc_middle::ty::error::{ExpectedFound, TypeError};
 use rustc_middle::ty::subst::SubstsRef;
 use rustc_middle::ty::{self, Binder, Const, TypeVisitable};
+use std::alloc::{Allocator, Global};
 use std::marker::PhantomData;
 
 use super::const_evaluatable;
@@ -80,7 +80,10 @@ 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 + mem::size_of::<GlobalCoAllocMeta>());
+static_assert_size!(
+    PendingPredicateObligation<'_>,
+    72 + mem::size_of::<<Global as Allocator>::CoAllocMeta>()
+);
 
 impl<'a, 'tcx> FulfillmentContext<'tcx> {
     /// Creates a new fulfillment context.