From d724d03389706e4efc72ea3865d9c2c185003fd2 Mon Sep 17 00:00:00 2001 From: Alex Crichton Date: Thu, 7 Sep 2017 12:35:21 -0700 Subject: [PATCH] rustc: Remove `DepGraph` handling from rustc_metadata This should now be entirely tracked through queries, so no need to have a `DepGraph` in the `CStore` object any more! --- src/librustc_driver/lib.rs | 4 +- src/librustc_driver/test.rs | 2 +- src/librustc_metadata/creader.rs | 66 +++++++++--------------- src/librustc_metadata/cstore.rs | 76 ++++++++++------------------ src/librustc_metadata/cstore_impl.rs | 52 ++++++++----------- src/librustc_metadata/decoder.rs | 59 ++++----------------- src/librustc_metadata/encoder.rs | 10 ++-- src/librustc_metadata/schema.rs | 70 ++++--------------------- src/librustdoc/core.rs | 2 +- src/librustdoc/test.rs | 4 +- src/test/run-make/issue-19371/foo.rs | 2 +- 11 files changed, 102 insertions(+), 245 deletions(-) diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs index 5011b53799043..78b20a73b83c3 100644 --- a/src/librustc_driver/lib.rs +++ b/src/librustc_driver/lib.rs @@ -294,7 +294,7 @@ pub fn run_compiler<'a>(args: &[String], }; 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())); @@ -574,7 +574,7 @@ impl<'a> CompilerCalls<'a> for RustcDefaultCalls { 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, diff --git a/src/librustc_driver/test.rs b/src/librustc_driver/test.rs index de710942ca189..8038045f762d5 100644 --- a/src/librustc_driver/test.rs +++ b/src/librustc_driver/test.rs @@ -104,7 +104,7 @@ fn test_env(source_string: &str, 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, diff --git a/src/librustc_metadata/creader.rs b/src/librustc_metadata/creader.rs index 7f018a7f5a6d5..603c74c2ae4c6 100644 --- a/src/librustc_metadata/creader.rs +++ b/src/librustc_metadata/creader.rs @@ -13,7 +13,7 @@ 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; @@ -261,16 +261,13 @@ impl<'a> CrateLoader<'a> { 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, @@ -295,23 +292,17 @@ impl<'a> CrateLoader<'a> { }, // 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> = 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; @@ -469,7 +460,6 @@ impl<'a> CrateLoader<'a> { // 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); @@ -692,16 +682,14 @@ impl<'a> CrateLoader<'a> { 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; } }); @@ -737,11 +725,11 @@ impl<'a> CrateLoader<'a> { // 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())); @@ -749,7 +737,7 @@ impl<'a> CrateLoader<'a> { 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) { @@ -844,7 +832,7 @@ impl<'a> CrateLoader<'a> { 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)); } @@ -865,7 +853,7 @@ impl<'a> CrateLoader<'a> { 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")); } @@ -883,9 +871,8 @@ impl<'a> CrateLoader<'a> { // 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 @@ -917,14 +904,13 @@ impl<'a> CrateLoader<'a> { // 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 { @@ -983,12 +969,6 @@ impl<'a> CrateLoader<'a> { 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 @@ -1001,7 +981,7 @@ impl<'a> CrateLoader<'a> { 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; } } diff --git a/src/librustc_metadata/cstore.rs b/src/librustc_metadata/cstore.rs index 2d10dadaf6415..83a468171ccfe 100644 --- a/src/librustc_metadata/cstore.rs +++ b/src/librustc_metadata/cstore.rs @@ -11,11 +11,10 @@ // 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; @@ -78,20 +77,19 @@ pub struct CrateMetadata { /// compilation support. pub def_path_table: Rc, - pub exported_symbols: Tracked>, + pub exported_symbols: FxHashSet, - pub trait_impls: Tracked>>, + pub trait_impls: FxHashMap<(u32, DefIndex), schema::LazySeq>, pub dep_kind: Cell, pub source: CrateSource, pub proc_macros: Option)>>, // Foreign items imported from a dylib (Windows only) - pub dllimport_foreign_items: Tracked>, + pub dllimport_foreign_items: FxHashSet, } pub struct CStore { - pub dep_graph: DepGraph, metas: RefCell>>, /// Map from NodeId's of local extern crate statements to crate numbers extern_mod_crate_map: RefCell>, @@ -99,9 +97,8 @@ pub struct CStore { } impl CStore { - pub fn new(dep_graph: &DepGraph, metadata_loader: Box) -> CStore { + pub fn new(metadata_loader: Box) -> CStore { CStore { - dep_graph: dep_graph.clone(), metas: RefCell::new(FxHashMap()), extern_mod_crate_map: RefCell::new(FxHashMap()), metadata_loader, @@ -165,13 +162,6 @@ impl CStore { pub fn do_extern_mod_stmt_cnum(&self, emod_id: ast::NodeId) -> Option { 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 { @@ -185,62 +175,50 @@ 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() } } diff --git a/src/librustc_metadata/cstore_impl.rs b/src/librustc_metadata/cstore_impl.rs index 776fd35829000..c3742fc1d03d8 100644 --- a/src/librustc_metadata/cstore_impl.rs +++ b/src/librustc_metadata/cstore_impl.rs @@ -27,7 +27,7 @@ use rustc::ty::maps::Providers; 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; @@ -148,7 +148,7 @@ provide! { <'tcx> tcx, def_id, other, cdata, 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 @@ -157,8 +157,7 @@ provide! { <'tcx> tcx, def_id, other, cdata, 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 => { @@ -166,18 +165,18 @@ provide! { <'tcx> tcx, def_id, other, cdata, } 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 } @@ -195,18 +194,18 @@ provide! { <'tcx> tcx, def_id, other, cdata, 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() } @@ -216,8 +215,8 @@ provide! { <'tcx> tcx, def_id, other, cdata, 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); @@ -362,34 +361,25 @@ impl CrateStore for cstore::CStore { } 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) } @@ -431,13 +421,11 @@ impl CrateStore for cstore::CStore { fn struct_field_names_untracked(&self, def: DefId) -> Vec { - 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 { - 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); @@ -462,7 +450,7 @@ impl CrateStore for cstore::CStore { 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); } diff --git a/src/librustc_metadata/decoder.rs b/src/librustc_metadata/decoder.rs index 324bab369dc7d..73f1ae253cd29 100644 --- a/src/librustc_metadata/decoder.rs +++ b/src/librustc_metadata/decoder.rs @@ -13,9 +13,7 @@ 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; @@ -402,7 +400,6 @@ impl<'a, 'tcx> MetadataBlob { 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)?; @@ -646,11 +643,9 @@ impl<'a, 'tcx> CrateMetadata { } /// 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() } @@ -869,18 +864,13 @@ impl<'a, 'tcx> CrateMetadata { } } - 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(); @@ -947,7 +937,6 @@ impl<'a, 'tcx> CrateMetadata { pub fn get_implementations_for_trait(&self, filter: Option, - dep_graph: &DepGraph, result: &mut Vec) { // Do a reverse lookup beforehand to avoid touching the crate_num // hash map in the loop below. @@ -958,16 +947,13 @@ impl<'a, 'tcx> CrateMetadata { 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))); } } @@ -983,25 +969,13 @@ impl<'a, 'tcx> CrateMetadata { } - pub fn get_native_libraries(&self, - dep_graph: &DepGraph) - -> Vec { - 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 { + 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)| { @@ -1011,11 +985,9 @@ impl<'a, 'tcx> CrateMetadata { .collect() } - pub fn get_missing_lang_items(&self, dep_graph: &DepGraph) -> Vec { - let dep_node = self.metadata_dep_node(GlobalMetaDataKind::LangItemsMissing); + pub fn get_missing_lang_items(&self) -> Vec { self.root .lang_items_missing - .get(dep_graph, dep_node) .decode(self) .collect() } @@ -1030,10 +1002,8 @@ impl<'a, 'tcx> CrateMetadata { arg_names.decode(self).collect() } - pub fn get_exported_symbols(&self, dep_graph: &DepGraph) -> Vec { - let dep_node = self.metadata_dep_node(GlobalMetaDataKind::ExportedSymbols); + pub fn get_exported_symbols(&self) -> Vec { self.exported_symbols - .get(dep_graph, dep_node) .iter() .map(|&index| self.local_def_id(index)) .collect() @@ -1065,11 +1035,8 @@ impl<'a, 'tcx> CrateMetadata { } } - 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 { @@ -1221,10 +1188,4 @@ impl<'a, 'tcx> CrateMetadata { *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) - } } diff --git a/src/librustc_metadata/encoder.rs b/src/librustc_metadata/encoder.rs index a27a85a63e8a7..3b07177b1b5c8 100644 --- a/src/librustc_metadata/encoder.rs +++ b/src/librustc_metadata/encoder.rs @@ -248,7 +248,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> { def_index: DefIndex, op: fn(&mut IsolatedEncoder<'x, 'a, 'tcx>, DATA) -> R, data: DATA) - -> Tracked { + -> R { let mut entry_builder = IsolatedEncoder::new(self); let ret = op(&mut entry_builder, data); let (fingerprint, this) = entry_builder.finish(); @@ -260,7 +260,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> { }) } - Tracked::new(ret) + ret } fn encode_info_for_items(&mut self) -> Index { @@ -408,9 +408,9 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> { 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() diff --git a/src/librustc_metadata/schema.rs b/src/librustc_metadata/schema.rs index d065a0fc21c6c..ee196d74bb814 100644 --- a/src/librustc_metadata/schema.rs +++ b/src/librustc_metadata/schema.rs @@ -32,8 +32,6 @@ use std::mem; 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")) @@ -188,75 +186,27 @@ pub enum LazyState { Previous(usize), } -/// A `Tracked` 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 { - state: T, -} - -impl Tracked { - pub fn new(state: T) -> Tracked { - 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(&self, f: F) -> Tracked - where F: FnOnce(&T) -> R - { - Tracked { - state: f(&self.state), - } - } -} - -impl<'a, 'gcx, 'tcx, T> HashStable> for Tracked - where T: HashStable> -{ - fn hash_stable(&self, - hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>, - hasher: &mut StableHasher) { - 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, - pub has_global_allocator: Tracked, - pub has_default_lib_allocator: Tracked, + pub panic_strategy: PanicStrategy, + pub has_global_allocator: bool, + pub has_default_lib_allocator: bool, pub plugin_registrar_fn: Option, pub macro_derive_registrar: Option, - pub crate_deps: Tracked>, - pub dylib_dependency_formats: Tracked>>, - pub lang_items: Tracked>, - pub lang_items_missing: Tracked>, - pub native_libraries: Tracked>, + pub crate_deps: LazySeq, + pub dylib_dependency_formats: LazySeq>, + pub lang_items: LazySeq<(DefIndex, usize)>, + pub lang_items_missing: LazySeq, + pub native_libraries: LazySeq, pub codemap: LazySeq, pub def_path_table: Lazy, - pub impls: Tracked>, - pub exported_symbols: Tracked>, + pub impls: LazySeq, + pub exported_symbols: LazySeq, pub index: LazySeq, } diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs index 58de0e1caecdb..742d4bf197ee2 100644 --- a/src/librustdoc/core.rs +++ b/src/librustdoc/core.rs @@ -146,7 +146,7 @@ pub fn run_core(search_paths: SearchPaths, 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() ); diff --git a/src/librustdoc/test.rs b/src/librustdoc/test.rs index 5d74cbdf56a19..700bbe23bab72 100644 --- a/src/librustdoc/test.rs +++ b/src/librustdoc/test.rs @@ -85,7 +85,7 @@ pub fn run(input: &str, 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(), ); @@ -238,7 +238,7 @@ fn run_test(test: &str, cratename: &str, filename: &str, cfgs: Vec, libs 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(), ); diff --git a/src/test/run-make/issue-19371/foo.rs b/src/test/run-make/issue-19371/foo.rs index e96588c6e5aea..9caf83d995444 100644 --- a/src/test/run-make/issue-19371/foo.rs +++ b/src/test/run-make/issue-19371/foo.rs @@ -59,7 +59,7 @@ fn basic_sess(sysroot: PathBuf) -> (Session, Rc) { 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));