use rustc_middle::metadata::ModChild;
use rustc_middle::middle::exported_symbols::ExportedSymbol;
use rustc_middle::middle::stability::DeprecationEntry;
+use rustc_middle::query::LocalCrate;
use rustc_middle::ty::fast_reject::SimplifiedType;
use rustc_middle::ty::query::{ExternProviders, Providers};
-use rustc_middle::ty::{self, TyCtxt, Visibility};
-use rustc_session::cstore::{CrateSource, CrateStore};
+use rustc_middle::ty::{self, TyCtxt};
+use rustc_session::cstore::CrateStore;
use rustc_session::{Session, StableCrateId};
use rustc_span::hygiene::{ExpnHash, ExpnId};
-use rustc_span::source_map::{Span, Spanned};
use rustc_span::symbol::{kw, Symbol};
+use rustc_span::Span;
use rustc_data_structures::sync::Lrc;
use std::any::Any;
lookup_default_body_stability => { table }
lookup_deprecation_entry => { table }
params_in_repr => { table }
- unused_generic_params => { table }
+ unused_generic_params => { cdata.root.tables.unused_generic_params.get(cdata, def_id.index) }
opt_def_kind => { table_direct }
impl_parent => { table }
impl_polarity => { table_direct }
.get(cdata, def_id.index)
.map(|lazy| lazy.decode((cdata, tcx)))
.process_decoded(tcx, || panic!("{def_id:?} does not have trait_impl_trait_tys")))
- }
+ }
+ implied_predicates_of => {
+ cdata
+ .root
+ .tables
+ .implied_predicates_of
+ .get(cdata, def_id.index)
+ .map(|lazy| lazy.decode((cdata, tcx)))
+ .unwrap_or_else(|| {
+ debug_assert_eq!(tcx.def_kind(def_id), DefKind::Trait);
+ tcx.super_predicates_of(def_id)
+ })
+ }
- associated_items_for_impl_trait_in_trait => { table_defaulted_array }
+ associated_types_for_impl_traits_in_associated_fn => { table_defaulted_array }
visibility => { cdata.get_visibility(def_id.index) }
adt_def => { cdata.get_adt_def(def_id.index, tcx) }
*providers = Providers {
allocator_kind: |tcx, ()| CStore::from_tcx(tcx).allocator_kind(),
alloc_error_handler_kind: |tcx, ()| CStore::from_tcx(tcx).alloc_error_handler_kind(),
- is_private_dep: |_tcx, cnum| {
- assert_eq!(cnum, LOCAL_CRATE);
- false
- },
+ is_private_dep: |_tcx, LocalCrate| false,
native_library: |tcx, id| {
tcx.native_libraries(id.krate)
.iter()
.contains(&id)
})
},
- native_libraries: |tcx, cnum| {
- assert_eq!(cnum, LOCAL_CRATE);
- native_libs::collect(tcx)
- },
- foreign_modules: |tcx, cnum| {
- assert_eq!(cnum, LOCAL_CRATE);
+ native_libraries: |tcx, LocalCrate| native_libs::collect(tcx),
+ foreign_modules: |tcx, LocalCrate| {
foreign_modules::collect(tcx).into_iter().map(|m| (m.def_id, m)).collect()
},
},
dependency_formats: |tcx, ()| Lrc::new(crate::dependency_format::calculate(tcx)),
- has_global_allocator: |tcx, cnum| {
- assert_eq!(cnum, LOCAL_CRATE);
- CStore::from_tcx(tcx).has_global_allocator()
- },
- has_alloc_error_handler: |tcx, cnum| {
- assert_eq!(cnum, LOCAL_CRATE);
- CStore::from_tcx(tcx).has_alloc_error_handler()
- },
+ has_global_allocator: |tcx, LocalCrate| CStore::from_tcx(tcx).has_global_allocator(),
+ has_alloc_error_handler: |tcx, LocalCrate| CStore::from_tcx(tcx).has_alloc_error_handler(),
postorder_cnums: |tcx, ()| {
tcx.arena
.alloc_slice(&CStore::from_tcx(tcx).crate_dependencies_in_postorder(LOCAL_CRATE))
},
- crates: |tcx, ()| tcx.arena.alloc_from_iter(CStore::from_tcx(tcx).crates_untracked()),
+ crates: |tcx, ()| {
+ // The list of loaded crates is now frozen in query cache,
+ // so make sure cstore is not mutably accessed from here on.
+ tcx.untracked().cstore.leak();
+ tcx.arena.alloc_from_iter(CStore::from_tcx(tcx).iter_crate_data().map(|(cnum, _)| cnum))
+ },
..*providers
};
}
impl CStore {
- pub fn struct_field_names_untracked<'a>(
- &'a self,
- def: DefId,
- sess: &'a Session,
- ) -> impl Iterator<Item = Spanned<Symbol>> + 'a {
- self.get_crate_data(def.krate).get_struct_field_names(def.index, sess)
- }
-
- pub fn struct_field_visibilities_untracked(
- &self,
- def: DefId,
- ) -> impl Iterator<Item = Visibility<DefId>> + '_ {
- self.get_crate_data(def.krate).get_struct_field_visibilities(def.index)
- }
-
pub fn ctor_untracked(&self, def: DefId) -> Option<(CtorKind, DefId)> {
self.get_crate_data(def.krate).get_ctor(def.index)
}
- pub fn visibility_untracked(&self, def: DefId) -> Visibility<DefId> {
- self.get_crate_data(def.krate).get_visibility(def.index)
- }
-
pub fn module_children_untracked<'a>(
&'a self,
def_id: DefId,
)
}
- 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, sess)
- }
-
- pub fn crate_source_untracked(&self, cnum: CrateNum) -> Lrc<CrateSource> {
- self.get_crate_data(cnum).source.clone()
- }
-
- pub fn get_span_untracked(&self, def_id: DefId, sess: &Session) -> Span {
+ pub fn def_span_untracked(&self, def_id: DefId, sess: &Session) -> Span {
self.get_crate_data(def_id.krate).get_span(def_id.index, sess)
}
- pub fn def_kind(&self, def: DefId) -> DefKind {
+ pub fn def_kind_untracked(&self, def: DefId) -> DefKind {
self.get_crate_data(def.krate).def_kind(def.index)
}
- pub fn crates_untracked(&self) -> impl Iterator<Item = CrateNum> + '_ {
- self.iter_crate_data().map(|(cnum, _)| cnum)
- }
-
- pub fn item_generics_num_lifetimes(&self, def_id: DefId, sess: &Session) -> usize {
- self.get_crate_data(def_id.krate).get_generics(def_id.index, sess).own_counts().lifetimes
- }
-
- pub fn module_expansion_untracked(&self, def_id: DefId, sess: &Session) -> ExpnId {
- self.get_crate_data(def_id.krate).module_expansion(def_id.index, sess)
+ pub fn expn_that_defined_untracked(&self, def_id: DefId, sess: &Session) -> ExpnId {
+ self.get_crate_data(def_id.krate).get_expn_that_defined(def_id.index, sess)
}
/// Only public-facing way to traverse all the definitions in a non-local crate.
self.get_crate_data(cnum).num_def_ids()
}
- pub fn item_attrs_untracked<'a>(
- &'a self,
- def_id: DefId,
- sess: &'a Session,
- ) -> impl Iterator<Item = ast::Attribute> + 'a {
- self.get_crate_data(def_id.krate).get_item_attrs(def_id.index, sess)
- }
-
pub fn get_proc_macro_quoted_span_untracked(
&self,
cnum: CrateNum,
}
fn stable_crate_id_to_crate_num(&self, stable_crate_id: StableCrateId) -> CrateNum {
- self.stable_crate_ids[&stable_crate_id]
+ *self
+ .stable_crate_ids
+ .get(&stable_crate_id)
+ .unwrap_or_else(|| bug!("uninterned StableCrateId: {stable_crate_id:?}"))
}
/// Returns the `DefKey` for a given `DefId`. This indicates the
projects / rustc.git / blobdiff