diff --git a/src/librustc/dep_graph/dep_node.rs b/src/librustc/dep_graph/dep_node.rs index 291d0d7c937ed..38ad473e4042f 100644 --- a/src/librustc/dep_graph/dep_node.rs +++ b/src/librustc/dep_graph/dep_node.rs @@ -176,7 +176,6 @@ pub enum DepNode { IsMirAvailable(D), ItemAttrs(D), FnArgNames(D), - FileMap(D, Arc), } impl DepNode { @@ -307,7 +306,6 @@ impl DepNode { ConstIsRvaluePromotableToStatic(ref d) => op(d).map(ConstIsRvaluePromotableToStatic), IsMirAvailable(ref d) => op(d).map(IsMirAvailable), GlobalMetaData(ref d, kind) => op(d).map(|d| GlobalMetaData(d, kind)), - FileMap(ref d, ref file_name) => op(d).map(|d| FileMap(d, file_name.clone())), } } } diff --git a/src/librustc/ich/caching_codemap_view.rs b/src/librustc/ich/caching_codemap_view.rs index b21c3a2b21600..9aecd8ad83602 100644 --- a/src/librustc/ich/caching_codemap_view.rs +++ b/src/librustc/ich/caching_codemap_view.rs @@ -8,11 +8,7 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -use dep_graph::{DepGraph, DepNode}; -use hir::def_id::{DefId, CrateNum, CRATE_DEF_INDEX}; -use rustc_data_structures::bitvec::BitVector; use std::rc::Rc; -use std::sync::Arc; use syntax::codemap::CodeMap; use syntax_pos::{BytePos, FileMap}; use ty::TyCtxt; @@ -31,14 +27,12 @@ pub struct CachingCodemapView<'tcx> { codemap: &'tcx CodeMap, line_cache: [CacheEntry; 3], time_stamp: usize, - dep_graph: DepGraph, - dep_tracking_reads: BitVector, } impl<'tcx> CachingCodemapView<'tcx> { pub fn new<'a>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> CachingCodemapView<'tcx> { let codemap = tcx.sess.codemap(); - let files = codemap.files_untracked(); + let files = codemap.files(); let first_file = files[0].clone(); let entry = CacheEntry { time_stamp: 0, @@ -50,11 +44,9 @@ impl<'tcx> CachingCodemapView<'tcx> { }; CachingCodemapView { - dep_graph: tcx.dep_graph.clone(), codemap: codemap, line_cache: [entry.clone(), entry.clone(), entry.clone()], time_stamp: 0, - dep_tracking_reads: BitVector::new(files.len()), } } @@ -67,9 +59,6 @@ impl<'tcx> CachingCodemapView<'tcx> { for cache_entry in self.line_cache.iter_mut() { if pos >= cache_entry.line_start && pos < cache_entry.line_end { cache_entry.time_stamp = self.time_stamp; - if self.dep_tracking_reads.insert(cache_entry.file_index) { - self.dep_graph.read(dep_node(cache_entry)); - } return Some((cache_entry.file.clone(), cache_entry.line_number, @@ -90,7 +79,7 @@ impl<'tcx> CachingCodemapView<'tcx> { // If the entry doesn't point to the correct file, fix it up if pos < cache_entry.file.start_pos || pos >= cache_entry.file.end_pos { let file_valid; - let files = self.codemap.files_untracked(); + let files = self.codemap.files(); if files.len() > 0 { let file_index = self.codemap.lookup_filemap_idx(pos); @@ -120,21 +109,8 @@ impl<'tcx> CachingCodemapView<'tcx> { cache_entry.line_end = line_bounds.1; cache_entry.time_stamp = self.time_stamp; - if self.dep_tracking_reads.insert(cache_entry.file_index) { - self.dep_graph.read(dep_node(cache_entry)); - } - return Some((cache_entry.file.clone(), cache_entry.line_number, pos - cache_entry.line_start)); } } - -fn dep_node(cache_entry: &CacheEntry) -> DepNode { - let def_id = DefId { - krate: CrateNum::from_u32(cache_entry.file.crate_of_origin), - index: CRATE_DEF_INDEX, - }; - let name = Arc::new(cache_entry.file.name.clone()); - DepNode::FileMap(def_id, name) -} diff --git a/src/librustc/ich/hcx.rs b/src/librustc/ich/hcx.rs index f25ec8ecd4d71..f8dddc42e48cc 100644 --- a/src/librustc/ich/hcx.rs +++ b/src/librustc/ich/hcx.rs @@ -74,6 +74,11 @@ impl<'a, 'tcx: 'a> StableHashingContext<'a, 'tcx> { } } + pub fn force_span_hashing(mut self) -> Self { + self.hash_spans = true; + self + } + #[inline] pub fn while_hashing_hir_bodies(&mut self, hash_bodies: bool, diff --git a/src/librustc/ich/impls_mir.rs b/src/librustc/ich/impls_mir.rs index 3ff8ffb35054a..d523d40ccd4ab 100644 --- a/src/librustc/ich/impls_mir.rs +++ b/src/librustc/ich/impls_mir.rs @@ -22,11 +22,55 @@ impl_stable_hash_for!(struct mir::SourceInfo { span, scope }); impl_stable_hash_for!(enum mir::Mutability { Mut, Not }); impl_stable_hash_for!(enum mir::BorrowKind { Shared, Unique, Mut }); impl_stable_hash_for!(enum mir::LocalKind { Var, Temp, Arg, ReturnPointer }); -impl_stable_hash_for!(struct mir::LocalDecl<'tcx> { mutability, ty, name, source_info, -is_user_variable}); +impl_stable_hash_for!(struct mir::LocalDecl<'tcx> { + mutability, + ty, + name, + source_info, + is_user_variable +}); impl_stable_hash_for!(struct mir::UpvarDecl { debug_name, by_ref }); impl_stable_hash_for!(struct mir::BasicBlockData<'tcx> { statements, terminator, is_cleanup }); -impl_stable_hash_for!(struct mir::Terminator<'tcx> { source_info, kind }); + +impl<'a, 'tcx> HashStable> for mir::Terminator<'tcx> { + #[inline] + fn hash_stable(&self, + hcx: &mut StableHashingContext<'a, 'tcx>, + hasher: &mut StableHasher) { + let mir::Terminator { + ref kind, + ref source_info, + } = *self; + + let hash_spans_unconditionally = match *kind { + mir::TerminatorKind::Assert { .. } => { + // Assert terminators generate a panic message that contains the + // source location, so we always have to feed its span into the + // ICH. + true + } + mir::TerminatorKind::Goto { .. } | + mir::TerminatorKind::SwitchInt { .. } | + mir::TerminatorKind::Resume | + mir::TerminatorKind::Return | + mir::TerminatorKind::Unreachable | + mir::TerminatorKind::Drop { .. } | + mir::TerminatorKind::DropAndReplace { .. } | + mir::TerminatorKind::Call { .. } => false, + }; + + if hash_spans_unconditionally { + hcx.while_hashing_spans(true, |hcx| { + source_info.hash_stable(hcx, hasher); + }) + } else { + source_info.hash_stable(hcx, hasher); + } + + kind.hash_stable(hcx, hasher); + } +} + impl<'a, 'tcx> HashStable> for mir::Local { #[inline] diff --git a/src/librustc/session/mod.rs b/src/librustc/session/mod.rs index 814246330a4c2..28531893659e6 100644 --- a/src/librustc/session/mod.rs +++ b/src/librustc/session/mod.rs @@ -11,8 +11,9 @@ pub use self::code_stats::{CodeStats, DataTypeKind, FieldInfo}; pub use self::code_stats::{SizeKind, TypeSizeInfo, VariantInfo}; -use dep_graph::{DepGraph, DepNode}; -use hir::def_id::{DefId, CrateNum, DefIndex, CRATE_DEF_INDEX}; +use dep_graph::DepGraph; +use hir::def_id::{CrateNum, DefIndex}; + use lint; use middle::cstore::CrateStore; use middle::dependency_format; @@ -32,7 +33,7 @@ use syntax::parse::ParseSess; use syntax::symbol::Symbol; use syntax::{ast, codemap}; use syntax::feature_gate::AttributeType; -use syntax_pos::{Span, MultiSpan, FileMap}; +use syntax_pos::{Span, MultiSpan}; use rustc_back::{LinkerFlavor, PanicStrategy}; use rustc_back::target::Target; @@ -46,7 +47,6 @@ use std::io::Write; use std::rc::Rc; use std::fmt; use std::time::Duration; -use std::sync::Arc; mod code_stats; pub mod config; @@ -626,21 +626,6 @@ pub fn build_session_(sopts: config::Options, }; let target_cfg = config::build_target_config(&sopts, &span_diagnostic); - // Hook up the codemap with a callback that allows it to register FileMap - // accesses with the dependency graph. - let cm_depgraph = dep_graph.clone(); - let codemap_dep_tracking_callback = Box::new(move |filemap: &FileMap| { - let def_id = DefId { - krate: CrateNum::from_u32(filemap.crate_of_origin), - index: CRATE_DEF_INDEX, - }; - let name = Arc::new(filemap.name.clone()); - let dep_node = DepNode::FileMap(def_id, name); - - cm_depgraph.read(dep_node); - }); - codemap.set_dep_tracking_callback(codemap_dep_tracking_callback); - let p_s = parse::ParseSess::with_span_handler(span_diagnostic, codemap); let default_sysroot = match sopts.maybe_sysroot { Some(_) => None, diff --git a/src/librustc_incremental/calculate_svh/mod.rs b/src/librustc_incremental/calculate_svh/mod.rs index c9ed9ad3c7d2d..f5727aa0a5ecc 100644 --- a/src/librustc_incremental/calculate_svh/mod.rs +++ b/src/librustc_incremental/calculate_svh/mod.rs @@ -29,10 +29,9 @@ use std::cell::RefCell; use std::hash::Hash; -use std::sync::Arc; use rustc::dep_graph::DepNode; use rustc::hir; -use rustc::hir::def_id::{LOCAL_CRATE, CRATE_DEF_INDEX, DefId}; +use rustc::hir::def_id::{CRATE_DEF_INDEX, DefId}; use rustc::hir::itemlikevisit::ItemLikeVisitor; use rustc::ich::{Fingerprint, StableHashingContext}; use rustc::ty::TyCtxt; @@ -155,11 +154,6 @@ impl<'a, 'tcx: 'a> ComputeItemHashesVisitor<'a, 'tcx> { // We want to incoporate these into the // SVH. } - DepNode::FileMap(..) => { - // These don't make a semantic - // difference, filter them out. - return None - } DepNode::AllLocalTraitImpls => { // These are already covered by hashing // the HIR. @@ -306,24 +300,6 @@ pub fn compute_incremental_hashes_map<'a, 'tcx: 'a>(tcx: TyCtxt<'a, 'tcx, 'tcx>) visitor.compute_and_store_ich_for_item_like(DepNode::HirBody(def_id), true, macro_def); } - for filemap in tcx.sess - .codemap() - .files_untracked() - .iter() - .filter(|fm| !fm.is_imported()) { - assert_eq!(LOCAL_CRATE.as_u32(), filemap.crate_of_origin); - let def_id = DefId { - krate: LOCAL_CRATE, - index: CRATE_DEF_INDEX, - }; - let name = Arc::new(filemap.name.clone()); - let dep_node = DepNode::FileMap(def_id, name); - let mut hasher = IchHasher::new(); - filemap.hash_stable(&mut visitor.hcx, &mut hasher); - let fingerprint = hasher.finish(); - visitor.hashes.insert(dep_node, fingerprint); - } - visitor.compute_and_store_ich_for_trait_impls(krate); }); diff --git a/src/librustc_incremental/persist/hash.rs b/src/librustc_incremental/persist/hash.rs index 2f727a80f016e..6ab280be470dd 100644 --- a/src/librustc_incremental/persist/hash.rs +++ b/src/librustc_incremental/persist/hash.rs @@ -51,8 +51,7 @@ impl<'a, 'tcx> HashContext<'a, 'tcx> { match *dep_node { DepNode::Krate | DepNode::Hir(_) | - DepNode::HirBody(_) | - DepNode::FileMap(..) => + DepNode::HirBody(_) => true, DepNode::MetaData(def_id) | DepNode::GlobalMetaData(def_id, _) => !def_id.is_local(), @@ -77,20 +76,6 @@ impl<'a, 'tcx> HashContext<'a, 'tcx> { Some(self.incremental_hashes_map[dep_node]) } - DepNode::FileMap(def_id, ref name) => { - if def_id.is_local() { - // We will have been able to retrace the DefId (which is - // always the local CRATE_DEF_INDEX), but the file with the - // given name might have been removed, so we use get() in - // order to allow for that case. - self.incremental_hashes_map.get(dep_node).map(|x| *x) - } else { - Some(self.metadata_hash(DepNode::FileMap(def_id, name.clone()), - def_id.krate, - |this| &mut this.global_metadata_hashes)) - } - } - // MetaData from other crates is an *input* to us. // MetaData nodes from *our* crates are an *output*; we // don't hash them, but we do compute a hash for them and @@ -242,7 +227,6 @@ impl<'a, 'tcx> HashContext<'a, 'tcx> { let def_id = DefId { krate: cnum, index: CRATE_DEF_INDEX }; let dep_node = match dep_node { DepNode::GlobalMetaData(_, kind) => DepNode::GlobalMetaData(def_id, kind), - DepNode::FileMap(_, name) => DepNode::FileMap(def_id, name), other => { bug!("unexpected DepNode variant: {:?}", other) } diff --git a/src/librustc_metadata/encoder.rs b/src/librustc_metadata/encoder.rs index 93fcdc455e5dd..317b14e4ad27d 100644 --- a/src/librustc_metadata/encoder.rs +++ b/src/librustc_metadata/encoder.rs @@ -18,7 +18,7 @@ use rustc::middle::cstore::{LinkMeta, LinkagePreference, NativeLibrary, use rustc::hir::def_id::{CrateNum, CRATE_DEF_INDEX, DefIndex, DefId, LOCAL_CRATE}; use rustc::hir::map::definitions::DefPathTable; use rustc::dep_graph::{DepNode, GlobalMetaDataKind}; -use rustc::ich::{StableHashingContext, Fingerprint}; +use rustc::ich::Fingerprint; use rustc::middle::dependency_format::Linkage; use rustc::middle::lang_items; use rustc::mir; @@ -29,7 +29,6 @@ use rustc::session::config::{self, CrateTypeProcMacro}; use rustc::util::nodemap::{FxHashMap, NodeSet}; use rustc_serialize::{Encodable, Encoder, SpecializedEncoder, opaque}; -use rustc_data_structures::stable_hasher::{StableHasher, HashStable}; use std::hash::Hash; use std::intrinsics; @@ -37,7 +36,6 @@ use std::io::prelude::*; use std::io::Cursor; use std::path::Path; use std::rc::Rc; -use std::sync::Arc; use std::u32; use syntax::ast::{self, CRATE_NODE_ID}; use syntax::codemap::Spanned; @@ -284,7 +282,6 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> { let codemap = self.tcx.sess.codemap(); let all_filemaps = codemap.files(); - let hcx = &mut StableHashingContext::new(self.tcx); let (working_dir, working_dir_was_remapped) = self.tcx.sess.working_dir.clone(); let adapted = all_filemaps.iter() @@ -316,21 +313,10 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> { adapted.name = abs_path; Rc::new(adapted) } - }); - - let filemaps: Vec<_> = if self.compute_ich { - adapted.inspect(|filemap| { - let mut hasher = StableHasher::new(); - filemap.hash_stable(hcx, &mut hasher); - let fingerprint = hasher.finish(); - let dep_node = DepNode::FileMap((), Arc::new(filemap.name.clone())); - self.metadata_hashes.global_hashes.push((dep_node, fingerprint)); - }).collect() - } else { - adapted.collect() - }; + }) + .collect::>(); - self.lazy_seq_ref(filemaps.iter().map(|fm| &**fm)) + self.lazy_seq_ref(adapted.iter().map(|rc| &**rc)) } fn encode_crate_root(&mut self) -> Lazy { diff --git a/src/librustc_metadata/isolated_encoder.rs b/src/librustc_metadata/isolated_encoder.rs index 7722a7b10c996..ed1680fbfaee8 100644 --- a/src/librustc_metadata/isolated_encoder.rs +++ b/src/librustc_metadata/isolated_encoder.rs @@ -35,7 +35,17 @@ impl<'a, 'b: 'a, 'tcx: 'b> IsolatedEncoder<'a, 'b, 'tcx> { tcx: tcx, ecx: ecx, hcx: if compute_ich { - Some((StableHashingContext::new(tcx), StableHasher::new())) + // We are always hashing spans for things in metadata because + // don't know if a downstream crate will use them or not. + // Except when -Zquery-dep-graph is specified because we don't + // want to mess up our tests. + let hcx = if tcx.sess.opts.debugging_opts.query_dep_graph { + StableHashingContext::new(tcx) + } else { + StableHashingContext::new(tcx).force_span_hashing() + }; + + Some((hcx, StableHasher::new())) } else { None } diff --git a/src/libsyntax/codemap.rs b/src/libsyntax/codemap.rs index d32c3ec5f46b1..bbe5bd4a10cf1 100644 --- a/src/libsyntax/codemap.rs +++ b/src/libsyntax/codemap.rs @@ -103,18 +103,11 @@ impl FileLoader for RealFileLoader { // pub struct CodeMap { - // The `files` field should not be visible outside of libsyntax so that we - // can do proper dependency tracking. pub(super) files: RefCell>>, file_loader: Box, // This is used to apply the file path remapping as specified via // -Zremap-path-prefix to all FileMaps allocated within this CodeMap. path_mapping: FilePathMapping, - // The CodeMap will invoke this callback whenever a specific FileMap is - // accessed. The callback starts out as a no-op but when the dependency - // graph becomes available later during the compilation process, it is - // be replaced with something that notifies the dep-tracking system. - dep_tracking_callback: RefCell>, } impl CodeMap { @@ -123,7 +116,6 @@ impl CodeMap { files: RefCell::new(Vec::new()), file_loader: Box::new(RealFileLoader), path_mapping: path_mapping, - dep_tracking_callback: RefCell::new(Box::new(|_| {})), } } @@ -134,7 +126,6 @@ impl CodeMap { files: RefCell::new(Vec::new()), file_loader: file_loader, path_mapping: path_mapping, - dep_tracking_callback: RefCell::new(Box::new(|_| {})), } } @@ -142,10 +133,6 @@ impl CodeMap { &self.path_mapping } - pub fn set_dep_tracking_callback(&self, cb: Box) { - *self.dep_tracking_callback.borrow_mut() = cb; - } - pub fn file_exists(&self, path: &Path) -> bool { self.file_loader.file_exists(path) } @@ -156,15 +143,6 @@ impl CodeMap { } pub fn files(&self) -> Ref>> { - let files = self.files.borrow(); - for file in files.iter() { - (self.dep_tracking_callback.borrow())(file); - } - files - } - - /// Only use this if you do your own dependency tracking! - pub fn files_untracked(&self) -> Ref>> { self.files.borrow() } @@ -311,8 +289,6 @@ impl CodeMap { let files = self.files.borrow(); let f = (*files)[idx].clone(); - (self.dep_tracking_callback.borrow())(&f); - match f.lookup_line(pos) { Some(line) => Ok(FileMapAndLine { fm: f, line: line }), None => Err(f) @@ -502,7 +478,6 @@ impl CodeMap { pub fn get_filemap(&self, filename: &str) -> Option> { for fm in self.files.borrow().iter() { if filename == fm.name { - (self.dep_tracking_callback.borrow())(fm); return Some(fm.clone()); } } @@ -513,7 +488,6 @@ impl CodeMap { pub fn lookup_byte_offset(&self, bpos: BytePos) -> FileMapAndBytePos { let idx = self.lookup_filemap_idx(bpos); let fm = (*self.files.borrow())[idx].clone(); - (self.dep_tracking_callback.borrow())(&fm); let offset = bpos - fm.start_pos; FileMapAndBytePos {fm: fm, pos: offset} } @@ -524,8 +498,6 @@ impl CodeMap { let files = self.files.borrow(); let map = &(*files)[idx]; - (self.dep_tracking_callback.borrow())(map); - // The number of extra bytes due to multibyte chars in the FileMap let mut total_extra_bytes = 0; diff --git a/src/test/incremental/rlib_cross_crate/auxiliary/a.rs b/src/test/incremental/rlib_cross_crate/auxiliary/a.rs index ff5fd63471449..1099aeb921763 100644 --- a/src/test/incremental/rlib_cross_crate/auxiliary/a.rs +++ b/src/test/incremental/rlib_cross_crate/auxiliary/a.rs @@ -9,6 +9,7 @@ // except according to those terms. // no-prefer-dynamic +// compile-flags: -Z query-dep-graph #![crate_type="rlib"] diff --git a/src/test/incremental/type_alias_cross_crate/auxiliary/a.rs b/src/test/incremental/type_alias_cross_crate/auxiliary/a.rs index e1dba1317703d..2ae434071f2c5 100644 --- a/src/test/incremental/type_alias_cross_crate/auxiliary/a.rs +++ b/src/test/incremental/type_alias_cross_crate/auxiliary/a.rs @@ -8,6 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. +// compile-flags: -Z query-dep-graph + #![crate_type="rlib"] #[cfg(rpass1)]