};
let dep_graph = DepGraph::new(sopts.build_dep_graph());
- let cstore = Rc::new(CStore::new(&dep_graph, box ::MetadataLoader));
+ let cstore = Rc::new(CStore::new(box ::MetadataLoader));
let loader = file_loader.unwrap_or(box RealFileLoader);
let codemap = Rc::new(CodeMap::with_file_loader(loader, sopts.file_path_mapping()));
return None;
}
let dep_graph = DepGraph::new(sopts.build_dep_graph());
- let cstore = Rc::new(CStore::new(&dep_graph, box ::MetadataLoader));
+ let cstore = Rc::new(CStore::new(box ::MetadataLoader));
let mut sess = build_session(sopts.clone(),
&dep_graph,
None,
let dep_graph = DepGraph::new(false);
let _ignore = dep_graph.in_ignore();
- let cstore = Rc::new(CStore::new(&dep_graph, box ::MetadataLoader));
+ let cstore = Rc::new(CStore::new(box ::MetadataLoader));
let sess = session::build_session_(options,
&dep_graph,
None,
use cstore::{self, CStore, CrateSource, MetadataBlob};
use locator::{self, CratePaths};
use native_libs::relevant_lib;
-use schema::{CrateRoot, Tracked};
+use schema::CrateRoot;
use rustc::hir::def_id::{CrateNum, DefIndex};
use rustc::hir::svh::Svh;
crate_root.def_path_table.decode(&metadata)
});
- let exported_symbols = crate_root.exported_symbols
- .map(|x| x.decode(&metadata).collect());
+ let exported_symbols = crate_root.exported_symbols.decode(&metadata).collect();
let trait_impls = crate_root
.impls
- .map(|impls| {
- impls.decode(&metadata)
- .map(|trait_impls| (trait_impls.trait_id, trait_impls.impls))
- .collect()
- });
+ .decode(&metadata)
+ .map(|trait_impls| (trait_impls.trait_id, trait_impls.impls))
+ .collect();
let mut cmeta = cstore::CrateMetadata {
name,
},
// Initialize this with an empty set. The field is populated below
// after we were able to deserialize its contents.
- dllimport_foreign_items: Tracked::new(FxHashSet()),
+ dllimport_foreign_items: FxHashSet(),
};
- let dllimports: Tracked<FxHashSet<_>> = cmeta
+ let dllimports: FxHashSet<_> = cmeta
.root
.native_libraries
- .map(|native_libraries| {
- let native_libraries: Vec<_> = native_libraries.decode(&cmeta)
- .collect();
- native_libraries
- .iter()
- .filter(|lib| relevant_lib(self.sess, lib) &&
- lib.kind == cstore::NativeLibraryKind::NativeUnknown)
- .flat_map(|lib| lib.foreign_items.iter())
- .map(|id| *id)
- .collect()
- });
+ .decode(&cmeta)
+ .filter(|lib| relevant_lib(self.sess, lib) &&
+ lib.kind == cstore::NativeLibraryKind::NativeUnknown)
+ .flat_map(|lib| lib.foreign_items.into_iter())
+ .collect();
cmeta.dllimport_foreign_items = dllimports;
// We map 0 and all other holes in the map to our parent crate. The "additional"
// self-dependencies should be harmless.
::std::iter::once(krate).chain(crate_root.crate_deps
- .get_untracked()
.decode(metadata)
.map(|dep| {
debug!("resolving dep crate {} hash: `{}`", dep.name, dep.hash);
let mut needs_panic_runtime = attr::contains_name(&krate.attrs,
"needs_panic_runtime");
- let dep_graph = &self.sess.dep_graph;
-
self.cstore.iter_crate_data(|cnum, data| {
needs_panic_runtime = needs_panic_runtime ||
- data.needs_panic_runtime(dep_graph);
- if data.is_panic_runtime(dep_graph) {
+ data.needs_panic_runtime();
+ if data.is_panic_runtime() {
// Inject a dependency from all #![needs_panic_runtime] to this
// #![panic_runtime] crate.
self.inject_dependency_if(cnum, "a panic runtime",
- &|data| data.needs_panic_runtime(dep_graph));
+ &|data| data.needs_panic_runtime());
runtime_found = runtime_found || data.dep_kind.get() == DepKind::Explicit;
}
});
// Sanity check the loaded crate to ensure it is indeed a panic runtime
// and the panic strategy is indeed what we thought it was.
- if !data.is_panic_runtime(dep_graph) {
+ if !data.is_panic_runtime() {
self.sess.err(&format!("the crate `{}` is not a panic runtime",
name));
}
- if data.panic_strategy(dep_graph) != desired_strategy {
+ if data.panic_strategy() != desired_strategy {
self.sess.err(&format!("the crate `{}` does not have the panic \
strategy `{}`",
name, desired_strategy.desc()));
self.sess.injected_panic_runtime.set(Some(cnum));
self.inject_dependency_if(cnum, "a panic runtime",
- &|data| data.needs_panic_runtime(dep_graph));
+ &|data| data.needs_panic_runtime());
}
fn inject_sanitizer_runtime(&mut self) {
PathKind::Crate, dep_kind);
// Sanity check the loaded crate to ensure it is indeed a sanitizer runtime
- if !data.is_sanitizer_runtime(&self.sess.dep_graph) {
+ if !data.is_sanitizer_runtime() {
self.sess.err(&format!("the crate `{}` is not a sanitizer runtime",
name));
}
PathKind::Crate, dep_kind);
// Sanity check the loaded crate to ensure it is indeed a profiler runtime
- if !data.is_profiler_runtime(&self.sess.dep_graph) {
+ if !data.is_profiler_runtime() {
self.sess.err(&format!("the crate `profiler_builtins` is not \
a profiler runtime"));
}
// written down in liballoc.
let mut needs_allocator = attr::contains_name(&krate.attrs,
"needs_allocator");
- let dep_graph = &self.sess.dep_graph;
self.cstore.iter_crate_data(|_, data| {
- needs_allocator = needs_allocator || data.needs_allocator(dep_graph);
+ needs_allocator = needs_allocator || data.needs_allocator();
});
if !needs_allocator {
return
// First up we check for global allocators. Look at the crate graph here
// and see what's a global allocator, including if we ourselves are a
// global allocator.
- let dep_graph = &self.sess.dep_graph;
let mut global_allocator = if has_global_allocator {
Some(None)
} else {
None
};
self.cstore.iter_crate_data(|_, data| {
- if !data.has_global_allocator(dep_graph) {
+ if !data.has_global_allocator() {
return
}
match global_allocator {
DUMMY_SP,
PathKind::Crate, dep_kind);
self.sess.injected_allocator.set(Some(cnum));
- // self.cstore.iter_crate_data(|_, data| {
- // if !data.needs_allocator(dep_graph) {
- // return
- // }
- // data.cnum_map.borrow_mut().push(cnum);
- // });
}
// We're not actually going to inject an allocator, we're going to
attr::contains_name(&krate.attrs, "default_lib_allocator");
self.cstore.iter_crate_data(|_, data| {
if !found_lib_allocator {
- if data.has_default_lib_allocator(dep_graph) {
+ if data.has_default_lib_allocator() {
found_lib_allocator = true;
}
}
// The crate store - a central repo for information collected about external
// crates and libraries
-use schema::{self, Tracked};
+use schema;
-use rustc::dep_graph::DepGraph;
-use rustc::hir::def_id::{CRATE_DEF_INDEX, CrateNum, DefIndex, DefId};
-use rustc::hir::map::definitions::{DefPathTable, GlobalMetaDataKind};
+use rustc::hir::def_id::{CRATE_DEF_INDEX, CrateNum, DefIndex};
+use rustc::hir::map::definitions::DefPathTable;
use rustc::hir::svh::Svh;
use rustc::middle::cstore::{DepKind, ExternCrate, MetadataLoader};
use rustc_back::PanicStrategy;
/// compilation support.
pub def_path_table: Rc<DefPathTable>,
- pub exported_symbols: Tracked<FxHashSet<DefIndex>>,
+ pub exported_symbols: FxHashSet<DefIndex>,
- pub trait_impls: Tracked<FxHashMap<(u32, DefIndex), schema::LazySeq<DefIndex>>>,
+ pub trait_impls: FxHashMap<(u32, DefIndex), schema::LazySeq<DefIndex>>,
pub dep_kind: Cell<DepKind>,
pub source: CrateSource,
pub proc_macros: Option<Vec<(ast::Name, Rc<SyntaxExtension>)>>,
// Foreign items imported from a dylib (Windows only)
- pub dllimport_foreign_items: Tracked<FxHashSet<DefIndex>>,
+ pub dllimport_foreign_items: FxHashSet<DefIndex>,
}
pub struct CStore {
- pub dep_graph: DepGraph,
metas: RefCell<FxHashMap<CrateNum, Rc<CrateMetadata>>>,
/// Map from NodeId's of local extern crate statements to crate numbers
extern_mod_crate_map: RefCell<NodeMap<CrateNum>>,
}
impl CStore {
- pub fn new(dep_graph: &DepGraph, metadata_loader: Box<MetadataLoader>) -> CStore {
+ pub fn new(metadata_loader: Box<MetadataLoader>) -> CStore {
CStore {
- dep_graph: dep_graph.clone(),
metas: RefCell::new(FxHashMap()),
extern_mod_crate_map: RefCell::new(FxHashMap()),
metadata_loader,
pub fn do_extern_mod_stmt_cnum(&self, emod_id: ast::NodeId) -> Option<CrateNum> {
self.extern_mod_crate_map.borrow().get(&emod_id).cloned()
}
-
- pub fn read_dep_node(&self, def_id: DefId) {
- use rustc::middle::cstore::CrateStore;
- let def_path_hash = self.def_path_hash(def_id);
- let dep_node = def_path_hash.to_dep_node(::rustc::dep_graph::DepKind::MetaData);
- self.dep_graph.read(dep_node);
- }
}
impl CrateMetadata {
self.root.disambiguator
}
- pub fn needs_allocator(&self, dep_graph: &DepGraph) -> bool {
- let attrs = self.get_item_attrs(CRATE_DEF_INDEX, dep_graph);
+ pub fn needs_allocator(&self) -> bool {
+ let attrs = self.get_item_attrs(CRATE_DEF_INDEX);
attr::contains_name(&attrs, "needs_allocator")
}
- pub fn has_global_allocator(&self, dep_graph: &DepGraph) -> bool {
- let dep_node = self.metadata_dep_node(GlobalMetaDataKind::Krate);
- self.root
- .has_global_allocator
- .get(dep_graph, dep_node)
- .clone()
+ pub fn has_global_allocator(&self) -> bool {
+ self.root.has_global_allocator.clone()
}
- pub fn has_default_lib_allocator(&self, dep_graph: &DepGraph) -> bool {
- let dep_node = self.metadata_dep_node(GlobalMetaDataKind::Krate);
- self.root
- .has_default_lib_allocator
- .get(dep_graph, dep_node)
- .clone()
+ pub fn has_default_lib_allocator(&self) -> bool {
+ self.root.has_default_lib_allocator.clone()
}
- pub fn is_panic_runtime(&self, dep_graph: &DepGraph) -> bool {
- let attrs = self.get_item_attrs(CRATE_DEF_INDEX, dep_graph);
+ pub fn is_panic_runtime(&self) -> bool {
+ let attrs = self.get_item_attrs(CRATE_DEF_INDEX);
attr::contains_name(&attrs, "panic_runtime")
}
- pub fn needs_panic_runtime(&self, dep_graph: &DepGraph) -> bool {
- let attrs = self.get_item_attrs(CRATE_DEF_INDEX, dep_graph);
+ pub fn needs_panic_runtime(&self) -> bool {
+ let attrs = self.get_item_attrs(CRATE_DEF_INDEX);
attr::contains_name(&attrs, "needs_panic_runtime")
}
- pub fn is_compiler_builtins(&self, dep_graph: &DepGraph) -> bool {
- let attrs = self.get_item_attrs(CRATE_DEF_INDEX, dep_graph);
+ pub fn is_compiler_builtins(&self) -> bool {
+ let attrs = self.get_item_attrs(CRATE_DEF_INDEX);
attr::contains_name(&attrs, "compiler_builtins")
}
- pub fn is_sanitizer_runtime(&self, dep_graph: &DepGraph) -> bool {
- let attrs = self.get_item_attrs(CRATE_DEF_INDEX, dep_graph);
+ pub fn is_sanitizer_runtime(&self) -> bool {
+ let attrs = self.get_item_attrs(CRATE_DEF_INDEX);
attr::contains_name(&attrs, "sanitizer_runtime")
}
- pub fn is_profiler_runtime(&self, dep_graph: &DepGraph) -> bool {
- let attrs = self.get_item_attrs(CRATE_DEF_INDEX, dep_graph);
+ pub fn is_profiler_runtime(&self) -> bool {
+ let attrs = self.get_item_attrs(CRATE_DEF_INDEX);
attr::contains_name(&attrs, "profiler_runtime")
}
- pub fn is_no_builtins(&self, dep_graph: &DepGraph) -> bool {
- let attrs = self.get_item_attrs(CRATE_DEF_INDEX, dep_graph);
+ pub fn is_no_builtins(&self) -> bool {
+ let attrs = self.get_item_attrs(CRATE_DEF_INDEX);
attr::contains_name(&attrs, "no_builtins")
}
- pub fn panic_strategy(&self, dep_graph: &DepGraph) -> PanicStrategy {
- let dep_node = self.metadata_dep_node(GlobalMetaDataKind::Krate);
- self.root
- .panic_strategy
- .get(dep_graph, dep_node)
- .clone()
+ pub fn panic_strategy(&self) -> PanicStrategy {
+ self.root.panic_strategy.clone()
}
}
use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE, CRATE_DEF_INDEX};
use rustc::hir::map::{DefKey, DefPath, DefPathHash};
use rustc::hir::map::blocks::FnLikeNode;
-use rustc::hir::map::definitions::{DefPathTable, GlobalMetaDataKind};
+use rustc::hir::map::definitions::DefPathTable;
use rustc::util::nodemap::{NodeSet, DefIdMap};
use std::any::Any;
lookup_deprecation_entry => {
cdata.get_deprecation(def_id.index).map(DeprecationEntry::external)
}
- item_attrs => { cdata.get_item_attrs(def_id.index, &tcx.dep_graph) }
+ item_attrs => { cdata.get_item_attrs(def_id.index) }
// FIXME(#38501) We've skipped a `read` on the `HirBody` of
// a `fn` when encoding, so the dep-tracking wouldn't work.
// This is only used by rustdoc anyway, which shouldn't have
impl_parent => { cdata.get_parent_impl(def_id.index) }
trait_of_item => { cdata.get_trait_of_item(def_id.index) }
is_exported_symbol => {
- let dep_node = cdata.metadata_dep_node(GlobalMetaDataKind::ExportedSymbols);
- cdata.exported_symbols.get(&tcx.dep_graph, dep_node).contains(&def_id.index)
+ cdata.exported_symbols.contains(&def_id.index)
}
item_body_nested_bodies => { Rc::new(cdata.item_body_nested_bodies(def_id.index)) }
const_is_rvalue_promotable_to_static => {
}
is_mir_available => { cdata.is_item_mir_available(def_id.index) }
- dylib_dependency_formats => { Rc::new(cdata.get_dylib_dependency_formats(&tcx.dep_graph)) }
- is_panic_runtime => { cdata.is_panic_runtime(&tcx.dep_graph) }
- is_compiler_builtins => { cdata.is_compiler_builtins(&tcx.dep_graph) }
- has_global_allocator => { cdata.has_global_allocator(&tcx.dep_graph) }
- is_sanitizer_runtime => { cdata.is_sanitizer_runtime(&tcx.dep_graph) }
- is_profiler_runtime => { cdata.is_profiler_runtime(&tcx.dep_graph) }
- panic_strategy => { cdata.panic_strategy(&tcx.dep_graph) }
+ dylib_dependency_formats => { Rc::new(cdata.get_dylib_dependency_formats()) }
+ is_panic_runtime => { cdata.is_panic_runtime() }
+ is_compiler_builtins => { cdata.is_compiler_builtins() }
+ has_global_allocator => { cdata.has_global_allocator() }
+ is_sanitizer_runtime => { cdata.is_sanitizer_runtime() }
+ is_profiler_runtime => { cdata.is_profiler_runtime() }
+ panic_strategy => { cdata.panic_strategy() }
extern_crate => { Rc::new(cdata.extern_crate.get()) }
- is_no_builtins => { cdata.is_no_builtins(&tcx.dep_graph) }
+ is_no_builtins => { cdata.is_no_builtins() }
impl_defaultness => { cdata.get_impl_defaultness(def_id.index) }
- exported_symbols => { Rc::new(cdata.get_exported_symbols(&tcx.dep_graph)) }
- native_libraries => { Rc::new(cdata.get_native_libraries(&tcx.dep_graph)) }
+ exported_symbols => { Rc::new(cdata.get_exported_symbols()) }
+ native_libraries => { Rc::new(cdata.get_native_libraries()) }
plugin_registrar_fn => {
cdata.root.plugin_registrar_fn.map(|index| {
DefId { krate: def_id.krate, index }
implementations_of_trait => {
let mut result = vec![];
let filter = Some(other);
- cdata.get_implementations_for_trait(filter, &tcx.dep_graph, &mut result);
+ cdata.get_implementations_for_trait(filter, &mut result);
Rc::new(result)
}
all_trait_implementations => {
let mut result = vec![];
- cdata.get_implementations_for_trait(None, &tcx.dep_graph, &mut result);
+ cdata.get_implementations_for_trait(None, &mut result);
Rc::new(result)
}
is_dllimport_foreign_item => {
- cdata.is_dllimport_foreign_item(def_id.index, &tcx.dep_graph)
+ cdata.is_dllimport_foreign_item(def_id.index)
}
visibility => { cdata.get_visibility(def_id.index) }
dep_kind => { cdata.dep_kind.get() }
cdata.each_child_of_item(def_id.index, |child| result.push(child), tcx.sess);
Rc::new(result)
}
- defined_lang_items => { Rc::new(cdata.get_lang_items(&tcx.dep_graph)) }
- missing_lang_items => { Rc::new(cdata.get_missing_lang_items(&tcx.dep_graph)) }
+ defined_lang_items => { Rc::new(cdata.get_lang_items()) }
+ missing_lang_items => { Rc::new(cdata.get_missing_lang_items()) }
extern_const_body => {
debug!("item_body({:?}): inlining item", def_id);
}
fn visibility_untracked(&self, def: DefId) -> ty::Visibility {
- self.read_dep_node(def);
self.get_crate_data(def.krate).get_visibility(def.index)
}
fn item_generics_cloned_untracked(&self, def: DefId) -> ty::Generics {
- self.read_dep_node(def);
self.get_crate_data(def.krate).get_generics(def.index)
}
fn associated_item_cloned_untracked(&self, def: DefId) -> ty::AssociatedItem
{
- self.read_dep_node(def);
self.get_crate_data(def.krate).get_associated_item(def.index)
}
fn dep_kind_untracked(&self, cnum: CrateNum) -> DepKind
{
- let data = self.get_crate_data(cnum);
- let dep_node = data.metadata_dep_node(GlobalMetaDataKind::CrateDeps);
- self.dep_graph.read(dep_node);
- data.dep_kind.get()
+ self.get_crate_data(cnum).dep_kind.get()
}
fn export_macros_untracked(&self, cnum: CrateNum) {
let data = self.get_crate_data(cnum);
- let dep_node = data.metadata_dep_node(GlobalMetaDataKind::CrateDeps);
-
- self.dep_graph.read(dep_node);
if data.dep_kind.get() == DepKind::UnexportedMacrosOnly {
data.dep_kind.set(DepKind::MacrosOnly)
}
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_untracked(&self, def_id: DefId, sess: &Session) -> Vec<def::Export>
{
- self.read_dep_node(def_id);
let mut result = vec![];
self.get_crate_data(def_id.krate)
.each_child_of_item(def_id.index, |child| result.push(child), sess);
let body = filemap_to_stream(&sess.parse_sess, filemap, None);
// Mark the attrs as used
- let attrs = data.get_item_attrs(id.index, &self.dep_graph);
+ let attrs = data.get_item_attrs(id.index);
for attr in attrs.iter() {
attr::mark_used(attr);
}
use cstore::{self, CrateMetadata, MetadataBlob, NativeLibrary};
use schema::*;
-use rustc::dep_graph::{DepGraph, DepNode, DepKind};
use rustc::hir::map::{DefKey, DefPath, DefPathData, DefPathHash};
-use rustc::hir::map::definitions::GlobalMetaDataKind;
use rustc::hir;
use rustc::middle::cstore::LinkagePreference;
write!(out, "=External Dependencies=\n")?;
let root = self.get_root();
for (i, dep) in root.crate_deps
- .get_untracked()
.decode(self)
.enumerate() {
write!(out, "{} {}-{}\n", i + 1, dep.name, dep.hash)?;
}
/// Iterates over the language items in the given crate.
- pub fn get_lang_items(&self, dep_graph: &DepGraph) -> Vec<(DefIndex, usize)> {
- let dep_node = self.metadata_dep_node(GlobalMetaDataKind::LangItems);
+ pub fn get_lang_items(&self) -> Vec<(DefIndex, usize)> {
self.root
.lang_items
- .get(dep_graph, dep_node)
.decode(self)
.collect()
}
}
}
- pub fn get_item_attrs(&self,
- node_id: DefIndex,
- dep_graph: &DepGraph) -> Rc<[ast::Attribute]> {
+ pub fn get_item_attrs(&self, node_id: DefIndex) -> Rc<[ast::Attribute]> {
let (node_as, node_index) =
(node_id.address_space().index(), node_id.as_array_index());
if self.is_proc_macro(node_id) {
return Rc::new([]);
}
- let dep_node = self.def_path_hash(node_id).to_dep_node(DepKind::MetaData);
- dep_graph.read(dep_node);
-
if let Some(&Some(ref val)) =
self.attribute_cache.borrow()[node_as].get(node_index) {
return val.clone();
pub fn get_implementations_for_trait(&self,
filter: Option<DefId>,
- dep_graph: &DepGraph,
result: &mut Vec<DefId>) {
// Do a reverse lookup beforehand to avoid touching the crate_num
// hash map in the loop below.
None => None,
};
- let dep_node = self.metadata_dep_node(GlobalMetaDataKind::Impls);
-
if let Some(filter) = filter {
if let Some(impls) = self.trait_impls
- .get(dep_graph, dep_node)
.get(&filter) {
result.extend(impls.decode(self).map(|idx| self.local_def_id(idx)));
}
} else {
- for impls in self.trait_impls.get(dep_graph, dep_node).values() {
+ for impls in self.trait_impls.values() {
result.extend(impls.decode(self).map(|idx| self.local_def_id(idx)));
}
}
}
- pub fn get_native_libraries(&self,
- dep_graph: &DepGraph)
- -> Vec<NativeLibrary> {
- let dep_node = self.metadata_dep_node(GlobalMetaDataKind::NativeLibraries);
- self.root
- .native_libraries
- .get(dep_graph, dep_node)
- .decode(self)
- .collect()
+ pub fn get_native_libraries(&self) -> Vec<NativeLibrary> {
+ self.root.native_libraries.decode(self).collect()
}
- pub fn get_dylib_dependency_formats(&self,
- dep_graph: &DepGraph)
- -> Vec<(CrateNum, LinkagePreference)> {
- let dep_node =
- self.metadata_dep_node(GlobalMetaDataKind::DylibDependencyFormats);
+ pub fn get_dylib_dependency_formats(&self) -> Vec<(CrateNum, LinkagePreference)> {
self.root
.dylib_dependency_formats
- .get(dep_graph, dep_node)
.decode(self)
.enumerate()
.flat_map(|(i, link)| {
.collect()
}
- pub fn get_missing_lang_items(&self, dep_graph: &DepGraph) -> Vec<lang_items::LangItem> {
- let dep_node = self.metadata_dep_node(GlobalMetaDataKind::LangItemsMissing);
+ pub fn get_missing_lang_items(&self) -> Vec<lang_items::LangItem> {
self.root
.lang_items_missing
- .get(dep_graph, dep_node)
.decode(self)
.collect()
}
arg_names.decode(self).collect()
}
- pub fn get_exported_symbols(&self, dep_graph: &DepGraph) -> Vec<DefId> {
- let dep_node = self.metadata_dep_node(GlobalMetaDataKind::ExportedSymbols);
+ pub fn get_exported_symbols(&self) -> Vec<DefId> {
self.exported_symbols
- .get(dep_graph, dep_node)
.iter()
.map(|&index| self.local_def_id(index))
.collect()
}
}
- pub fn is_dllimport_foreign_item(&self, id: DefIndex, dep_graph: &DepGraph) -> bool {
- let dep_node = self.metadata_dep_node(GlobalMetaDataKind::NativeLibraries);
- self.dllimport_foreign_items
- .get(dep_graph, dep_node)
- .contains(&id)
+ pub fn is_dllimport_foreign_item(&self, id: DefIndex) -> bool {
+ self.dllimport_foreign_items.contains(&id)
}
pub fn is_default_impl(&self, impl_id: DefIndex) -> bool {
*self.codemap_import_info.borrow_mut() = imported_filemaps;
self.codemap_import_info.borrow()
}
-
- pub fn metadata_dep_node(&self, kind: GlobalMetaDataKind) -> DepNode {
- let def_index = kind.def_index(&self.def_path_table);
- let def_path_hash = self.def_path_table.def_path_hash(def_index);
- def_path_hash.to_dep_node(DepKind::MetaData)
- }
}
def_index: DefIndex,
op: fn(&mut IsolatedEncoder<'x, 'a, 'tcx>, DATA) -> R,
data: DATA)
- -> Tracked<R> {
+ -> R {
let mut entry_builder = IsolatedEncoder::new(self);
let ret = op(&mut entry_builder, data);
let (fingerprint, this) = entry_builder.finish();
})
}
- Tracked::new(ret)
+ ret
}
fn encode_info_for_items(&mut self) -> Index {
triple: tcx.sess.opts.target_triple.clone(),
hash: link_meta.crate_hash,
disambiguator: tcx.sess.local_crate_disambiguator(),
- panic_strategy: Tracked::new(tcx.sess.panic_strategy()),
- has_global_allocator: Tracked::new(has_global_allocator),
- has_default_lib_allocator: Tracked::new(has_default_lib_allocator),
+ panic_strategy: tcx.sess.panic_strategy(),
+ has_global_allocator: has_global_allocator,
+ has_default_lib_allocator: has_default_lib_allocator,
plugin_registrar_fn: tcx.sess
.plugin_registrar_fn
.get()
use rustc_data_structures::stable_hasher::{StableHasher, HashStable,
StableHasherResult};
-use rustc::dep_graph::{DepGraph, DepNode};
-
pub fn rustc_version() -> String {
format!("rustc {}",
option_env!("CFG_VERSION").unwrap_or("unknown version"))
Previous(usize),
}
-/// A `Tracked<T>` wraps a value so that one can only access it when specifying
-/// the `DepNode` for that value. This makes it harder to forget registering
-/// reads.
-#[derive(RustcEncodable, RustcDecodable)]
-pub struct Tracked<T> {
- state: T,
-}
-
-impl<T> Tracked<T> {
- pub fn new(state: T) -> Tracked<T> {
- Tracked {
- state,
- }
- }
-
- pub fn get(&self, dep_graph: &DepGraph, dep_node: DepNode) -> &T {
- dep_graph.read(dep_node);
- &self.state
- }
-
- pub fn get_untracked(&self) -> &T {
- &self.state
- }
-
- pub fn map<F, R>(&self, f: F) -> Tracked<R>
- where F: FnOnce(&T) -> R
- {
- Tracked {
- state: f(&self.state),
- }
- }
-}
-
-impl<'a, 'gcx, 'tcx, T> HashStable<StableHashingContext<'a, 'gcx, 'tcx>> for Tracked<T>
- where T: HashStable<StableHashingContext<'a, 'gcx, 'tcx>>
-{
- fn hash_stable<W: StableHasherResult>(&self,
- hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>,
- hasher: &mut StableHasher<W>) {
- let Tracked {
- ref state
- } = *self;
-
- state.hash_stable(hcx, hasher);
- }
-}
-
-
#[derive(RustcEncodable, RustcDecodable)]
pub struct CrateRoot {
pub name: Symbol,
pub triple: String,
pub hash: hir::svh::Svh,
pub disambiguator: Symbol,
- pub panic_strategy: Tracked<PanicStrategy>,
- pub has_global_allocator: Tracked<bool>,
- pub has_default_lib_allocator: Tracked<bool>,
+ pub panic_strategy: PanicStrategy,
+ pub has_global_allocator: bool,
+ pub has_default_lib_allocator: bool,
pub plugin_registrar_fn: Option<DefIndex>,
pub macro_derive_registrar: Option<DefIndex>,
- pub crate_deps: Tracked<LazySeq<CrateDep>>,
- pub dylib_dependency_formats: Tracked<LazySeq<Option<LinkagePreference>>>,
- pub lang_items: Tracked<LazySeq<(DefIndex, usize)>>,
- pub lang_items_missing: Tracked<LazySeq<lang_items::LangItem>>,
- pub native_libraries: Tracked<LazySeq<NativeLibrary>>,
+ pub crate_deps: LazySeq<CrateDep>,
+ pub dylib_dependency_formats: LazySeq<Option<LinkagePreference>>,
+ pub lang_items: LazySeq<(DefIndex, usize)>,
+ pub lang_items_missing: LazySeq<lang_items::LangItem>,
+ pub native_libraries: LazySeq<NativeLibrary>,
pub codemap: LazySeq<syntax_pos::FileMap>,
pub def_path_table: Lazy<hir::map::definitions::DefPathTable>,
- pub impls: Tracked<LazySeq<TraitImpls>>,
- pub exported_symbols: Tracked<LazySeq<DefIndex>>,
+ pub impls: LazySeq<TraitImpls>,
+ pub exported_symbols: LazySeq<DefIndex>,
pub index: LazySeq<index::Index>,
}
let dep_graph = DepGraph::new(false);
let _ignore = dep_graph.in_ignore();
- let cstore = Rc::new(CStore::new(&dep_graph, box rustc_trans::LlvmMetadataLoader));
+ let cstore = Rc::new(CStore::new(box rustc_trans::LlvmMetadataLoader));
let mut sess = session::build_session_(
sessopts, &dep_graph, cpath, diagnostic_handler, codemap, cstore.clone()
);
let dep_graph = DepGraph::new(false);
let _ignore = dep_graph.in_ignore();
- let cstore = Rc::new(CStore::new(&dep_graph, box rustc_trans::LlvmMetadataLoader));
+ let cstore = Rc::new(CStore::new(box rustc_trans::LlvmMetadataLoader));
let mut sess = session::build_session_(
sessopts, &dep_graph, Some(input_path.clone()), handler, codemap.clone(), cstore.clone(),
);
let diagnostic_handler = errors::Handler::with_emitter(true, false, box emitter);
let dep_graph = DepGraph::new(false);
- let cstore = Rc::new(CStore::new(&dep_graph, box rustc_trans::LlvmMetadataLoader));
+ let cstore = Rc::new(CStore::new(box rustc_trans::LlvmMetadataLoader));
let mut sess = session::build_session_(
sessopts, &dep_graph, None, diagnostic_handler, codemap, cstore.clone(),
);
let descriptions = Registry::new(&rustc::DIAGNOSTICS);
let dep_graph = DepGraph::new(opts.build_dep_graph());
- let cstore = Rc::new(CStore::new(&dep_graph, Box::new(rustc_trans::LlvmMetadataLoader)));
+ let cstore = Rc::new(CStore::new(Box::new(rustc_trans::LlvmMetadataLoader)));
let sess = build_session(opts, &dep_graph, None, descriptions, cstore.clone());
rustc_trans::init(&sess);
rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess));
projects / rust.git / commitdiff