Reimplement the dep_graph.

Author: cjgillot

compiler/rustc_incremental/src/persist/dirty_clean.rs

@@ -14,15 +14,14 @@
 //! the required condition is not met.
 
 use rustc_ast::{self as ast, Attribute, NestedMetaItem};
-use rustc_data_structures::fingerprint::Fingerprint;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir as hir;
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::intravisit;
 use rustc_hir::itemlikevisit::ItemLikeVisitor;
 use rustc_hir::Node as HirNode;
 use rustc_hir::{ImplItemKind, ItemKind as HirItem, TraitItemKind};
-use rustc_middle::dep_graph::{label_strs, DepNode, DepNodeExt};
+use rustc_middle::dep_graph::{label_strs, DepNode, DepNodeColor, DepNodeExt};
 use rustc_middle::hir::map::Map;
 use rustc_middle::ty::TyCtxt;
 use rustc_span::symbol::{sym, Symbol};
@@ -391,39 +390,18 @@ impl DirtyCleanVisitor<'tcx> {
     fn assert_dirty(&self, item_span: Span, dep_node: DepNode) {
         debug!("assert_dirty({:?})", dep_node);
 
-        let current_fingerprint = self.get_fingerprint(&dep_node);
-        let prev_fingerprint = self.tcx.dep_graph.prev_fingerprint_of(&dep_node);
-
-        if current_fingerprint == prev_fingerprint {
+        if self.tcx.dep_graph.node_color(&dep_node) == Some(DepNodeColor::Green) {
             let dep_node_str = self.dep_node_str(&dep_node);
             self.tcx
                 .sess
                 .span_err(item_span, &format!("`{}` should be dirty but is not", dep_node_str));
         }
     }
 
-    fn get_fingerprint(&self, dep_node: &DepNode) -> Option<Fingerprint> {
-        if self.tcx.dep_graph.dep_node_exists(dep_node) {
-            let dep_node_index = self.tcx.dep_graph.dep_node_index_of(dep_node);
-            Some(self.tcx.dep_graph.fingerprint_of(dep_node_index))
-        } else {
-            None
-        }
-    }
-
     fn assert_clean(&self, item_span: Span, dep_node: DepNode) {
         debug!("assert_clean({:?})", dep_node);
 
-        let current_fingerprint = self.get_fingerprint(&dep_node);
-        let prev_fingerprint = self.tcx.dep_graph.prev_fingerprint_of(&dep_node);
-
-        // if the node wasn't previously evaluated and now is (or vice versa),
-        // then the node isn't actually clean or dirty.
-        if (current_fingerprint == None) ^ (prev_fingerprint == None) {
-            return;
-        }
-
-        if current_fingerprint != prev_fingerprint {
+        if self.tcx.dep_graph.node_color(&dep_node) == Some(DepNodeColor::Red) {
             let dep_node_str = self.dep_node_str(&dep_node);
             self.tcx
                 .sess

compiler/rustc_incremental/src/persist/load.rs

@@ -2,7 +2,7 @@
 
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::definitions::Definitions;
-use rustc_middle::dep_graph::{PreviousDepGraph, SerializedDepGraph, WorkProduct, WorkProductId};
+use rustc_middle::dep_graph::{SerializedDepGraph, WorkProduct, WorkProductId};
 use rustc_middle::ty::query::OnDiskCache;
 use rustc_serialize::opaque::Decoder;
 use rustc_serialize::Decodable as RustcDecodable;
@@ -22,8 +22,8 @@ pub enum LoadResult<T> {
     Error { message: String },
 }
 
-impl LoadResult<(PreviousDepGraph, WorkProductMap)> {
-    pub fn open(self, sess: &Session) -> (PreviousDepGraph, WorkProductMap) {
+impl LoadResult<(SerializedDepGraph, WorkProductMap)> {
+    pub fn open(self, sess: &Session) -> (SerializedDepGraph, WorkProductMap) {
         match self {
             LoadResult::Error { message } => {
                 sess.warn(&message);
@@ -84,7 +84,7 @@ impl<T> MaybeAsync<T> {
     }
 }
 
-pub type DepGraphFuture = MaybeAsync<LoadResult<(PreviousDepGraph, WorkProductMap)>>;
+pub type DepGraphFuture = MaybeAsync<LoadResult<(SerializedDepGraph, WorkProductMap)>>;
 
 /// Launch a thread and load the dependency graph in the background.
 pub fn load_dep_graph(sess: &Session) -> DepGraphFuture {
@@ -185,7 +185,7 @@ pub fn load_dep_graph(sess: &Session) -> DepGraphFuture {
                 let dep_graph = SerializedDepGraph::decode(&mut decoder)
                     .expect("Error reading cached dep-graph");
 
-                LoadResult::Ok { data: (PreviousDepGraph::new(dep_graph), prev_work_products) }
+                LoadResult::Ok { data: (dep_graph, prev_work_products) }
             }
         }
     }))

compiler/rustc_middle/src/dep_graph/dep_node.rs

@@ -64,7 +64,7 @@ use rustc_hir::HirId;
 use rustc_span::symbol::Symbol;
 use std::hash::Hash;
 
-pub use rustc_query_system::dep_graph::{DepContext, DepNodeParams};
+pub use rustc_query_system::dep_graph::{DepContext, DepNodeColor, DepNodeParams};
 
 /// This struct stores metadata about each DepKind.
 ///

compiler/rustc_middle/src/dep_graph/mod.rs

@@ -18,7 +18,6 @@ pub use dep_node::{label_strs, DepKind, DepNode, DepNodeExt};
 pub type DepGraph = rustc_query_system::dep_graph::DepGraph<DepKind>;
 pub type TaskDeps = rustc_query_system::dep_graph::TaskDeps<DepKind>;
 pub type DepGraphQuery = rustc_query_system::dep_graph::DepGraphQuery<DepKind>;
-pub type PreviousDepGraph = rustc_query_system::dep_graph::PreviousDepGraph<DepKind>;
 pub type SerializedDepGraph = rustc_query_system::dep_graph::SerializedDepGraph<DepKind>;
 
 impl rustc_query_system::dep_graph::DepKind for DepKind {

compiler/rustc_middle/src/ty/query/mod.rs

@@ -43,6 +43,7 @@ use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, DefIdSet, LocalDefId};
 use rustc_hir::lang_items::{LangItem, LanguageItems};
 use rustc_hir::{Crate, ItemLocalId, TraitCandidate};
 use rustc_index::{bit_set::FiniteBitSet, vec::IndexVec};
+use rustc_query_system::dep_graph::{DepNodeIndex, SerializedDepNodeIndex};
 use rustc_serialize::opaque;
 use rustc_session::config::{EntryFnType, OptLevel, OutputFilenames, SymbolManglingVersion};
 use rustc_session::utils::NativeLibKind;
@@ -237,6 +238,7 @@ macro_rules! define_callbacks {
                 tcx: TyCtxt<'tcx>,
                 encoder: &mut on_disk_cache::CacheEncoder<'a, 'tcx, opaque::FileEncoder>,
                 query_result_index: &mut on_disk_cache::EncodedQueryResultIndex,
+                remap: &IndexVec<DepNodeIndex, Option<SerializedDepNodeIndex>>,
             ) -> opaque::FileEncodeResult;
 
             fn exec_cache_promotions(&'tcx self, tcx: TyCtxt<'tcx>);

compiler/rustc_middle/src/ty/query/on_disk_cache.rs

@@ -13,7 +13,7 @@ use rustc_errors::Diagnostic;
 use rustc_hir::def_id::{CrateNum, DefId, DefIndex, LocalDefId, LOCAL_CRATE};
 use rustc_hir::definitions::DefPathHash;
 use rustc_hir::definitions::Definitions;
-use rustc_index::vec::{Idx, IndexVec};
+use rustc_index::vec::IndexVec;
 use rustc_query_system::dep_graph::DepContext;
 use rustc_query_system::query::QueryContext;
 use rustc_serialize::{
@@ -303,13 +303,15 @@ impl<'sess> OnDiskCache<'sess> {
                 latest_foreign_def_path_hashes,
             };
 
+            let remap = tcx.dep_graph.compression_map();
+
             // Encode query results.
             let mut query_result_index = EncodedQueryResultIndex::new();
 
             tcx.sess.time("encode_query_results", || -> FileEncodeResult {
                 let enc = &mut encoder;
                 let qri = &mut query_result_index;
-                tcx.queries.encode_query_results(tcx, enc, qri)
+                tcx.queries.encode_query_results(tcx, enc, qri, &remap)
             })?;
 
             // Encode diagnostics.
@@ -318,11 +320,11 @@ impl<'sess> OnDiskCache<'sess> {
                 .borrow()
                 .iter()
                 .map(
-                    |(dep_node_index, diagnostics)| -> Result<_, <FileEncoder as Encoder>::Error> {
+                    |(&dep_node_index, diagnostics)| -> Result<_, <FileEncoder as Encoder>::Error> {
                         let pos = AbsoluteBytePos::new(encoder.position());
                         // Let's make sure we get the expected type here.
                         let diagnostics: &EncodedDiagnostics = diagnostics;
-                        let dep_node_index = SerializedDepNodeIndex::new(dep_node_index.index());
+                        let dep_node_index = remap[dep_node_index].unwrap();
                         encoder.encode_tagged(dep_node_index, diagnostics)?;
 
                         Ok((dep_node_index, pos))
@@ -1220,6 +1222,7 @@ pub fn encode_query_results<'a, 'tcx, CTX, Q>(
     tcx: CTX,
     encoder: &mut CacheEncoder<'a, 'tcx, FileEncoder>,
     query_result_index: &mut EncodedQueryResultIndex,
+    remap: &IndexVec<DepNodeIndex, Option<SerializedDepNodeIndex>>,
 ) -> FileEncodeResult
 where
     CTX: QueryContext + 'tcx,
@@ -1236,7 +1239,7 @@ where
     cache.iter_results(|results| {
         for (key, value, dep_node) in results {
             if Q::cache_on_disk(tcx, &key, Some(value)) {
-                let dep_node = SerializedDepNodeIndex::new(dep_node.index());
+                let dep_node = remap[dep_node].unwrap();
 
                 // Record position of the cache entry.
                 query_result_index

compiler/rustc_query_impl/src/lib.rs

@@ -26,6 +26,7 @@ use rustc_middle::ich::StableHashingContext;
 use rustc_middle::ty::query::{query_keys, query_storage, query_stored, query_values};
 use rustc_middle::ty::query::{Providers, QueryEngine};
 use rustc_middle::ty::{self, TyCtxt};
+use rustc_query_system::dep_graph::{DepNodeColor, DepNodeIndex, SerializedDepNodeIndex};
 use rustc_serialize::opaque;
 use rustc_span::{Span, DUMMY_SP};
 

compiler/rustc_query_impl/src/plumbing.rs

@@ -13,6 +13,7 @@ use rustc_query_system::query::{QueryContext, QueryDescription, QueryJobId, Quer
 use rustc_data_structures::sync::Lock;
 use rustc_data_structures::thin_vec::ThinVec;
 use rustc_errors::Diagnostic;
+use rustc_index::vec::IndexVec;
 use rustc_serialize::opaque;
 use rustc_span::def_id::{DefId, LocalDefId};
 
@@ -177,14 +178,16 @@ impl<'tcx> QueryCtxt<'tcx> {
         self,
         encoder: &mut on_disk_cache::CacheEncoder<'a, 'tcx, opaque::FileEncoder>,
         query_result_index: &mut on_disk_cache::EncodedQueryResultIndex,
+        remap: &IndexVec<DepNodeIndex, Option<SerializedDepNodeIndex>>,
     ) -> opaque::FileEncodeResult {
         macro_rules! encode_queries {
             ($($query:ident,)*) => {
                 $(
                     on_disk_cache::encode_query_results::<_, super::queries::$query<'_>>(
                         self,
                         encoder,
-                        query_result_index
+                        query_result_index,
+                        remap,
                     )?;
                 )*
             }
@@ -478,10 +481,10 @@ macro_rules! define_queries {
                         return
                     }
 
-                    debug_assert!(tcx.dep_graph
-                                     .node_color(dep_node)
-                                     .map(|c| c.is_green())
-                                     .unwrap_or(false));
+                    debug_assert_eq!(
+                        tcx.dep_graph.node_color(dep_node),
+                        Some(DepNodeColor::Green),
+                    );
 
                     let key = recover(*tcx, dep_node).unwrap_or_else(|| panic!("Failed to recover key for {:?} with hash {}", dep_node, dep_node.hash));
                     if queries::$name::cache_on_disk(tcx, &key, None) {
@@ -562,9 +565,10 @@ macro_rules! define_queries_struct {
                 tcx: TyCtxt<'tcx>,
                 encoder: &mut on_disk_cache::CacheEncoder<'a, 'tcx, opaque::FileEncoder>,
                 query_result_index: &mut on_disk_cache::EncodedQueryResultIndex,
+                remap: &IndexVec<DepNodeIndex, Option<SerializedDepNodeIndex>>,
             ) -> opaque::FileEncodeResult {
                 let tcx = QueryCtxt { tcx, queries: self };
-                tcx.encode_query_results(encoder, query_result_index)
+                tcx.encode_query_results(encoder, query_result_index, remap)
             }
 
             fn exec_cache_promotions(&'tcx self, tcx: TyCtxt<'tcx>) {