[] NamedRegion(HirId),
[] IsLateBound(HirId),
[] ObjectLifetimeDefaults(HirId),
+
+ [] Visibility(DefId),
+ [] DepKind(CrateNum),
+ [] CrateName(CrateNum),
+ [] ItemChildren(DefId),
+ [] ExternModStmtCnum(HirId),
);
trait DepNodeParams<'a, 'gcx: 'tcx + 'a, 'tcx: 'a> : fmt::Debug {
// for imported and non-imported crates
if exp_path == found_path
|| exp_abs_path == found_abs_path {
- let crate_name = self.tcx.sess.cstore.crate_name(did1.krate);
+ let crate_name = self.tcx.crate_name(did1.krate);
err.span_note(sp, &format!("Perhaps two different versions \
of crate `{}` are being used?",
crate_name));
/// A store of Rust crates, through with their metadata
/// can be accessed.
+///
+/// Note that this trait should probably not be expanding today. All new
+/// functionality should be driven through queries instead!
+///
+/// If you find a method on this trait named `{name}_untracked` it signifies
+/// that it's *not* tracked for dependency information throughout compilation
+/// (it'd break incremental compilation) and should only be called pre-HIR (e.g.
+/// during resolve)
pub trait CrateStore {
fn crate_data_as_rc_any(&self, krate: CrateNum) -> Rc<Any>;
fn metadata_loader(&self) -> &MetadataLoader;
// item info
- fn visibility(&self, def: DefId) -> ty::Visibility;
fn visible_parent_map<'a>(&'a self, sess: &Session) -> ::std::cell::Ref<'a, DefIdMap<DefId>>;
fn item_generics_cloned(&self, def: DefId) -> ty::Generics;
fn associated_item_cloned(&self, def: DefId) -> ty::AssociatedItem;
// crate metadata
- fn dep_kind(&self, cnum: CrateNum) -> DepKind;
- fn export_macros(&self, cnum: CrateNum);
fn lang_items(&self, cnum: CrateNum) -> Vec<(DefIndex, usize)>;
fn missing_lang_items(&self, cnum: CrateNum) -> Vec<lang_items::LangItem>;
- /// The name of the crate as it is referred to in source code of the current
- /// crate.
- fn crate_name(&self, cnum: CrateNum) -> Symbol;
// resolve
fn def_key(&self, def: DefId) -> DefKey;
fn def_path(&self, def: DefId) -> hir_map::DefPath;
fn def_path_hash(&self, def: DefId) -> hir_map::DefPathHash;
fn def_path_table(&self, cnum: CrateNum) -> Rc<DefPathTable>;
- fn struct_field_names(&self, def: DefId) -> Vec<ast::Name>;
- fn item_children(&self, did: DefId, sess: &Session) -> Vec<def::Export>;
- fn load_macro(&self, did: DefId, sess: &Session) -> LoadedMacro;
+
+ // "queries" used in resolve that aren't tracked for incremental compilation
+ fn visibility_untracked(&self, def: DefId) -> ty::Visibility;
+ fn export_macros_untracked(&self, cnum: CrateNum);
+ fn dep_kind_untracked(&self, cnum: CrateNum) -> DepKind;
+ fn crate_name_untracked(&self, cnum: CrateNum) -> Symbol;
+ fn struct_field_names_untracked(&self, def: DefId) -> Vec<ast::Name>;
+ fn item_children_untracked(&self, did: DefId, sess: &Session) -> Vec<def::Export>;
+ fn load_macro_untracked(&self, did: DefId, sess: &Session) -> LoadedMacro;
+ fn extern_mod_stmt_cnum_untracked(&self, emod_id: ast::NodeId) -> Option<CrateNum>;
// misc. metadata
fn item_body<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, def: DefId)
// utility functions
fn used_crates(&self, prefer: LinkagePreference) -> Vec<(CrateNum, LibSource)>;
fn used_crate_source(&self, cnum: CrateNum) -> CrateSource;
- fn extern_mod_stmt_cnum(&self, emod_id: ast::NodeId) -> Option<CrateNum>;
fn encode_metadata<'a, 'tcx>(&self,
tcx: TyCtxt<'a, 'tcx, 'tcx>,
link_meta: &LinkMeta,
fn crate_data_as_rc_any(&self, krate: CrateNum) -> Rc<Any>
{ bug!("crate_data_as_rc_any") }
// item info
- fn visibility(&self, def: DefId) -> ty::Visibility { bug!("visibility") }
+ fn visibility_untracked(&self, def: DefId) -> ty::Visibility { bug!("visibility") }
fn visible_parent_map<'a>(&'a self, session: &Session)
-> ::std::cell::Ref<'a, DefIdMap<DefId>>
{
{ bug!("lang_items") }
fn missing_lang_items(&self, cnum: CrateNum) -> Vec<lang_items::LangItem>
{ bug!("missing_lang_items") }
- fn dep_kind(&self, cnum: CrateNum) -> DepKind { bug!("is_explicitly_linked") }
- fn export_macros(&self, cnum: CrateNum) { bug!("export_macros") }
- fn crate_name(&self, cnum: CrateNum) -> Symbol { bug!("crate_name") }
+ fn dep_kind_untracked(&self, cnum: CrateNum) -> DepKind { bug!("is_explicitly_linked") }
+ fn export_macros_untracked(&self, cnum: CrateNum) { bug!("export_macros") }
+ fn crate_name_untracked(&self, cnum: CrateNum) -> Symbol { bug!("crate_name") }
// resolve
fn def_key(&self, def: DefId) -> DefKey { bug!("def_key") }
fn def_path_table(&self, cnum: CrateNum) -> Rc<DefPathTable> {
bug!("def_path_table")
}
- fn struct_field_names(&self, def: DefId) -> Vec<ast::Name> { bug!("struct_field_names") }
- fn item_children(&self, did: DefId, sess: &Session) -> Vec<def::Export> {
+ fn struct_field_names_untracked(&self, def: DefId) -> Vec<ast::Name> {
+ bug!("struct_field_names")
+ }
+ fn item_children_untracked(&self, did: DefId, sess: &Session) -> Vec<def::Export> {
bug!("item_children")
}
- fn load_macro(&self, did: DefId, sess: &Session) -> LoadedMacro { bug!("load_macro") }
+ fn load_macro_untracked(&self, did: DefId, sess: &Session) -> LoadedMacro { bug!("load_macro") }
// misc. metadata
fn item_body<'a, 'tcx>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, def: DefId)
fn used_crates(&self, prefer: LinkagePreference) -> Vec<(CrateNum, LibSource)>
{ vec![] }
fn used_crate_source(&self, cnum: CrateNum) -> CrateSource { bug!("used_crate_source") }
- fn extern_mod_stmt_cnum(&self, emod_id: ast::NodeId) -> Option<CrateNum> { None }
+ fn extern_mod_stmt_cnum_untracked(&self, emod_id: ast::NodeId) -> Option<CrateNum> { None }
fn encode_metadata<'a, 'tcx>(&self,
tcx: TyCtxt<'a, 'tcx, 'tcx>,
link_meta: &LinkMeta,
return v;
}
for cnum in sess.cstore.crates() {
- if sess.cstore.dep_kind(cnum).macros_only() { continue }
+ if tcx.dep_kind(cnum).macros_only() { continue }
let src = sess.cstore.used_crate_source(cnum);
if src.rlib.is_some() { continue }
sess.err(&format!("dependency `{}` not found in rlib format",
- sess.cstore.crate_name(cnum)));
+ tcx.crate_name(cnum)));
}
return Vec::new();
}
// dependencies, ensuring there are no conflicts. The only valid case for a
// dependency to be relied upon twice is for both cases to rely on a dylib.
for cnum in sess.cstore.crates() {
- if sess.cstore.dep_kind(cnum).macros_only() { continue }
- let name = sess.cstore.crate_name(cnum);
+ if tcx.dep_kind(cnum).macros_only() { continue }
+ let name = tcx.crate_name(cnum);
let src = sess.cstore.used_crate_source(cnum);
if src.dylib.is_some() {
info!("adding dylib: {}", name);
- add_library(sess, cnum, RequireDynamic, &mut formats);
+ add_library(tcx, cnum, RequireDynamic, &mut formats);
let deps = tcx.dylib_dependency_formats(cnum);
for &(depnum, style) in deps.iter() {
- info!("adding {:?}: {}", style,
- sess.cstore.crate_name(depnum));
- add_library(sess, depnum, style, &mut formats);
+ info!("adding {:?}: {}", style, tcx.crate_name(depnum));
+ add_library(tcx, depnum, style, &mut formats);
}
}
}
let src = sess.cstore.used_crate_source(cnum);
if src.dylib.is_none() &&
!formats.contains_key(&cnum) &&
- sess.cstore.dep_kind(cnum) == DepKind::Explicit {
+ tcx.dep_kind(cnum) == DepKind::Explicit {
assert!(src.rlib.is_some() || src.rmeta.is_some());
- info!("adding staticlib: {}", sess.cstore.crate_name(cnum));
- add_library(sess, cnum, RequireStatic, &mut formats);
+ info!("adding staticlib: {}", tcx.crate_name(cnum));
+ add_library(tcx, cnum, RequireStatic, &mut formats);
ret[cnum.as_usize() - 1] = Linkage::Static;
}
}
Linkage::Static => "rlib",
_ => "dylib",
};
- let name = sess.cstore.crate_name(cnum);
+ let name = tcx.crate_name(cnum);
sess.err(&format!("crate `{}` required to be available in {}, \
but it was not available in this form",
name, kind));
return ret;
}
-fn add_library(sess: &session::Session,
+fn add_library(tcx: TyCtxt,
cnum: CrateNum,
link: LinkagePreference,
m: &mut FxHashMap<CrateNum, LinkagePreference>) {
// This error is probably a little obscure, but I imagine that it
// can be refined over time.
if link2 != link || link == RequireStatic {
- sess.struct_err(&format!("cannot satisfy dependencies so `{}` only \
- shows up once", sess.cstore.crate_name(cnum)))
+ tcx.sess.struct_err(&format!("cannot satisfy dependencies so `{}` only \
+ shows up once", tcx.crate_name(cnum)))
.help("having upstream crates all available in one format \
will likely make this go away")
.emit();
// everything in explicitly so long as it's actually required.
let last_crate = sess.cstore.crates().len();
let mut ret = (1..last_crate+1).map(|cnum| {
- if sess.cstore.dep_kind(CrateNum::new(cnum)) == DepKind::Explicit {
+ if tcx.dep_kind(CrateNum::new(cnum)) == DepKind::Explicit {
Linkage::Static
} else {
Linkage::NotLinked
if tcx.is_panic_runtime(cnum) {
if let Some((prev, _)) = panic_runtime {
- let prev_name = sess.cstore.crate_name(prev);
- let cur_name = sess.cstore.crate_name(cnum);
+ let prev_name = tcx.crate_name(prev);
+ let cur_name = tcx.crate_name(cnum);
sess.err(&format!("cannot link together two \
panic runtimes: {} and {}",
prev_name, cur_name));
sess.err(&format!("the linked panic runtime `{}` is \
not compiled with this crate's \
panic strategy `{}`",
- sess.cstore.crate_name(cnum),
+ tcx.crate_name(cnum),
desired_strategy.desc()));
}
panic strategy `{}` which is \
incompatible with this crate's \
strategy of `{}`",
- sess.cstore.crate_name(cnum),
+ tcx.crate_name(cnum),
found_strategy.desc(),
desired_strategy.desc()));
}
name),
None => self.session.struct_err(&format!(
"duplicate lang item in crate `{}`: `{}`.",
- cstore.crate_name(item_def_id.krate),
+ cstore.crate_name_untracked(item_def_id.krate),
name)),
};
if let Some(span) = self.hir_map.span_if_local(original_def_id) {
"first defined here.");
} else {
err.note(&format!("first defined in crate `{}`.",
- cstore.crate_name(original_def_id.krate)));
+ cstore.crate_name_untracked(original_def_id.krate)));
}
err.emit();
}
_ => {}
}
- let visibility = self.sess.cstore.visibility(def_id);
+ let visibility = self.visibility(def_id);
match visibility {
// must check stability for pub items.
// compiler-generated `extern crate` items have a dummy span.
if item.span == DUMMY_SP { return }
- let cnum = match self.tcx.sess.cstore.extern_mod_stmt_cnum(item.id) {
+ let hir_id = self.tcx.hir.node_to_hir_id(item.id);
+ let cnum = match self.tcx.extern_mod_stmt_cnum(hir_id) {
Some(cnum) => cnum,
None => return,
};
}
impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
- pub fn crate_name(self, cnum: CrateNum) -> Symbol {
- if cnum == LOCAL_CRATE {
- self.crate_name
- } else {
- self.sess.cstore.crate_name(cnum)
- }
- }
-
pub fn alloc_generics(self, generics: ty::Generics) -> &'gcx ty::Generics {
self.global_arenas.generics.alloc(generics)
}
providers.object_lifetime_defaults = |tcx, id| {
tcx.gcx.named_region_map.object_lifetime_defaults.get(&id).cloned()
};
+ providers.crate_name = |tcx, id| {
+ assert_eq!(id, LOCAL_CRATE);
+ tcx.crate_name
+ };
}
use lint;
use middle::const_val;
use middle::cstore::{ExternCrate, LinkagePreference, NativeLibrary};
-use middle::cstore::NativeLibraryKind;
+use middle::cstore::{NativeLibraryKind, DepKind};
use middle::privacy::AccessLevels;
use middle::region;
use middle::region::RegionMaps;
}
}
+impl<'tcx> QueryDescription for queries::dep_kind<'tcx> {
+ fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
+ format!("fetching what a dependency looks like")
+ }
+}
+
+impl<'tcx> QueryDescription for queries::crate_name<'tcx> {
+ fn describe(_tcx: TyCtxt, _: CrateNum) -> String {
+ format!("fetching what a crate is named")
+ }
+}
+
+impl<'tcx> QueryDescription for queries::extern_mod_stmt_cnum<'tcx> {
+ fn describe(_tcx: TyCtxt, _: HirId) -> String {
+ format!("looking up the CrateNum for an `extern mod` statement")
+ }
+}
+
// If enabled, send a message to the profile-queries thread
macro_rules! profq_msg {
($tcx:expr, $msg:expr) => {
[] is_late_bound: IsLateBound(HirId) -> bool,
[] object_lifetime_defaults: ObjectLifetimeDefaults(HirId)
-> Option<Rc<Vec<ObjectLifetimeDefault>>>,
+
+ [] visibility: Visibility(DefId) -> ty::Visibility,
+ [] dep_kind: DepKind(CrateNum) -> DepKind,
+ [] crate_name: CrateName(CrateNum) -> Symbol,
+ [] item_children: ItemChildren(DefId) -> Rc<Vec<Export>>,
+ [] extern_mod_stmt_cnum: ExternModStmtCnum(HirId) -> Option<CrateNum>,
}
fn type_param_predicates<'tcx>((item_id, param_id): (DefId, DefId)) -> DepConstructor<'tcx> {
let node_id = self.hir.as_local_node_id(impl_did).unwrap();
Ok(self.hir.span(node_id))
} else {
- Err(self.sess.cstore.crate_name(impl_did.krate))
+ Err(self.crate_name(impl_did.krate))
}
}
_ => return,
};
- let prfn = match cx.sess().cstore.extern_mod_stmt_cnum(it.id) {
+ let hir_id = cx.tcx.hir.node_to_hir_id(it.id);
+ let prfn = match cx.tcx.extern_mod_stmt_cnum(hir_id) {
Some(cnum) => cx.tcx.plugin_registrar_fn(cnum),
None => {
// Probably means we aren't linking the crate for some reason.
is_dllimport_foreign_item => {
cdata.is_dllimport_foreign_item(def_id.index, &tcx.dep_graph)
}
+ visibility => { cdata.get_visibility(def_id.index) }
+ dep_kind => { cdata.dep_kind.get() }
+ crate_name => { cdata.name }
+ item_children => {
+ let mut result = vec![];
+ cdata.each_child_of_item(def_id.index, |child| result.push(child), tcx.sess);
+ Rc::new(result)
+ }
}
pub fn provide_local<'tcx>(providers: &mut Providers<'tcx>) {
assert_eq!(cnum, LOCAL_CRATE);
Rc::new(link_args::collect(tcx))
},
+ extern_mod_stmt_cnum: |tcx, id| {
+ let id = tcx.hir.definitions().find_node_for_hir_id(id);
+ tcx.sess.cstore.extern_mod_stmt_cnum_untracked(id)
+ },
..*providers
};
}
&*self.metadata_loader
}
- fn visibility(&self, def: DefId) -> ty::Visibility {
+ fn visibility_untracked(&self, def: DefId) -> ty::Visibility {
self.read_dep_node(def);
self.get_crate_data(def.krate).get_visibility(def.index)
}
self.get_crate_data(def.krate).get_associated_item(def.index)
}
- fn dep_kind(&self, cnum: CrateNum) -> DepKind
+ fn dep_kind_untracked(&self, cnum: CrateNum) -> DepKind
{
let data = self.get_crate_data(cnum);
let dep_node = data.metadata_dep_node(GlobalMetaDataKind::CrateDeps);
data.dep_kind.get()
}
- fn export_macros(&self, cnum: CrateNum) {
+ fn export_macros_untracked(&self, cnum: CrateNum) {
let data = self.get_crate_data(cnum);
let dep_node = data.metadata_dep_node(GlobalMetaDataKind::CrateDeps);
self.get_crate_data(cnum).get_missing_lang_items(&self.dep_graph)
}
- fn crate_name(&self, cnum: CrateNum) -> Symbol
+ fn crate_name_untracked(&self, cnum: CrateNum) -> Symbol
{
self.get_crate_data(cnum).name
}
self.get_crate_data(cnum).def_path_table.clone()
}
- fn struct_field_names(&self, def: DefId) -> Vec<ast::Name>
+ fn struct_field_names_untracked(&self, def: DefId) -> Vec<ast::Name>
{
self.read_dep_node(def);
self.get_crate_data(def.krate).get_struct_field_names(def.index)
}
- fn item_children(&self, def_id: DefId, sess: &Session) -> Vec<def::Export>
+ fn item_children_untracked(&self, def_id: DefId, sess: &Session) -> Vec<def::Export>
{
self.read_dep_node(def_id);
let mut result = vec![];
result
}
- fn load_macro(&self, id: DefId, sess: &Session) -> LoadedMacro {
+ fn load_macro_untracked(&self, id: DefId, sess: &Session) -> LoadedMacro {
let data = self.get_crate_data(id.krate);
if let Some(ref proc_macros) = data.proc_macros {
return LoadedMacro::ProcMacro(proc_macros[id.index.as_usize() - 1].1.clone());
self.get_crate_data(cnum).source.clone()
}
- fn extern_mod_stmt_cnum(&self, emod_id: ast::NodeId) -> Option<CrateNum>
+ fn extern_mod_stmt_cnum_untracked(&self, emod_id: ast::NodeId) -> Option<CrateNum>
{
self.do_extern_mod_stmt_cnum(emod_id)
}
let mut add_child = |bfs_queue: &mut VecDeque<_>, child: def::Export, parent: DefId| {
let child = child.def.def_id();
- if self.visibility(child) != ty::Visibility::Public {
+ if self.visibility_untracked(child) != ty::Visibility::Public {
return;
}
index: CRATE_DEF_INDEX
});
while let Some(def) = bfs_queue.pop_front() {
- for child in self.item_children(def, sess) {
+ for child in self.item_children_untracked(def, sess) {
add_child(bfs_queue, child, def);
}
}
}
fn encode_crate_deps(&mut self, _: ()) -> LazySeq<CrateDep> {
- let cstore = &*self.tcx.sess.cstore;
- let crates = cstore.crates();
+ let crates = self.tcx.sess.cstore.crates();
let mut deps = crates
.iter()
let dep = CrateDep {
name: self.tcx.original_crate_name(cnum),
hash: self.tcx.crate_hash(cnum),
- kind: cstore.dep_kind(cnum),
+ kind: self.tcx.dep_kind(cnum),
};
(cnum, dep)
})
};
ty::Visibility::from_hir(vis, node_id, self.tcx)
}
- None => self.tcx.sess.cstore.visibility(did),
+ None => self.tcx.visibility(did),
}
}
self.crate_loader.process_item(item, &self.definitions);
// n.b. we don't need to look at the path option here, because cstore already did
- let crate_id = self.session.cstore.extern_mod_stmt_cnum(item.id).unwrap();
+ let crate_id = self.session.cstore.extern_mod_stmt_cnum_untracked(item.id).unwrap();
let module =
self.get_module(DefId { krate: crate_id, index: CRATE_DEF_INDEX });
self.populate_module_if_necessary(module);
let ident = child.ident;
let def = child.def;
let def_id = def.def_id();
- let vis = self.session.cstore.visibility(def_id);
+ let vis = self.session.cstore.visibility_untracked(def_id);
let span = child.span;
let expansion = Mark::root(); // FIXME(jseyfried) intercrate hygiene
match def {
span);
self.define(parent, ident, TypeNS, (module, vis, DUMMY_SP, expansion));
- for child in self.session.cstore.item_children(def_id, self.session) {
+ for child in self.session.cstore.item_children_untracked(def_id, self.session) {
let ns = if let Def::AssociatedTy(..) = child.def { TypeNS } else { ValueNS };
self.define(module, child.ident, ns,
(child.def, ty::Visibility::Public, DUMMY_SP, expansion));
self.define(parent, ident, TypeNS, (def, vis, DUMMY_SP, expansion));
// Record field names for error reporting.
- let field_names = self.session.cstore.struct_field_names(def_id);
+ let field_names = self.session.cstore.struct_field_names_untracked(def_id);
self.insert_field_names(def_id, field_names);
}
Def::Macro(..) => {
return self.module_map[&def_id]
}
- let macros_only = self.session.cstore.dep_kind(def_id.krate).macros_only();
+ let macros_only = self.session.cstore.dep_kind_untracked(def_id.krate).macros_only();
if let Some(&module) = self.extern_module_map.get(&(def_id, macros_only)) {
return module;
}
let (name, parent) = if def_id.index == CRATE_DEF_INDEX {
- (self.session.cstore.crate_name(def_id.krate), None)
+ (self.session.cstore.crate_name_untracked(def_id.krate), None)
} else {
let def_key = self.session.cstore.def_key(def_id);
(def_key.disambiguated_data.data.get_opt_name().unwrap(),
return ext.clone();
}
- let macro_def = match self.session.cstore.load_macro(def_id, &self.session) {
+ let macro_def = match self.session.cstore.load_macro_untracked(def_id, &self.session) {
LoadedMacro::MacroDef(macro_def) => macro_def,
LoadedMacro::ProcMacro(ext) => return ext,
};
/// is built, building it if it is not.
pub fn populate_module_if_necessary(&mut self, module: Module<'a>) {
if module.populated.get() { return }
- for child in self.session.cstore.item_children(module.def_id().unwrap(), self.session) {
+ let def_id = module.def_id().unwrap();
+ for child in self.session.cstore.item_children_untracked(def_id, self.session) {
self.build_reduced_graph_for_external_crate_def(module, child);
}
module.populated.set(true)
span_err!(self.session, item.span, E0468,
"an `extern crate` loading macros must be at the crate root");
} else if !self.use_extern_macros && !used &&
- self.session.cstore.dep_kind(module.def_id().unwrap().krate).macros_only() {
+ self.session.cstore.dep_kind_untracked(module.def_id().unwrap().krate)
+ .macros_only() {
let msg = "proc macro crates and `#[no_link]` crates have no effect without \
`#[macro_use]`";
self.session.span_warn(item.span, msg);
}
}
for (name, span) in legacy_imports.reexports {
- self.session.cstore.export_macros(module.def_id().unwrap().krate);
+ self.session.cstore.export_macros_untracked(module.def_id().unwrap().krate);
let ident = Ident::with_empty_ctxt(name);
let result = self.resolve_ident_in_module(module, ident, MacroNS, false, false, span);
if let Ok(binding) = result {
_ => return,
};
- let crate_name = self.session.cstore.crate_name(krate);
+ let crate_name = self.session.cstore.crate_name_untracked(krate);
self.session.struct_span_err(use_span, warn_msg)
.help(&format!("instead, import the procedural macro like any other item: \
let def = binding.def();
if def != Def::Err {
if !def.def_id().is_local() {
- self.session.cstore.export_macros(def.def_id().krate);
+ self.session.cstore.export_macros_untracked(def.def_id().krate);
}
if let Def::Macro(..) = def {
if let Some(&span) = exported_macro_names.get(&ident.modern()) {
};
let lo_loc = self.span_utils.sess.codemap().lookup_char_pos(span.lo());
result.push(ExternalCrateData {
- name: self.tcx.sess.cstore.crate_name(n).to_string(),
+ name: self.tcx.crate_name(n).to_string(),
num: n.as_u32(),
file_name: SpanUtils::make_path_string(&lo_loc.file.name),
});
}
pub fn each_linked_rlib(sess: &Session,
+ info: &CrateInfo,
f: &mut FnMut(CrateNum, &Path)) -> Result<(), String> {
let crates = sess.cstore.used_crates(LinkagePreference::RequireStatic).into_iter();
let fmts = sess.dependency_formats.borrow();
Some(_) => {}
None => return Err(format!("could not find formats for rlibs"))
}
- let name = sess.cstore.crate_name(cnum).clone();
+ let name = &info.crate_name[&cnum];
let path = match path {
LibSource::Some(p) => p,
LibSource::MetadataOnly => {
tempdir);
let mut all_native_libs = vec![];
- let res = each_linked_rlib(sess, &mut |cnum, path| {
- let name = sess.cstore.crate_name(cnum);
+ let res = each_linked_rlib(sess, &trans.crate_info, &mut |cnum, path| {
+ let name = &trans.crate_info.crate_name[&cnum];
let native_libs = &trans.crate_info.native_libraries[&cnum];
// Here when we include the rlib into our staticlib we need to make a
}).expect("failed to spawn helper thread");
let mut each_linked_rlib_for_lto = Vec::new();
- drop(link::each_linked_rlib(sess, &mut |cnum, path| {
+ drop(link::each_linked_rlib(sess, crate_info, &mut |cnum, path| {
if link::ignored_for_lto(crate_info, cnum) {
return
}
native_libraries: FxHashMap(),
used_libraries: tcx.native_libraries(LOCAL_CRATE),
link_args: tcx.link_args(LOCAL_CRATE),
+ crate_name: FxHashMap(),
};
for cnum in tcx.sess.cstore.crates() {
info.native_libraries.insert(cnum, tcx.native_libraries(cnum));
+ info.crate_name.insert(cnum, tcx.crate_name(cnum).to_string());
if tcx.is_panic_runtime(cnum) {
info.panic_runtime = Some(cnum);
}
sanitizer_runtime: Option<CrateNum>,
is_no_builtins: FxHashSet<CrateNum>,
native_libraries: FxHashMap<CrateNum, Rc<Vec<NativeLibrary>>>,
+ crate_name: FxHashMap<CrateNum, String>,
used_libraries: Rc<Vec<NativeLibrary>>,
link_args: Rc<Vec<String>>,
}
if !external_mods.insert(def_id) {
return;
}
- for child in tcx.sess.cstore.item_children(def_id, tcx.sess) {
+ for child in tcx.item_children(def_id).iter() {
handle_external_def(tcx, traits, external_mods, child.def)
}
}
tcx.hir.krate().visit_all_item_likes(&mut visitor);
for &(id, span) in &tcx.maybe_unused_extern_crates {
- let cnum = tcx.sess.cstore.extern_mod_stmt_cnum(id).unwrap();
+ let hir_id = tcx.hir.node_to_hir_id(id);
+ let cnum = tcx.extern_mod_stmt_cnum(hir_id).unwrap();
if !tcx.is_compiler_builtins(cnum)
&& !tcx.is_panic_runtime(cnum)
&& !tcx.has_global_allocator(cnum) {
/// These names are used later on by HTML rendering to generate things like
/// source links back to the original item.
pub fn record_extern_fqn(cx: &DocContext, did: DefId, kind: clean::TypeKind) {
- let crate_name = cx.tcx.sess.cstore.crate_name(did.krate).to_string();
+ let crate_name = cx.tcx.crate_name(did.krate).to_string();
let relative = cx.tcx.def_path(did).data.into_iter().filter_map(|elem| {
// extern blocks have an empty name
let s = elem.data.to_string();
// two namespaces, so the target may be listed twice. Make sure we only
// visit each node at most once.
let mut visited = FxHashSet();
- for item in cx.tcx.sess.cstore.item_children(did, cx.tcx.sess) {
+ for &item in cx.tcx.item_children(did).iter() {
let def_id = item.def.def_id();
- if cx.tcx.sess.cstore.visibility(def_id) == ty::Visibility::Public {
+ if cx.tcx.visibility(def_id) == ty::Visibility::Public {
if !visited.insert(def_id) { continue }
if let Some(i) = try_inline(cx, item.def, item.ident.name) {
items.extend(i)
}
}).collect()
} else {
- cx.tcx.sess.cstore.item_children(root, cx.tcx.sess).iter().map(|item| item.def)
+ cx.tcx.item_children(root).iter().map(|item| item.def)
.filter_map(as_primitive).collect()
};
}
let imported_from = self.cx.tcx.original_crate_name(def_id.krate);
- let def = match self.cx.sess().cstore.load_macro(def_id, self.cx.sess()) {
+ let cstore = &self.cx.sess().cstore;
+ let def = match cstore.load_macro_untracked(def_id, self.cx.sess()) {
LoadedMacro::MacroDef(macro_def) => macro_def,
// FIXME(jseyfried): document proc macro reexports
LoadedMacro::ProcMacro(..) => continue,
_ if self.inlining && item.vis != hir::Public => {}
hir::ItemGlobalAsm(..) => {}
hir::ItemExternCrate(ref p) => {
- let cstore = &self.cx.sess().cstore;
+ let hir_id = self.cx.tcx.hir.node_to_hir_id(item.id);
om.extern_crates.push(ExternCrate {
- cnum: cstore.extern_mod_stmt_cnum(item.id)
+ cnum: self.cx.tcx.extern_mod_stmt_cnum(hir_id)
.unwrap_or(LOCAL_CRATE),
name,
path: p.map(|x|x.to_string()),
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use rustc::middle::cstore::CrateStore;
use rustc::middle::privacy::{AccessLevels, AccessLevel};
use rustc::hir::def::Def;
use rustc::hir::def_id::{CrateNum, CRATE_DEF_INDEX, DefId};
/// specific rustdoc annotations into account (i.e. `doc(hidden)`)
pub struct LibEmbargoVisitor<'a, 'b: 'a, 'tcx: 'b> {
cx: &'a ::core::DocContext<'b, 'tcx>,
- cstore: &'a CrateStore,
// Accessibility levels for reachable nodes
access_levels: RefMut<'a, AccessLevels<DefId>>,
// Previous accessibility level, None means unreachable
pub fn new(cx: &'a ::core::DocContext<'b, 'tcx>) -> LibEmbargoVisitor<'a, 'b, 'tcx> {
LibEmbargoVisitor {
cx,
- cstore: &*cx.sess().cstore,
access_levels: cx.access_levels.borrow_mut(),
prev_level: Some(AccessLevel::Public),
visited_mods: FxHashSet()
return;
}
- for item in self.cstore.item_children(def_id, self.cx.tcx.sess) {
+ for item in self.cx.tcx.item_children(def_id).iter() {
self.visit_item(item.def);
}
}
fn visit_item(&mut self, def: Def) {
let def_id = def.def_id();
- let vis = self.cstore.visibility(def_id);
+ let vis = self.cx.tcx.visibility(def_id);
let inherited_item_level = if vis == Visibility::Public {
self.prev_level
} else {