CoAlloc: x86_64-only compiler node size asserts. Tidy.

Author: peter-lyons-kehl

compiler/rustc_ast/src/ast.rs

@@ -34,8 +34,6 @@ use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
 use rustc_span::source_map::{respan, Spanned};
 use rustc_span::symbol::{kw, sym, Ident, Symbol};
 use rustc_span::{Span, DUMMY_SP};
-use std::alloc::Allocator;
-use std::alloc::Global;
 use std::fmt;
 use std::mem;
 use thin_vec::{thin_vec, ThinVec};
@@ -3114,6 +3112,7 @@ pub type ForeignItem = Item<ForeignItemKind>;
 mod size_asserts {
     use super::*;
     use rustc_data_structures::static_assert_size;
+    use std::alloc::{Allocator, Global};
     // tidy-alphabetical-start
     static_assert_size!(AssocItem, 104);
     static_assert_size!(AssocItemKind, 32);

compiler/rustc_middle/src/mir/mod.rs

@@ -34,7 +34,6 @@ 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};
@@ -3084,7 +3083,7 @@ mod size_asserts {
     // tidy-alphabetical-start
     static_assert_size!(
         BasicBlockData<'_>,
-        144 + mem::size_of::<<Global as Allocator>::CoAllocMeta>()
+        144 + mem::size_of::<<std::alloc::Global as std::alloc::Allocator>::CoAllocMeta>()
     );
     static_assert_size!(LocalDecl<'_>, 40);
     static_assert_size!(Statement<'_>, 32);

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::mem;
 
 use crate::mir::coverage::{CodeRegion, CoverageKind};
 use crate::traits::Reveal;
@@ -25,8 +24,6 @@ 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
@@ -1254,6 +1251,9 @@ 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::<<Global as Allocator>::CoAllocMeta>());
+    static_assert_size!(
+        Rvalue<'_>,
+        40 + std::mem::size_of::<<std::alloc::Global as std::alloc::Allocator>::CoAllocMeta>()
+    );
     // tidy-alphabetical-end
 }

compiler/rustc_parse/src/parser/attr_wrapper.rs

@@ -1,5 +1,4 @@
 use super::{Capturing, FlatToken, ForceCollect, Parser, ReplaceRange, TokenCursor, TrailingToken};
-use core::mem;
 use rustc_ast::token::{self, Delimiter, Token, TokenKind};
 use rustc_ast::tokenstream::{AttrTokenStream, AttributesData, ToAttrTokenStream};
 use rustc_ast::tokenstream::{AttrTokenTree, DelimSpan, LazyAttrTokenStream, Spacing};
@@ -9,7 +8,6 @@ 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.
@@ -469,11 +467,12 @@ fn make_token_stream(
 mod size_asserts {
     use super::*;
     use rustc_data_structures::static_assert_size;
+    use std::alloc::{Allocator, Global};
     // tidy-alphabetical-start
     static_assert_size!(AttrWrapper, 16);
     static_assert_size!(
         LazyAttrTokenStreamImpl,
-        120 + mem::size_of::<<Global as Allocator>::CoAllocMeta>()
+        120 + std::mem::size_of::<<Global as Allocator>::CoAllocMeta>()
     );
     // tidy-alphabetical-end
 }

compiler/rustc_parse/src/parser/mod.rs

@@ -36,7 +36,6 @@ use rustc_errors::{
 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};
 use thin_vec::ThinVec;
@@ -168,7 +167,7 @@ pub struct Parser<'a> {
 #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
 rustc_data_structures::static_assert_size!(
     Parser<'_>,
-    288 + 4 * mem::size_of::<<Global as Allocator>::CoAllocMeta>()
+    288 + 4 * mem::size_of::<<std::alloc::Global as std::alloc::Allocator>::CoAllocMeta>()
 );
 
 /// Stores span information about a closure.

compiler/rustc_trait_selection/src/traits/fulfill.rs

@@ -1,5 +1,4 @@
 use crate::infer::{InferCtxt, TyOrConstInferVar};
-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};
@@ -12,7 +11,6 @@ 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, TypeVisitableExt};
-use std::alloc::{Allocator, Global};
 use std::marker::PhantomData;
 
 use super::const_evaluatable;
@@ -83,7 +81,7 @@ pub struct PendingPredicateObligation<'tcx> {
 #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
 static_assert_size!(
     PendingPredicateObligation<'_>,
-    72 + mem::size_of::<<Global as Allocator>::CoAllocMeta>()
+    72 + std::mem::size_of::<<std::alloc::Global as std::alloc::Allocator>::CoAllocMeta>()
 );
 
 impl<'a, 'tcx> FulfillmentContext<'tcx> {

library/alloc/src/collections/btree/node.rs

@@ -80,7 +80,7 @@ struct LeafNode<K, V> {
 }
 
 /// @FIXME Remove once we remove leaf_node_capacity!() workaround for https://github.com/rust-lang/rust/issues/108751
-#[test]
+/// This should be in #[test], but that would mean having it in a separate file (as per `x test tidy --bless`) - too complicated for this workaround.
 #[allow(dead_code)]
 fn assert_leaf_node_capacity() {
     fn leaf_node() -> LeafNode<char, bool> {
@@ -130,7 +130,7 @@ struct InternalNode<K, V> {
 }
 
 /// @FIXME Remove once we remove internal_node_capacity!() workaround for https://github.com/rust-lang/rust/issues/108751
-#[test]
+/// This should be in #[test], but that would mean having it in a separate file (as per `x test tidy --bless`) - too complicated for this workaround.
 #[allow(dead_code)]
 fn assert_internal_node_capacity() {
     fn internal_node() -> InternalNode<char, bool> {

src/librustdoc/clean/types.rs

@@ -1,8 +1,6 @@
-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;
@@ -2399,16 +2397,19 @@ impl SubstParam {
 mod size_asserts {
     use super::*;
     use rustc_data_structures::static_assert_size;
+    #[allow(dead_code)]
+    const GLOBAL_CO_ALLOC_META_SIZE: usize =
+        std::mem::size_of::<<std::alloc::Global as std::alloc::Allocator>::CoAllocMeta>();
     // tidy-alphabetical-start
     static_assert_size!(Crate, 64); // frequently moved by-value
     static_assert_size!(DocFragment, 32);
-    static_assert_size!(GenericArg, 32 + mem::size_of::<GlobalCoAllocMeta>());
+    static_assert_size!(GenericArg, 32 + GLOBAL_CO_ALLOC_META_SIZE);
     static_assert_size!(GenericArgs, 32);
-    static_assert_size!(GenericParamDef, 56 + mem::size_of::<GlobalCoAllocMeta>());
+    static_assert_size!(GenericParamDef, 56 + GLOBAL_CO_ALLOC_META_SIZE);
     static_assert_size!(Generics, 16);
     static_assert_size!(Item, 56);
-    static_assert_size!(ItemKind, 64 + mem::size_of::<GlobalCoAllocMeta>());
+    static_assert_size!(ItemKind, 64 + GLOBAL_CO_ALLOC_META_SIZE);
     static_assert_size!(PathSegment, 40);
-    static_assert_size!(Type, 32 + mem::size_of::<GlobalCoAllocMeta>());
+    static_assert_size!(Type, 32 + GLOBAL_CO_ALLOC_META_SIZE);
     // tidy-alphabetical-end
 }

src/librustdoc/html/render/context.rs

@@ -1,8 +1,6 @@
-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};
@@ -81,7 +79,7 @@ pub(crate) struct Context<'tcx> {
 #[cfg(all(not(windows), target_arch = "x86_64", target_pointer_width = "64"))]
 rustc_data_structures::static_assert_size!(
     Context<'_>,
-    160 + 2 * mem::size_of::<GlobalCoAllocMeta>()
+    160 + 2 * std::mem::size_of::<<std::alloc::Global as std::alloc::Allocator>::CoAllocMeta>()
 );
 
 /// Shared mutable state used in [`Context`] and elsewhere.

src/librustdoc/lib.rs

@@ -2,6 +2,7 @@
     html_root_url = "https://doc.rust-lang.org/nightly/",
     html_playground_url = "https://play.rust-lang.org/"
 )]
+#![feature(allocator_api)]
 #![feature(rustc_private)]
 #![feature(array_methods)]
 #![feature(assert_matches)]