bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Auto merge of #98960 - cjgillot:entry-kind, r=estebank

Browse source 
Remove EntryKind from metadata.

This PR continues the refactor of metadata emission to be more systematic, iterating on definitions and filtering based on each definition's `DefKind`. This allows to remove the large `EntryKind` enum, replaced by linear tables in metadata.
This commit is contained in:
bors 2022-09-01 19:31:14 +00:00
commit 2e35f954ad
7 changed files with 252 additions and 355 deletions
Download patch file Download diff file Expand all files Collapse all files

118
compiler/rustc_metadata/src/rmeta/decoder.rs
View file

@ -4,7 +4,6 @@ use crate::creader::{CStore, CrateMetadataRef};
use crate::rmeta::*; use crate::rmeta::*;
use rustc_ast as ast; use rustc_ast as ast;
use rustc_ast::ptr::P;
use rustc_data_structures::captures::Captures; use rustc_data_structures::captures::Captures;
use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::fx::FxHashMap;
use rustc_data_structures::svh::Svh; use rustc_data_structures::svh::Svh;
@ -33,7 +32,7 @@ use rustc_session::cstore::{
use rustc_session::Session; use rustc_session::Session;
use rustc_span::hygiene::{ExpnIndex, MacroKind}; use rustc_span::hygiene::{ExpnIndex, MacroKind};
use rustc_span::source_map::{respan, Spanned}; use rustc_span::source_map::{respan, Spanned};
use rustc_span::symbol::{sym, Ident, Symbol}; use rustc_span::symbol::{kw, sym, Ident, Symbol};
use rustc_span::{self, BytePos, ExpnId, Pos, Span, SyntaxContext, DUMMY_SP}; use rustc_span::{self, BytePos, ExpnId, Pos, Span, SyntaxContext, DUMMY_SP};
use proc_macro::bridge::client::ProcMacro; use proc_macro::bridge::client::ProcMacro;
@ -785,26 +784,11 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
self.opt_item_ident(item_index, sess).expect("no encoded ident for item") self.opt_item_ident(item_index, sess).expect("no encoded ident for item")
} }
fn maybe_kind(self, item_id: DefIndex) -> Option<EntryKind> {
self.root.tables.kind.get(self, item_id).map(|k| k.decode(self))
}
#[inline] #[inline]
pub(super) fn map_encoded_cnum_to_current(self, cnum: CrateNum) -> CrateNum { pub(super) fn map_encoded_cnum_to_current(self, cnum: CrateNum) -> CrateNum {
if cnum == LOCAL_CRATE { self.cnum } else { self.cnum_map[cnum] } if cnum == LOCAL_CRATE { self.cnum } else { self.cnum_map[cnum] }
} }
fn kind(self, item_id: DefIndex) -> EntryKind {
self.maybe_kind(item_id).unwrap_or_else(|| {
bug!(
"CrateMetadata::kind({:?}): id not found, in crate {:?} with number {}",
item_id,
self.root.name,
self.cnum,
)
})
}
fn def_kind(self, item_id: DefIndex) -> DefKind { fn def_kind(self, item_id: DefIndex) -> DefKind {
self.root.tables.opt_def_kind.get(self, item_id).unwrap_or_else(|| { self.root.tables.opt_def_kind.get(self, item_id).unwrap_or_else(|| {
bug!( bug!(
@ -856,20 +840,15 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
) )
} }
fn get_variant(self, kind: &EntryKind, index: DefIndex, parent_did: DefId) -> ty::VariantDef { fn get_variant(self, kind: &DefKind, index: DefIndex, parent_did: DefId) -> ty::VariantDef {
let data = match kind { let adt_kind = match kind {
EntryKind::Variant(data) | EntryKind::Struct(data) | EntryKind::Union(data) => { DefKind::Variant => ty::AdtKind::Enum,
data.decode(self) DefKind::Struct => ty::AdtKind::Struct,
} DefKind::Union => ty::AdtKind::Union,
_ => bug!(), _ => bug!(),
}; };
let adt_kind = match kind { let data = self.root.tables.variant_data.get(self, index).unwrap().decode(self);
EntryKind::Variant(_) => ty::AdtKind::Enum,
EntryKind::Struct(..) => ty::AdtKind::Struct,
EntryKind::Union(..) => ty::AdtKind::Union,
_ => bug!(),
};
let variant_did = let variant_did =
if adt_kind == ty::AdtKind::Enum { Some(self.local_def_id(index)) } else { None }; if adt_kind == ty::AdtKind::Enum { Some(self.local_def_id(index)) } else { None };
@ -901,13 +880,13 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
} }
fn get_adt_def(self, item_id: DefIndex, tcx: TyCtxt<'tcx>) -> ty::AdtDef<'tcx> { fn get_adt_def(self, item_id: DefIndex, tcx: TyCtxt<'tcx>) -> ty::AdtDef<'tcx> {
let kind = self.kind(item_id); let kind = self.def_kind(item_id);
let did = self.local_def_id(item_id); let did = self.local_def_id(item_id);
let adt_kind = match kind { let adt_kind = match kind {
EntryKind::Enum => ty::AdtKind::Enum, DefKind::Enum => ty::AdtKind::Enum,
EntryKind::Struct(_) => ty::AdtKind::Struct, DefKind::Struct => ty::AdtKind::Struct,
EntryKind::Union(_) => ty::AdtKind::Union, DefKind::Union => ty::AdtKind::Union,
_ => bug!("get_adt_def called on a non-ADT {:?}", did), _ => bug!("get_adt_def called on a non-ADT {:?}", did),
}; };
let repr = self.root.tables.repr_options.get(self, item_id).unwrap().decode(self); let repr = self.root.tables.repr_options.get(self, item_id).unwrap().decode(self);
@ -919,7 +898,7 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
.get(self, item_id) .get(self, item_id)
.unwrap_or_else(LazyArray::empty) .unwrap_or_else(LazyArray::empty)
.decode(self) .decode(self)
.map(|index| self.get_variant(&self.kind(index), index, did)) .map(|index| self.get_variant(&self.def_kind(index), index, did))
.collect() .collect()
} else { } else {
std::iter::once(self.get_variant(&kind, item_id, did)).collect() std::iter::once(self.get_variant(&kind, item_id, did)).collect()
@ -1029,10 +1008,9 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
let vis = self.get_visibility(child_index); let vis = self.get_visibility(child_index);
let span = self.get_span(child_index, sess); let span = self.get_span(child_index, sess);
let macro_rules = match kind { let macro_rules = match kind {
DefKind::Macro(..) => match self.kind(child_index) { DefKind::Macro(..) => {
EntryKind::MacroDef(_, macro_rules) => macro_rules, self.root.tables.macro_rules.get(self, child_index).is_some()
_ => unreachable!(), }
},
_ => false, _ => false,
}; };
@ -1086,14 +1064,10 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
} }
} }
match self.kind(id) { if let Some(exports) = self.root.tables.module_reexports.get(self, id) {
EntryKind::Mod(exports) => { for exp in exports.decode((self, sess)) {
for exp in exports.decode((self, sess)) { callback(exp);
callback(exp);
}
} }
EntryKind::Enum | EntryKind::Trait => {}
_ => bug!("`for_each_module_child` is called on a non-module: {:?}", self.def_kind(id)),
} }
} }
@ -1106,19 +1080,21 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
} }
fn module_expansion(self, id: DefIndex, sess: &Session) -> ExpnId { fn module_expansion(self, id: DefIndex, sess: &Session) -> ExpnId {
match self.kind(id) { match self.def_kind(id) {
EntryKind::Mod(_) | EntryKind::Enum | EntryKind::Trait => { DefKind::Mod | DefKind::Enum | DefKind::Trait => self.get_expn_that_defined(id, sess),
self.get_expn_that_defined(id, sess)
}
_ => panic!("Expected module, found {:?}", self.local_def_id(id)), _ => panic!("Expected module, found {:?}", self.local_def_id(id)),
} }
} }
fn get_fn_has_self_parameter(self, id: DefIndex) -> bool { fn get_fn_has_self_parameter(self, id: DefIndex, sess: &'a Session) -> bool {
match self.kind(id) { self.root
EntryKind::AssocFn { has_self, .. } => has_self, .tables
_ => false, .fn_arg_names
} .get(self, id)
.unwrap_or_else(LazyArray::empty)
.decode((self, sess))
.nth(0)
.map_or(false, |ident| ident.name == kw::SelfLower)
} }
fn get_associated_item_def_ids( fn get_associated_item_def_ids(
@ -1135,15 +1111,17 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
.map(move |child_index| self.local_def_id(child_index)) .map(move |child_index| self.local_def_id(child_index))
} }
fn get_associated_item(self, id: DefIndex) -> ty::AssocItem { fn get_associated_item(self, id: DefIndex, sess: &'a Session) -> ty::AssocItem {
let name = self.item_name(id); let name = self.item_name(id);
let (kind, container, has_self) = match self.kind(id) { let kind = match self.def_kind(id) {
EntryKind::AssocConst(container) => (ty::AssocKind::Const, container, false), DefKind::AssocConst => ty::AssocKind::Const,
EntryKind::AssocFn { container, has_self } => (ty::AssocKind::Fn, container, has_self), DefKind::AssocFn => ty::AssocKind::Fn,
EntryKind::AssocType(container) => (ty::AssocKind::Type, container, false), DefKind::AssocTy => ty::AssocKind::Type,
_ => bug!("cannot get associated-item of `{:?}`", id), _ => bug!("cannot get associated-item of `{:?}`", self.def_key(id)),
}; };
let has_self = self.get_fn_has_self_parameter(id, sess);
let container = self.root.tables.assoc_container.get(self, id).unwrap();
ty::AssocItem { ty::AssocItem {
name, name,
@ -1156,9 +1134,9 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
} }
fn get_ctor_def_id_and_kind(self, node_id: DefIndex) -> Option<(DefId, CtorKind)> { fn get_ctor_def_id_and_kind(self, node_id: DefIndex) -> Option<(DefId, CtorKind)> {
match self.kind(node_id) { match self.def_kind(node_id) {
EntryKind::Struct(data) | EntryKind::Variant(data) => { DefKind::Struct | DefKind::Variant => {
let vdata = data.decode(self); let vdata = self.root.tables.variant_data.get(self, node_id).unwrap().decode(self);
vdata.ctor.map(|index| (self.local_def_id(index), vdata.ctor_kind)) vdata.ctor.map(|index| (self.local_def_id(index), vdata.ctor_kind))
} }
_ => None, _ => None,
@ -1346,18 +1324,22 @@ impl<'a, 'tcx> CrateMetadataRef<'a> {
} }
fn get_macro(self, id: DefIndex, sess: &Session) -> ast::MacroDef { fn get_macro(self, id: DefIndex, sess: &Session) -> ast::MacroDef {
match self.kind(id) { match self.def_kind(id) {
EntryKind::MacroDef(mac_args, macro_rules) => { DefKind::Macro(_) => {
ast::MacroDef { body: P(mac_args.decode((self, sess))), macro_rules } let macro_rules = self.root.tables.macro_rules.get(self, id).is_some();
let body =
self.root.tables.macro_definition.get(self, id).unwrap().decode((self, sess));
ast::MacroDef { macro_rules, body: ast::ptr::P(body) }
} }
_ => bug!(), _ => bug!(),
} }
} }
fn is_foreign_item(self, id: DefIndex) -> bool { fn is_foreign_item(self, id: DefIndex) -> bool {
match self.kind(id) { if let Some(parent) = self.def_key(id).parent {
EntryKind::ForeignStatic | EntryKind::ForeignFn => true, matches!(self.def_kind(parent), DefKind::ForeignMod)
_ => false, } else {
false
} }
} }

6
compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs
View file

@ -233,7 +233,7 @@ provide! { tcx, def_id, other, cdata,
associated_item_def_ids => { associated_item_def_ids => {
tcx.arena.alloc_from_iter(cdata.get_associated_item_def_ids(def_id.index, tcx.sess)) tcx.arena.alloc_from_iter(cdata.get_associated_item_def_ids(def_id.index, tcx.sess))
} }
associated_item => { cdata.get_associated_item(def_id.index) } associated_item => { cdata.get_associated_item(def_id.index, tcx.sess) }
inherent_impls => { cdata.get_inherent_implementations_for_type(tcx, def_id.index) } inherent_impls => { cdata.get_inherent_implementations_for_type(tcx, def_id.index) }
is_foreign_item => { cdata.is_foreign_item(def_id.index) } is_foreign_item => { cdata.is_foreign_item(def_id.index) }
item_attrs => { tcx.arena.alloc_from_iter(cdata.get_item_attrs(def_id.index, tcx.sess)) } item_attrs => { tcx.arena.alloc_from_iter(cdata.get_item_attrs(def_id.index, tcx.sess)) }
@ -535,8 +535,8 @@ impl CStore {
) )
} }
pub fn fn_has_self_parameter_untracked(&self, def: DefId) -> bool { pub fn fn_has_self_parameter_untracked(&self, def: DefId, sess: &Session) -> bool {
self.get_crate_data(def.krate).get_fn_has_self_parameter(def.index) self.get_crate_data(def.krate).get_fn_has_self_parameter(def.index, sess)
} }
pub fn crate_source_untracked(&self, cnum: CrateNum) -> Lrc<CrateSource> { pub fn crate_source_untracked(&self, cnum: CrateNum) -> Lrc<CrateSource> {

421
compiler/rustc_metadata/src/rmeta/encoder.rs
View file

@ -16,7 +16,6 @@ use rustc_hir::def_id::{
use rustc_hir::definitions::DefPathData; use rustc_hir::definitions::DefPathData;
use rustc_hir::intravisit::{self, Visitor}; use rustc_hir::intravisit::{self, Visitor};
use rustc_hir::lang_items; use rustc_hir::lang_items;
use rustc_hir::{AnonConst, GenericParamKind};
use rustc_middle::hir::nested_filter; use rustc_middle::hir::nested_filter;
use rustc_middle::middle::dependency_format::Linkage; use rustc_middle::middle::dependency_format::Linkage;
use rustc_middle::middle::exported_symbols::{ use rustc_middle::middle::exported_symbols::{
@ -1019,6 +1018,89 @@ fn should_encode_generics(def_kind: DefKind) -> bool {
} }
} }
fn should_encode_type(tcx: TyCtxt<'_>, def_id: LocalDefId, def_kind: DefKind) -> bool {
match def_kind {
DefKind::Struct
| DefKind::Union
| DefKind::Enum
| DefKind::Variant
| DefKind::Ctor(..)
| DefKind::Field
| DefKind::Fn
| DefKind::Const
| DefKind::Static(..)
| DefKind::TyAlias
| DefKind::OpaqueTy
| DefKind::ForeignTy
| DefKind::Impl
| DefKind::AssocFn
| DefKind::AssocConst
| DefKind::Closure
| DefKind::Generator
| DefKind::ConstParam
| DefKind::AnonConst
| DefKind::InlineConst => true,
DefKind::AssocTy => {
let assoc_item = tcx.associated_item(def_id);
match assoc_item.container {
ty::AssocItemContainer::ImplContainer => true,
ty::AssocItemContainer::TraitContainer => assoc_item.defaultness(tcx).has_value(),
}
}
DefKind::TyParam => {
let hir::Node::GenericParam(param) = tcx.hir().get_by_def_id(def_id) else { bug!() };
let hir::GenericParamKind::Type { default, .. } = param.kind else { bug!() };
default.is_some()
}
DefKind::Trait
| DefKind::TraitAlias
| DefKind::Mod
| DefKind::ForeignMod
| DefKind::Macro(..)
| DefKind::Use
| DefKind::LifetimeParam
| DefKind::GlobalAsm
| DefKind::ExternCrate => false,
}
}
fn should_encode_const(def_kind: DefKind) -> bool {
match def_kind {
DefKind::Const | DefKind::AssocConst | DefKind::AnonConst => true,
DefKind::Struct
| DefKind::Union
| DefKind::Enum
| DefKind::Variant
| DefKind::Ctor(..)
| DefKind::Field
| DefKind::Fn
| DefKind::Static(..)
| DefKind::TyAlias
| DefKind::OpaqueTy
| DefKind::ForeignTy
| DefKind::Impl
| DefKind::AssocFn
| DefKind::Closure
| DefKind::Generator
| DefKind::ConstParam
| DefKind::InlineConst
| DefKind::AssocTy
| DefKind::TyParam
| DefKind::Trait
| DefKind::TraitAlias
| DefKind::Mod
| DefKind::ForeignMod
| DefKind::Macro(..)
| DefKind::Use
| DefKind::LifetimeParam
| DefKind::GlobalAsm
| DefKind::ExternCrate => false,
}
}
impl<'a, 'tcx> EncodeContext<'a, 'tcx> { impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
fn encode_attrs(&mut self, def_id: LocalDefId) { fn encode_attrs(&mut self, def_id: LocalDefId) {
let mut attrs = self let mut attrs = self
@ -1044,7 +1126,8 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
let def_kind = tcx.opt_def_kind(local_id); let def_kind = tcx.opt_def_kind(local_id);
let Some(def_kind) = def_kind else { continue }; let Some(def_kind) = def_kind else { continue };
self.tables.opt_def_kind.set(def_id.index, def_kind); self.tables.opt_def_kind.set(def_id.index, def_kind);
record!(self.tables.def_span[def_id] <- tcx.def_span(def_id)); let def_span = tcx.def_span(local_id);
record!(self.tables.def_span[def_id] <- def_span);
self.encode_attrs(local_id); self.encode_attrs(local_id);
record!(self.tables.expn_that_defined[def_id] <- self.tcx.expn_that_defined(def_id)); record!(self.tables.expn_that_defined[def_id] <- self.tcx.expn_that_defined(def_id));
if let Some(ident_span) = tcx.def_ident_span(def_id) { if let Some(ident_span) = tcx.def_ident_span(def_id) {
@ -1075,6 +1158,9 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
record_array!(self.tables.inferred_outlives_of[def_id] <- inferred_outlives); record_array!(self.tables.inferred_outlives_of[def_id] <- inferred_outlives);
} }
} }
if should_encode_type(tcx, local_id, def_kind) {
record!(self.tables.type_of[def_id] <- self.tcx.type_of(def_id));
}
if let DefKind::TyParam | DefKind::ConstParam = def_kind { if let DefKind::TyParam | DefKind::ConstParam = def_kind {
if let Some(default) = self.tcx.object_lifetime_default(def_id) { if let Some(default) = self.tcx.object_lifetime_default(def_id) {
record!(self.tables.object_lifetime_default[def_id] <- default); record!(self.tables.object_lifetime_default[def_id] <- default);
@ -1096,11 +1182,6 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
} }
} }
fn encode_item_type(&mut self, def_id: DefId) {
debug!("EncodeContext::encode_item_type({:?})", def_id);
record!(self.tables.type_of[def_id] <- self.tcx.type_of(def_id));
}
fn encode_enum_variant_info(&mut self, def: ty::AdtDef<'tcx>, index: VariantIdx) { fn encode_enum_variant_info(&mut self, def: ty::AdtDef<'tcx>, index: VariantIdx) {
let tcx = self.tcx; let tcx = self.tcx;
let variant = &def.variant(index); let variant = &def.variant(index);
@ -1114,13 +1195,12 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
is_non_exhaustive: variant.is_field_list_non_exhaustive(), is_non_exhaustive: variant.is_field_list_non_exhaustive(),
}; };
record!(self.tables.kind[def_id] <- EntryKind::Variant(self.lazy(data))); record!(self.tables.variant_data[def_id] <- data);
self.tables.constness.set(def_id.index, hir::Constness::Const); self.tables.constness.set(def_id.index, hir::Constness::Const);
record_array!(self.tables.children[def_id] <- variant.fields.iter().map(|f| { record_array!(self.tables.children[def_id] <- variant.fields.iter().map(|f| {
assert!(f.did.is_local()); assert!(f.did.is_local());
f.did.index f.did.index
})); }));
self.encode_item_type(def_id);
if variant.ctor_kind == CtorKind::Fn { if variant.ctor_kind == CtorKind::Fn {
// FIXME(eddyb) encode signature only in `encode_enum_variant_ctor`. // FIXME(eddyb) encode signature only in `encode_enum_variant_ctor`.
if let Some(ctor_def_id) = variant.ctor_def_id { if let Some(ctor_def_id) = variant.ctor_def_id {
@ -1143,9 +1223,8 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
is_non_exhaustive: variant.is_field_list_non_exhaustive(), is_non_exhaustive: variant.is_field_list_non_exhaustive(),
}; };
record!(self.tables.kind[def_id] <- EntryKind::Variant(self.lazy(data))); record!(self.tables.variant_data[def_id] <- data);
self.tables.constness.set(def_id.index, hir::Constness::Const); self.tables.constness.set(def_id.index, hir::Constness::Const);
self.encode_item_type(def_id);
if variant.ctor_kind == CtorKind::Fn { if variant.ctor_kind == CtorKind::Fn {
record!(self.tables.fn_sig[def_id] <- tcx.fn_sig(def_id)); record!(self.tables.fn_sig[def_id] <- tcx.fn_sig(def_id));
} }
@ -1162,15 +1241,12 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
// code uses it). However, we skip encoding anything relating to child // code uses it). However, we skip encoding anything relating to child
// items - we encode information about proc-macros later on. // items - we encode information about proc-macros later on.
let reexports = if !self.is_proc_macro { let reexports = if !self.is_proc_macro {
match tcx.module_reexports(local_def_id) { tcx.module_reexports(local_def_id).unwrap_or(&[])
Some(exports) => self.lazy_array(exports),
_ => LazyArray::empty(),
}
} else { } else {
LazyArray::empty() &[]
}; };
record!(self.tables.kind[def_id] <- EntryKind::Mod(reexports)); record_array!(self.tables.module_reexports[def_id] <- reexports);
if self.is_proc_macro { if self.is_proc_macro {
// Encode this here because we don't do it in encode_def_ids. // Encode this here because we don't do it in encode_def_ids.
record!(self.tables.expn_that_defined[def_id] <- tcx.expn_that_defined(local_def_id)); record!(self.tables.expn_that_defined[def_id] <- tcx.expn_that_defined(local_def_id));
@ -1198,22 +1274,6 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
} }
} }
fn encode_field(
&mut self,
adt_def: ty::AdtDef<'tcx>,
variant_index: VariantIdx,
field_index: usize,
) {
let variant = &adt_def.variant(variant_index);
let field = &variant.fields[field_index];
let def_id = field.did;
debug!("EncodeContext::encode_field({:?})", def_id);
record!(self.tables.kind[def_id] <- EntryKind::Field);
self.encode_item_type(def_id);
}
fn encode_struct_ctor(&mut self, adt_def: ty::AdtDef<'tcx>, def_id: DefId) { fn encode_struct_ctor(&mut self, adt_def: ty::AdtDef<'tcx>, def_id: DefId) {
debug!("EncodeContext::encode_struct_ctor({:?})", def_id); debug!("EncodeContext::encode_struct_ctor({:?})", def_id);
let tcx = self.tcx; let tcx = self.tcx;
@ -1227,9 +1287,8 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
}; };
record!(self.tables.repr_options[def_id] <- adt_def.repr()); record!(self.tables.repr_options[def_id] <- adt_def.repr());
record!(self.tables.variant_data[def_id] <- data);
self.tables.constness.set(def_id.index, hir::Constness::Const); self.tables.constness.set(def_id.index, hir::Constness::Const);
record!(self.tables.kind[def_id] <- EntryKind::Struct(self.lazy(data)));
self.encode_item_type(def_id);
if variant.ctor_kind == CtorKind::Fn { if variant.ctor_kind == CtorKind::Fn {
record!(self.tables.fn_sig[def_id] <- tcx.fn_sig(def_id)); record!(self.tables.fn_sig[def_id] <- tcx.fn_sig(def_id));
} }
@ -1250,18 +1309,10 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
let ast_item = tcx.hir().expect_trait_item(def_id.expect_local()); let ast_item = tcx.hir().expect_trait_item(def_id.expect_local());
self.tables.impl_defaultness.set(def_id.index, ast_item.defaultness); self.tables.impl_defaultness.set(def_id.index, ast_item.defaultness);
let trait_item = tcx.associated_item(def_id); let trait_item = tcx.associated_item(def_id);
self.tables.assoc_container.set(def_id.index, trait_item.container);
match trait_item.kind { match trait_item.kind {
ty::AssocKind::Const => { ty::AssocKind::Const => {}
let rendered = rustc_hir_pretty::to_string(
&(&self.tcx.hir() as &dyn intravisit::Map<'_>),
|s| s.print_trait_item(ast_item),
);
record!(self.tables.kind[def_id] <- EntryKind::AssocConst(ty::AssocItemContainer::TraitContainer));
record!(self.tables.mir_const_qualif[def_id] <- mir::ConstQualifs::default());
record!(self.tables.rendered_const[def_id] <- rendered);
}
ty::AssocKind::Fn => { ty::AssocKind::Fn => {
let hir::TraitItemKind::Fn(m_sig, m) = &ast_item.kind else { bug!() }; let hir::TraitItemKind::Fn(m_sig, m) = &ast_item.kind else { bug!() };
match *m { match *m {
@ -1274,24 +1325,9 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
}; };
self.tables.asyncness.set(def_id.index, m_sig.header.asyncness); self.tables.asyncness.set(def_id.index, m_sig.header.asyncness);
self.tables.constness.set(def_id.index, hir::Constness::NotConst); self.tables.constness.set(def_id.index, hir::Constness::NotConst);
record!(self.tables.kind[def_id] <- EntryKind::AssocFn {
container: ty::AssocItemContainer::TraitContainer,
has_self: trait_item.fn_has_self_parameter,
});
} }
ty::AssocKind::Type => { ty::AssocKind::Type => {
self.encode_explicit_item_bounds(def_id); self.encode_explicit_item_bounds(def_id);
record!(self.tables.kind[def_id] <- EntryKind::AssocType(ty::AssocItemContainer::TraitContainer));
}
}
match trait_item.kind {
ty::AssocKind::Const | ty::AssocKind::Fn => {
self.encode_item_type(def_id);
}
ty::AssocKind::Type => {
if ast_item.defaultness.has_value() {
self.encode_item_type(def_id);
}
} }
} }
if trait_item.kind == ty::AssocKind::Fn { if trait_item.kind == ty::AssocKind::Fn {
@ -1306,20 +1342,9 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
let ast_item = self.tcx.hir().expect_impl_item(def_id.expect_local()); let ast_item = self.tcx.hir().expect_impl_item(def_id.expect_local());
self.tables.impl_defaultness.set(def_id.index, ast_item.defaultness); self.tables.impl_defaultness.set(def_id.index, ast_item.defaultness);
let impl_item = self.tcx.associated_item(def_id); let impl_item = self.tcx.associated_item(def_id);
self.tables.assoc_container.set(def_id.index, impl_item.container);
match impl_item.kind { match impl_item.kind {
ty::AssocKind::Const => {
if let hir::ImplItemKind::Const(_, body_id) = ast_item.kind {
let qualifs = self.tcx.at(ast_item.span).mir_const_qualif(def_id);
let const_data = self.encode_rendered_const_for_body(body_id);
record!(self.tables.kind[def_id] <- EntryKind::AssocConst(ty::AssocItemContainer::ImplContainer));
record!(self.tables.mir_const_qualif[def_id] <- qualifs);
record!(self.tables.rendered_const[def_id] <- const_data);
} else {
bug!()
}
}
ty::AssocKind::Fn => { ty::AssocKind::Fn => {
let hir::ImplItemKind::Fn(ref sig, body) = ast_item.kind else { bug!() }; let hir::ImplItemKind::Fn(ref sig, body) = ast_item.kind else { bug!() };
self.tables.asyncness.set(def_id.index, sig.header.asyncness); self.tables.asyncness.set(def_id.index, sig.header.asyncness);
@ -1331,16 +1356,9 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
hir::Constness::NotConst hir::Constness::NotConst
}; };
self.tables.constness.set(def_id.index, constness); self.tables.constness.set(def_id.index, constness);
record!(self.tables.kind[def_id] <- EntryKind::AssocFn {
container: ty::AssocItemContainer::ImplContainer,
has_self: impl_item.fn_has_self_parameter,
});
}
ty::AssocKind::Type => {
record!(self.tables.kind[def_id] <- EntryKind::AssocType(ty::AssocItemContainer::ImplContainer));
} }
ty::AssocKind::Const | ty::AssocKind::Type => {}
} }
self.encode_item_type(def_id);
if let Some(trait_item_def_id) = impl_item.trait_item_def_id { if let Some(trait_item_def_id) = impl_item.trait_item_def_id {
self.tables.trait_item_def_id.set(def_id.index, trait_item_def_id.into()); self.tables.trait_item_def_id.set(def_id.index, trait_item_def_id.into());
} }
@ -1357,12 +1375,13 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
return; return;
} }
let keys_and_jobs = self let tcx = self.tcx;
.tcx
let keys_and_jobs = tcx
.mir_keys(()) .mir_keys(())
.iter() .iter()
.filter_map(|&def_id| { .filter_map(|&def_id| {
let (encode_const, encode_opt) = should_encode_mir(self.tcx, def_id); let (encode_const, encode_opt) = should_encode_mir(tcx, def_id);
if encode_const || encode_opt { if encode_const || encode_opt {
Some((def_id, encode_const, encode_opt)) Some((def_id, encode_const, encode_opt))
} else { } else {
@ -1375,22 +1394,32 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
debug!("EntryBuilder::encode_mir({:?})", def_id); debug!("EntryBuilder::encode_mir({:?})", def_id);
if encode_opt { if encode_opt {
record!(self.tables.optimized_mir[def_id.to_def_id()] <- self.tcx.optimized_mir(def_id)); record!(self.tables.optimized_mir[def_id.to_def_id()] <- tcx.optimized_mir(def_id));
} }
if encode_const { if encode_const {
record!(self.tables.mir_for_ctfe[def_id.to_def_id()] <- self.tcx.mir_for_ctfe(def_id)); record!(self.tables.mir_for_ctfe[def_id.to_def_id()] <- tcx.mir_for_ctfe(def_id));
// FIXME(generic_const_exprs): this feels wrong to have in `encode_mir` // FIXME(generic_const_exprs): this feels wrong to have in `encode_mir`
let abstract_const = self.tcx.thir_abstract_const(def_id); let abstract_const = tcx.thir_abstract_const(def_id);
if let Ok(Some(abstract_const)) = abstract_const { if let Ok(Some(abstract_const)) = abstract_const {
record!(self.tables.thir_abstract_const[def_id.to_def_id()] <- abstract_const); record!(self.tables.thir_abstract_const[def_id.to_def_id()] <- abstract_const);
} }
if should_encode_const(tcx.def_kind(def_id)) {
let qualifs = tcx.mir_const_qualif(def_id);
record!(self.tables.mir_const_qualif[def_id.to_def_id()] <- qualifs);
let body_id = tcx.hir().maybe_body_owned_by(def_id);
if let Some(body_id) = body_id {
let const_data = self.encode_rendered_const_for_body(body_id);
record!(self.tables.rendered_const[def_id.to_def_id()] <- const_data);
}
}
} }
record!(self.tables.promoted_mir[def_id.to_def_id()] <- self.tcx.promoted_mir(def_id)); record!(self.tables.promoted_mir[def_id.to_def_id()] <- tcx.promoted_mir(def_id));
let instance = let instance =
ty::InstanceDef::Item(ty::WithOptConstParam::unknown(def_id.to_def_id())); ty::InstanceDef::Item(ty::WithOptConstParam::unknown(def_id.to_def_id()));
let unused = self.tcx.unused_generic_params(instance); let unused = tcx.unused_generic_params(instance);
if !unused.is_empty() { if !unused.is_empty() {
record!(self.tables.unused_generic_params[def_id.to_def_id()] <- unused); record!(self.tables.unused_generic_params[def_id.to_def_id()] <- unused);
} }
@ -1453,38 +1482,27 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
debug!("EncodeContext::encode_info_for_item({:?})", def_id); debug!("EncodeContext::encode_info_for_item({:?})", def_id);
let entry_kind = match item.kind { match item.kind {
hir::ItemKind::Static(..) => EntryKind::Static,
hir::ItemKind::Const(_, body_id) => {
let qualifs = self.tcx.at(item.span).mir_const_qualif(def_id);
let const_data = self.encode_rendered_const_for_body(body_id);
record!(self.tables.mir_const_qualif[def_id] <- qualifs);
record!(self.tables.rendered_const[def_id] <- const_data);
EntryKind::Const
}
hir::ItemKind::Fn(ref sig, .., body) => { hir::ItemKind::Fn(ref sig, .., body) => {
self.tables.asyncness.set(def_id.index, sig.header.asyncness); self.tables.asyncness.set(def_id.index, sig.header.asyncness);
record_array!(self.tables.fn_arg_names[def_id] <- self.tcx.hir().body_param_names(body)); record_array!(self.tables.fn_arg_names[def_id] <- self.tcx.hir().body_param_names(body));
self.tables.constness.set(def_id.index, sig.header.constness); self.tables.constness.set(def_id.index, sig.header.constness);
EntryKind::Fn
} }
hir::ItemKind::Macro(ref macro_def, _) => { hir::ItemKind::Macro(ref macro_def, _) => {
EntryKind::MacroDef(self.lazy(&*macro_def.body), macro_def.macro_rules) if macro_def.macro_rules {
self.tables.macro_rules.set(def_id.index, ());
}
record!(self.tables.macro_definition[def_id] <- &*macro_def.body);
} }
hir::ItemKind::Mod(ref m) => { hir::ItemKind::Mod(ref m) => {
return self.encode_info_for_mod(item.def_id, m); return self.encode_info_for_mod(item.def_id, m);
} }
hir::ItemKind::ForeignMod { .. } => EntryKind::ForeignMod,
hir::ItemKind::GlobalAsm(..) => EntryKind::GlobalAsm,
hir::ItemKind::TyAlias(..) => EntryKind::Type,
hir::ItemKind::OpaqueTy(..) => { hir::ItemKind::OpaqueTy(..) => {
self.encode_explicit_item_bounds(def_id); self.encode_explicit_item_bounds(def_id);
EntryKind::OpaqueTy
} }
hir::ItemKind::Enum(..) => { hir::ItemKind::Enum(..) => {
let adt_def = self.tcx.adt_def(def_id); let adt_def = self.tcx.adt_def(def_id);
record!(self.tables.repr_options[def_id] <- adt_def.repr()); record!(self.tables.repr_options[def_id] <- adt_def.repr());
EntryKind::Enum
} }
hir::ItemKind::Struct(ref struct_def, _) => { hir::ItemKind::Struct(ref struct_def, _) => {
let adt_def = self.tcx.adt_def(def_id); let adt_def = self.tcx.adt_def(def_id);
@ -1499,24 +1517,24 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
.map(|ctor_hir_id| self.tcx.hir().local_def_id(ctor_hir_id).local_def_index); .map(|ctor_hir_id| self.tcx.hir().local_def_id(ctor_hir_id).local_def_index);
let variant = adt_def.non_enum_variant(); let variant = adt_def.non_enum_variant();
EntryKind::Struct(self.lazy(VariantData { record!(self.tables.variant_data[def_id] <- VariantData {
ctor_kind: variant.ctor_kind, ctor_kind: variant.ctor_kind,
discr: variant.discr, discr: variant.discr,
ctor, ctor,
is_non_exhaustive: variant.is_field_list_non_exhaustive(), is_non_exhaustive: variant.is_field_list_non_exhaustive(),
})) });
} }
hir::ItemKind::Union(..) => { hir::ItemKind::Union(..) => {
let adt_def = self.tcx.adt_def(def_id); let adt_def = self.tcx.adt_def(def_id);
record!(self.tables.repr_options[def_id] <- adt_def.repr()); record!(self.tables.repr_options[def_id] <- adt_def.repr());
let variant = adt_def.non_enum_variant(); let variant = adt_def.non_enum_variant();
EntryKind::Union(self.lazy(VariantData { record!(self.tables.variant_data[def_id] <- VariantData {
ctor_kind: variant.ctor_kind, ctor_kind: variant.ctor_kind,
discr: variant.discr, discr: variant.discr,
ctor: None, ctor: None,
is_non_exhaustive: variant.is_field_list_non_exhaustive(), is_non_exhaustive: variant.is_field_list_non_exhaustive(),
})) });
} }
hir::ItemKind::Impl(hir::Impl { defaultness, constness, .. }) => { hir::ItemKind::Impl(hir::Impl { defaultness, constness, .. }) => {
self.tables.impl_defaultness.set(def_id.index, *defaultness); self.tables.impl_defaultness.set(def_id.index, *defaultness);
@ -1542,26 +1560,24 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
let polarity = self.tcx.impl_polarity(def_id); let polarity = self.tcx.impl_polarity(def_id);
self.tables.impl_polarity.set(def_id.index, polarity); self.tables.impl_polarity.set(def_id.index, polarity);
EntryKind::Impl
} }
hir::ItemKind::Trait(..) => { hir::ItemKind::Trait(..) => {
let trait_def = self.tcx.trait_def(def_id); let trait_def = self.tcx.trait_def(def_id);
record!(self.tables.trait_def[def_id] <- trait_def); record!(self.tables.trait_def[def_id] <- trait_def);
EntryKind::Trait
} }
hir::ItemKind::TraitAlias(..) => { hir::ItemKind::TraitAlias(..) => {
let trait_def = self.tcx.trait_def(def_id); let trait_def = self.tcx.trait_def(def_id);
record!(self.tables.trait_def[def_id] <- trait_def); record!(self.tables.trait_def[def_id] <- trait_def);
EntryKind::TraitAlias
} }
hir::ItemKind::ExternCrate(_) | hir::ItemKind::Use(..) => { hir::ItemKind::ExternCrate(_) | hir::ItemKind::Use(..) => {
bug!("cannot encode info for item {:?}", item) bug!("cannot encode info for item {:?}", item)
} }
hir::ItemKind::Static(..)
| hir::ItemKind::Const(..)
| hir::ItemKind::ForeignMod { .. }
| hir::ItemKind::GlobalAsm(..)
| hir::ItemKind::TyAlias(..) => {}
}; };
record!(self.tables.kind[def_id] <- entry_kind);
// FIXME(eddyb) there should be a nicer way to do this. // FIXME(eddyb) there should be a nicer way to do this.
match item.kind { match item.kind {
hir::ItemKind::Enum(..) => record_array!(self.tables.children[def_id] <- hir::ItemKind::Enum(..) => record_array!(self.tables.children[def_id] <-
@ -1589,18 +1605,6 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
} }
_ => {} _ => {}
} }
match item.kind {
hir::ItemKind::Static(..)
| hir::ItemKind::Const(..)
| hir::ItemKind::Fn(..)
| hir::ItemKind::TyAlias(..)
| hir::ItemKind::OpaqueTy(..)
| hir::ItemKind::Enum(..)
| hir::ItemKind::Struct(..)
| hir::ItemKind::Union(..)
| hir::ItemKind::Impl { .. } => self.encode_item_type(def_id),
_ => {}
}
if let hir::ItemKind::Fn(..) = item.kind { if let hir::ItemKind::Fn(..) = item.kind {
record!(self.tables.fn_sig[def_id] <- tcx.fn_sig(def_id)); record!(self.tables.fn_sig[def_id] <- tcx.fn_sig(def_id));
if tcx.is_intrinsic(def_id) { if tcx.is_intrinsic(def_id) {
@ -1612,12 +1616,43 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
record!(self.tables.impl_trait_ref[def_id] <- trait_ref); record!(self.tables.impl_trait_ref[def_id] <- trait_ref);
} }
} }
} // In some cases, along with the item itself, we also
// encode some sub-items. Usually we want some info from the item
// so it's easier to do that here then to wait until we would encounter
// normally in the visitor walk.
match item.kind {
hir::ItemKind::Enum(..) => {
let def = self.tcx.adt_def(item.def_id.to_def_id());
for (i, variant) in def.variants().iter_enumerated() {
self.encode_enum_variant_info(def, i);
fn encode_info_for_generic_param(&mut self, def_id: DefId, kind: EntryKind, encode_type: bool) { if let Some(_ctor_def_id) = variant.ctor_def_id {
record!(self.tables.kind[def_id] <- kind); self.encode_enum_variant_ctor(def, i);
if encode_type { }
self.encode_item_type(def_id); }
}
hir::ItemKind::Struct(ref struct_def, _) => {
let def = self.tcx.adt_def(item.def_id.to_def_id());
// If the struct has a constructor, encode it.
if let Some(ctor_hir_id) = struct_def.ctor_hir_id() {
let ctor_def_id = self.tcx.hir().local_def_id(ctor_hir_id);
self.encode_struct_ctor(def, ctor_def_id.to_def_id());
}
}
hir::ItemKind::Impl { .. } => {
for &trait_item_def_id in
self.tcx.associated_item_def_ids(item.def_id.to_def_id()).iter()
{
self.encode_info_for_impl_item(trait_item_def_id);
}
}
hir::ItemKind::Trait(..) => {
for &item_def_id in self.tcx.associated_item_def_ids(item.def_id.to_def_id()).iter()
{
self.encode_info_for_trait_item(item_def_id);
}
}
_ => {}
} }
} }
@ -1632,34 +1667,16 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
ty::Generator(..) => { ty::Generator(..) => {
let data = self.tcx.generator_kind(def_id).unwrap(); let data = self.tcx.generator_kind(def_id).unwrap();
let generator_diagnostic_data = typeck_result.get_generator_diagnostic_data(); let generator_diagnostic_data = typeck_result.get_generator_diagnostic_data();
record!(self.tables.kind[def_id.to_def_id()] <- EntryKind::Generator);
record!(self.tables.generator_kind[def_id.to_def_id()] <- data); record!(self.tables.generator_kind[def_id.to_def_id()] <- data);
record!(self.tables.generator_diagnostic_data[def_id.to_def_id()] <- generator_diagnostic_data); record!(self.tables.generator_diagnostic_data[def_id.to_def_id()] <- generator_diagnostic_data);
} }
ty::Closure(..) => { ty::Closure(_, substs) => {
record!(self.tables.kind[def_id.to_def_id()] <- EntryKind::Closure); record!(self.tables.fn_sig[def_id.to_def_id()] <- substs.as_closure().sig());
} }
_ => bug!("closure that is neither generator nor closure"), _ => bug!("closure that is neither generator nor closure"),
} }
self.encode_item_type(def_id.to_def_id());
if let ty::Closure(def_id, substs) = *ty.kind() {
record!(self.tables.fn_sig[def_id] <- substs.as_closure().sig());
}
}
fn encode_info_for_anon_const(&mut self, id: hir::HirId) {
let def_id = self.tcx.hir().local_def_id(id);
debug!("EncodeContext::encode_info_for_anon_const({:?})", def_id);
let body_id = self.tcx.hir().body_owned_by(def_id);
let const_data = self.encode_rendered_const_for_body(body_id);
let qualifs = self.tcx.mir_const_qualif(def_id);
record!(self.tables.kind[def_id.to_def_id()] <- EntryKind::AnonConst);
record!(self.tables.mir_const_qualif[def_id.to_def_id()] <- qualifs);
record!(self.tables.rendered_const[def_id.to_def_id()] <- const_data);
self.encode_item_type(def_id.to_def_id());
} }
fn encode_native_libraries(&mut self) -> LazyArray<NativeLib> { fn encode_native_libraries(&mut self) -> LazyArray<NativeLib> {
@ -1757,7 +1774,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
let def_id = id.to_def_id(); let def_id = id.to_def_id();
self.tables.opt_def_kind.set(def_id.index, DefKind::Macro(macro_kind)); self.tables.opt_def_kind.set(def_id.index, DefKind::Macro(macro_kind));
record!(self.tables.kind[def_id] <- EntryKind::ProcMacro(macro_kind)); self.tables.proc_macro.set(def_id.index, macro_kind);
self.encode_attrs(id); self.encode_attrs(id);
record!(self.tables.def_keys[def_id] <- def_key); record!(self.tables.def_keys[def_id] <- def_key);
record!(self.tables.def_ident_span[def_id] <- span); record!(self.tables.def_ident_span[def_id] <- span);
@ -1995,18 +2012,11 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
hir::Constness::NotConst hir::Constness::NotConst
}; };
self.tables.constness.set(def_id.index, constness); self.tables.constness.set(def_id.index, constness);
record!(self.tables.kind[def_id] <- EntryKind::ForeignFn); record!(self.tables.fn_sig[def_id] <- tcx.fn_sig(def_id));
}
hir::ForeignItemKind::Static(..) => {
record!(self.tables.kind[def_id] <- EntryKind::ForeignStatic);
}
hir::ForeignItemKind::Type => {
record!(self.tables.kind[def_id] <- EntryKind::ForeignType);
} }
hir::ForeignItemKind::Static(..) | hir::ForeignItemKind::Type => {}
} }
self.encode_item_type(def_id);
if let hir::ForeignItemKind::Fn(..) = nitem.kind { if let hir::ForeignItemKind::Fn(..) = nitem.kind {
record!(self.tables.fn_sig[def_id] <- tcx.fn_sig(def_id));
if tcx.is_intrinsic(def_id) { if tcx.is_intrinsic(def_id) {
self.tables.is_intrinsic.set(def_id.index, ()); self.tables.is_intrinsic.set(def_id.index, ());
} }
@ -2025,17 +2035,12 @@ impl<'a, 'tcx> Visitor<'tcx> for EncodeContext<'a, 'tcx> {
intravisit::walk_expr(self, ex); intravisit::walk_expr(self, ex);
self.encode_info_for_expr(ex); self.encode_info_for_expr(ex);
} }
fn visit_anon_const(&mut self, c: &'tcx AnonConst) {
intravisit::walk_anon_const(self, c);
self.encode_info_for_anon_const(c.hir_id);
}
fn visit_item(&mut self, item: &'tcx hir::Item<'tcx>) { fn visit_item(&mut self, item: &'tcx hir::Item<'tcx>) {
intravisit::walk_item(self, item); intravisit::walk_item(self, item);
match item.kind { match item.kind {
hir::ItemKind::ExternCrate(_) | hir::ItemKind::Use(..) => {} // ignore these hir::ItemKind::ExternCrate(_) | hir::ItemKind::Use(..) => {} // ignore these
_ => self.encode_info_for_item(item.def_id.to_def_id(), item), _ => self.encode_info_for_item(item.def_id.to_def_id(), item),
} }
self.encode_addl_info_for_item(item);
} }
fn visit_foreign_item(&mut self, ni: &'tcx hir::ForeignItem<'tcx>) { fn visit_foreign_item(&mut self, ni: &'tcx hir::ForeignItem<'tcx>) {
intravisit::walk_foreign_item(self, ni); intravisit::walk_foreign_item(self, ni);
@ -2048,29 +2053,13 @@ impl<'a, 'tcx> Visitor<'tcx> for EncodeContext<'a, 'tcx> {
} }
impl<'a, 'tcx> EncodeContext<'a, 'tcx> { impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
fn encode_fields(&mut self, adt_def: ty::AdtDef<'tcx>) {
for (variant_index, variant) in adt_def.variants().iter_enumerated() {
for (field_index, _field) in variant.fields.iter().enumerate() {
self.encode_field(adt_def, variant_index, field_index);
}
}
}
fn encode_info_for_generics(&mut self, generics: &hir::Generics<'tcx>) { fn encode_info_for_generics(&mut self, generics: &hir::Generics<'tcx>) {
for param in generics.params { for param in generics.params {
let def_id = self.tcx.hir().local_def_id(param.hir_id); let def_id = self.tcx.hir().local_def_id(param.hir_id);
match param.kind { match param.kind {
GenericParamKind::Lifetime { .. } => continue, hir::GenericParamKind::Lifetime { .. } | hir::GenericParamKind::Type { .. } => {}
GenericParamKind::Type { default, .. } => { hir::GenericParamKind::Const { ref default, .. } => {
self.encode_info_for_generic_param(
def_id.to_def_id(),
EntryKind::TypeParam,
default.is_some(),
);
}
GenericParamKind::Const { ref default, .. } => {
let def_id = def_id.to_def_id(); let def_id = def_id.to_def_id();
self.encode_info_for_generic_param(def_id, EntryKind::ConstParam, true);
if default.is_some() { if default.is_some() {
record!(self.tables.const_param_default[def_id] <- self.tcx.const_param_default(def_id)) record!(self.tables.const_param_default[def_id] <- self.tcx.const_param_default(def_id))
} }
@ -2084,68 +2073,6 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
self.encode_info_for_closure(expr.hir_id); self.encode_info_for_closure(expr.hir_id);
} }
} }
/// In some cases, along with the item itself, we also
/// encode some sub-items. Usually we want some info from the item
/// so it's easier to do that here then to wait until we would encounter
/// normally in the visitor walk.
fn encode_addl_info_for_item(&mut self, item: &hir::Item<'_>) {
match item.kind {
hir::ItemKind::Static(..)
| hir::ItemKind::Const(..)
| hir::ItemKind::Fn(..)
| hir::ItemKind::Macro(..)
| hir::ItemKind::Mod(..)
| hir::ItemKind::ForeignMod { .. }
| hir::ItemKind::GlobalAsm(..)
| hir::ItemKind::ExternCrate(..)
| hir::ItemKind::Use(..)
| hir::ItemKind::TyAlias(..)
| hir::ItemKind::OpaqueTy(..)
| hir::ItemKind::TraitAlias(..) => {
// no sub-item recording needed in these cases
}
hir::ItemKind::Enum(..) => {
let def = self.tcx.adt_def(item.def_id.to_def_id());
self.encode_fields(def);
for (i, variant) in def.variants().iter_enumerated() {
self.encode_enum_variant_info(def, i);
if let Some(_ctor_def_id) = variant.ctor_def_id {
self.encode_enum_variant_ctor(def, i);
}
}
}
hir::ItemKind::Struct(ref struct_def, _) => {
let def = self.tcx.adt_def(item.def_id.to_def_id());
self.encode_fields(def);
// If the struct has a constructor, encode it.
if let Some(ctor_hir_id) = struct_def.ctor_hir_id() {
let ctor_def_id = self.tcx.hir().local_def_id(ctor_hir_id);
self.encode_struct_ctor(def, ctor_def_id.to_def_id());
}
}
hir::ItemKind::Union(..) => {
let def = self.tcx.adt_def(item.def_id.to_def_id());
self.encode_fields(def);
}
hir::ItemKind::Impl { .. } => {
for &trait_item_def_id in
self.tcx.associated_item_def_ids(item.def_id.to_def_id()).iter()
{
self.encode_info_for_impl_item(trait_item_def_id);
}
}
hir::ItemKind::Trait(..) => {
for &item_def_id in self.tcx.associated_item_def_ids(item.def_id.to_def_id()).iter()
{
self.encode_info_for_trait_item(item_def_id);
}
}
}
}
} }
/// Used to prefetch queries which will be needed later by metadata encoding. /// Used to prefetch queries which will be needed later by metadata encoding.

42
compiler/rustc_metadata/src/rmeta/mod.rs
View file

@ -334,7 +334,6 @@ macro_rules! define_tables {
} }
define_tables! { define_tables! {
kind: Table<DefIndex, LazyValue<EntryKind>>,
attributes: Table<DefIndex, LazyArray<ast::Attribute>>, attributes: Table<DefIndex, LazyArray<ast::Attribute>>,
children: Table<DefIndex, LazyArray<DefIndex>>, children: Table<DefIndex, LazyArray<DefIndex>>,
@ -393,39 +392,13 @@ define_tables! {
proc_macro_quoted_spans: Table<usize, LazyValue<Span>>, proc_macro_quoted_spans: Table<usize, LazyValue<Span>>,
generator_diagnostic_data: Table<DefIndex, LazyValue<GeneratorDiagnosticData<'static>>>, generator_diagnostic_data: Table<DefIndex, LazyValue<GeneratorDiagnosticData<'static>>>,
may_have_doc_links: Table<DefIndex, ()>, may_have_doc_links: Table<DefIndex, ()>,
} variant_data: Table<DefIndex, LazyValue<VariantData>>,
assoc_container: Table<DefIndex, ty::AssocItemContainer>,
#[derive(Copy, Clone, MetadataEncodable, MetadataDecodable)] // Slot is full when macro is macro_rules.
enum EntryKind { macro_rules: Table<DefIndex, ()>,
AnonConst, macro_definition: Table<DefIndex, LazyValue<ast::MacArgs>>,
Const, proc_macro: Table<DefIndex, MacroKind>,
Static, module_reexports: Table<DefIndex, LazyArray<ModChild>>,
ForeignStatic,
ForeignMod,
ForeignType,
GlobalAsm,
Type,
TypeParam,
ConstParam,
OpaqueTy,
Enum,
Field,
Variant(LazyValue<VariantData>),
Struct(LazyValue<VariantData>),
Union(LazyValue<VariantData>),
Fn,
ForeignFn,
Mod(LazyArray<ModChild>),
MacroDef(LazyValue<ast::MacArgs>, /*macro_rules*/ bool),
ProcMacro(MacroKind),
Closure,
Generator,
Trait,
Impl,
AssocFn { container: ty::AssocItemContainer, has_self: bool },
AssocType(ty::AssocItemContainer),
AssocConst(ty::AssocItemContainer),
TraitAlias,
} }
#[derive(TyEncodable, TyDecodable)] #[derive(TyEncodable, TyDecodable)]
@ -459,7 +432,6 @@ pub fn provide(providers: &mut Providers) {
trivially_parameterized_over_tcx! { trivially_parameterized_over_tcx! {
VariantData, VariantData,
EntryKind,
RawDefId, RawDefId,
TraitImpls, TraitImpls,
IncoherentImpls, IncoherentImpls,

17
compiler/rustc_metadata/src/rmeta/table.rs
View file

@ -50,7 +50,7 @@ macro_rules! fixed_size_enum {
} }
match b[0] - 1 { match b[0] - 1 {
$(${index()} => Some($($pat)*),)* $(${index()} => Some($($pat)*),)*
_ => panic!("Unexpected ImplPolarity code: {:?}", b[0]), _ => panic!("Unexpected {} code: {:?}", stringify!($ty), b[0]),
} }
} }
@ -140,6 +140,21 @@ fixed_size_enum! {
} }
} }
fixed_size_enum! {
ty::AssocItemContainer {
( TraitContainer )
( ImplContainer )
}
}
fixed_size_enum! {
MacroKind {
( Attr )
( Bang )
( Derive )
}
}
// We directly encode `DefPathHash` because a `LazyValue` would incur a 25% cost. // We directly encode `DefPathHash` because a `LazyValue` would incur a 25% cost.
impl FixedSizeEncoding for Option<DefPathHash> { impl FixedSizeEncoding for Option<DefPathHash> {
type ByteArray = [u8; 16]; type ByteArray = [u8; 16];

1
compiler/rustc_middle/src/ty/parameterized.rs
View file

@ -55,6 +55,7 @@ trivially_parameterized_over_tcx! {
crate::middle::exported_symbols::SymbolExportInfo, crate::middle::exported_symbols::SymbolExportInfo,
crate::middle::resolve_lifetime::ObjectLifetimeDefault, crate::middle::resolve_lifetime::ObjectLifetimeDefault,
crate::mir::ConstQualifs, crate::mir::ConstQualifs,
ty::AssocItemContainer,
ty::Generics, ty::Generics,
ty::ImplPolarity, ty::ImplPolarity,
ty::ReprOptions, ty::ReprOptions,

2
compiler/rustc_resolve/src/build_reduced_graph.rs
View file

@ -1029,7 +1029,7 @@ impl<'a, 'b> BuildReducedGraphVisitor<'a, 'b> {
self.insert_field_names(def_id, field_names); self.insert_field_names(def_id, field_names);
} }
Res::Def(DefKind::AssocFn, def_id) => { Res::Def(DefKind::AssocFn, def_id) => {
if cstore.fn_has_self_parameter_untracked(def_id) { if cstore.fn_has_self_parameter_untracked(def_id, self.r.session) {
self.r.has_self.insert(def_id); self.r.has_self.insert(def_id);
} }
} }