wip

Author: Zoxc

src/librustc/dep_graph/graph.rs

@@ -164,7 +164,7 @@ where
 pub struct DepGraphArgs {
     pub prev_graph: PreviousDepGraph,
     pub prev_work_products: FxHashMap<WorkProductId, WorkProduct>,
-    pub file: File,
+    pub file: Option<File>,
     pub state: IndexVec<DepNodeIndex, AtomicCell<DepNodeState>>,
     pub invalidated: Vec<DepNodeIndex>,
     pub model: Option<DepGraphModel>,
@@ -713,8 +713,18 @@ impl DepGraph {
                 DepNodeState::Invalid |
                 DepNodeState::UnknownEvalAlways |
                 DepNodeState::Unknown => {
-                    bug!("try_force_previous_green() - Forcing the DepNode \
+                    if !tcx.sess.has_errors() {
+                        bug!("try_force_previous_green() - Forcing the DepNode \
                             should have set its color")
+                    } else {
+                        // If the query we just forced has resulted
+                        // in some kind of compilation error, we
+                        // don't expect that the corresponding
+                        // dep-node color has been updated.
+                        // A query cycle which does not panic is one
+                        // such error.
+                        false
+                    }
                 }
             }
         } else {
@@ -1062,7 +1072,7 @@ pub(super) struct CurrentDepGraph {
 impl CurrentDepGraph {
     fn new(
         prev_graph: Lrc<PreviousDepGraph>,
-        file: File,
+        file: Option<File>,
         invalidated: Vec<DepNodeIndex>,
         model: Option<DepGraphModel>,
     ) -> CurrentDepGraph {

src/librustc/dep_graph/serialized.rs

@@ -352,7 +352,7 @@ enum Action {
 struct SerializerWorker {
     fingerprints: IndexVec<DepNodeIndex, Fingerprint>,
     previous: Lrc<PreviousDepGraph>,
-    file: File,
+    file: Option<File>,
     model: Option<DepGraphModel>,
 }
 
@@ -495,7 +495,9 @@ impl Worker for SerializerWorker {
             },
         };
         action.encode(&mut encoder).ok();
-        self.file.write_all(&encoder.into_inner()).expect("unable to write to temp dep graph");
+        self.file.as_mut().map(|file| {
+            file.write_all(&encoder.into_inner()).expect("unable to write to temp dep graph");
+        });
     }
 
     fn complete(self) -> CompletedDepGraph {
@@ -520,7 +522,7 @@ pub struct Serializer {
 
 impl Serializer {
     pub fn new(
-        file: File,
+        file: Option<File>,
         previous: Lrc<PreviousDepGraph>,
         invalidated: Vec<DepNodeIndex>,
         model: Option<DepGraphModel>,

src/librustc/ty/query/plumbing.rs

@@ -494,7 +494,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
         // If -Zincremental-verify-ich is specified, re-hash results from
         // the cache and make sure that they have the expected fingerprint.
         if unlikely!(self.sess.opts.debugging_opts.incremental_verify_ich) {
-            self.incremental_verify_ich::<Q>(&result, dep_node, dep_node_index);
+            self.incremental_verify_ich::<Q>(&result, dep_node);
         }
 
         if unlikely!(self.sess.opts.debugging_opts.query_dep_graph) {
@@ -508,28 +508,21 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
     #[cold]
     fn incremental_verify_ich<Q: QueryDescription<'gcx>>(
         self,
-        _result: &Q::Value,
-        _dep_node: &DepNode,
-        _dep_node_index: DepNodeIndex,
+        result: &Q::Value,
+        dep_node: &DepNode,
     ) {
-        panic!()/*
         use crate::ich::Fingerprint;
 
-        assert!(Some(self.dep_graph.fingerprint_of(dep_node_index)) ==
-                self.dep_graph.prev_fingerprint_of(dep_node),
-                "Fingerprint for green query instance not loaded \
-                    from cache: {:?}", dep_node);
-
         debug!("BEGIN verify_ich({:?})", dep_node);
         let mut hcx = self.create_stable_hashing_context();
 
         let new_hash = Q::hash_result(&mut hcx, result).unwrap_or(Fingerprint::ZERO);
         debug!("END verify_ich({:?})", dep_node);
 
-        let old_hash = self.dep_graph.fingerprint_of(dep_node_index);
+        let old_hash = self.dep_graph.prev_fingerprint_of(dep_node);
 
-        assert!(new_hash == old_hash, "Found unstable fingerprints \
-            for {:?}", dep_node);*/
+        assert!(Some(new_hash) == old_hash, "Found unstable fingerprints \
+            for {:?}", dep_node);
     }
 
     #[inline(always)]

src/librustc_incremental/persist/dirty_clean.rs

@@ -15,7 +15,7 @@
 
 use std::iter::FromIterator;
 use std::vec::Vec;
-use rustc::dep_graph::{DepNode, label_strs};
+use rustc::dep_graph::{CompletedDepGraph, ReconstructedDepGraph, DepNode, label_strs};
 use rustc::hir;
 use rustc::hir::{ItemKind as HirItem, ImplItemKind, TraitItemKind};
 use rustc::hir::Node as HirNode;
@@ -206,16 +206,21 @@ impl Assertion {
     }
 }
 
-pub fn check_dirty_clean_annotations<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
+pub fn check_dirty_clean_annotations<'a, 'tcx>(
+    tcx: TyCtxt<'a, 'tcx, 'tcx>,
+    dep_graph: &CompletedDepGraph,
+) {
     // can't add `#[rustc_dirty]` etc without opting in to this feature
     if !tcx.features().rustc_attrs {
         return;
     }
 
     tcx.dep_graph.with_ignore(|| {
+        let graph = ReconstructedDepGraph::new(dep_graph);
         let krate = tcx.hir().krate();
         let mut dirty_clean_visitor = DirtyCleanVisitor {
             tcx,
+            graph,
             checked_attrs: Default::default(),
         };
         krate.visit_all_item_likes(&mut dirty_clean_visitor);
@@ -236,6 +241,7 @@ pub fn check_dirty_clean_annotations<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
 
 struct DirtyCleanVisitor<'a, 'tcx:'a> {
     tcx: TyCtxt<'a, 'tcx, 'tcx>,
+    graph: ReconstructedDepGraph,
     checked_attrs: FxHashSet<ast::AttrId>,
 }
 
@@ -460,7 +466,7 @@ impl<'a, 'tcx> DirtyCleanVisitor<'a, 'tcx> {
             })
     }
 
-    fn _dep_node_str(&self, dep_node: &DepNode) -> String {
+    fn dep_node_str(&self, dep_node: &DepNode) -> String {
         if let Some(def_id) = dep_node.extract_def_id(self.tcx) {
             format!("{:?}({})",
                     dep_node.kind,
@@ -470,34 +476,32 @@ impl<'a, 'tcx> DirtyCleanVisitor<'a, 'tcx> {
         }
     }
 
-    fn assert_dirty(&self, _item_span: Span, dep_node: DepNode) {
+    fn assert_dirty(&self, item_span: Span, dep_node: DepNode) {
         debug!("assert_dirty({:?})", dep_node);
-        panic!()
-        /*let dep_node_index = self.tcx.dep_graph.dep_node_index_of(&dep_node);
-        let current_fingerprint = self.tcx.dep_graph.fingerprint_of(dep_node_index);
+        let dep_node_index = self.graph.dep_node_index_of(&dep_node);
+        let current_fingerprint = self.graph.fingerprint_of(dep_node_index);
         let prev_fingerprint = self.tcx.dep_graph.prev_fingerprint_of(&dep_node);
 
         if Some(current_fingerprint) == prev_fingerprint {
             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 assert_clean(&self, _item_span: Span, dep_node: DepNode) {
+    fn assert_clean(&self, item_span: Span, dep_node: DepNode) {
         debug!("assert_clean({:?})", dep_node);
-        panic!()
-        /*let dep_node_index = self.tcx.dep_graph.dep_node_index_of(&dep_node);
-        let current_fingerprint = self.tcx.dep_graph.fingerprint_of(dep_node_index);
+        let dep_node_index = self.graph.dep_node_index_of(&dep_node);
+        let current_fingerprint = self.graph.fingerprint_of(dep_node_index);
         let prev_fingerprint = self.tcx.dep_graph.prev_fingerprint_of(&dep_node);
 
         if Some(current_fingerprint) != prev_fingerprint {
             let dep_node_str = self.dep_node_str(&dep_node);
             self.tcx.sess.span_err(
                 item_span,
                 &format!("`{}` should be clean but is not", dep_node_str));
-        }*/
+        }
     }
 
     fn check_item(&mut self, item_id: hir::HirId, item_span: Span) {

src/librustc_incremental/persist/load.rs

@@ -45,7 +45,7 @@ pub fn dep_graph_from_future(sess: &Session, future: DepGraphFuture) -> DepGraph
             DepGraphArgs {
                 prev_graph: Default::default(),
                 prev_work_products: Default::default(),
-                file,
+                file: Some(file),
                 state: Default::default(),
                 invalidated: Vec::new(),
                 model: if use_model {
@@ -169,6 +169,28 @@ pub fn load_dep_graph(sess: &Session) -> DepGraphFuture {
 
     let time_passes = sess.time_passes();
 
+    let use_model = sess.reconstruct_dep_graph() || cfg!(debug_assertions);
+
+    if sess.opts.incremental.is_none() {
+        let args = DepGraphArgs {
+            prev_graph: Default::default(),
+            prev_work_products: Default::default(),
+            file: None,
+            state: Default::default(),
+            invalidated: Vec::new(),
+            model: if use_model {
+                Some(Default::default())
+            } else {
+                None
+            },
+        };
+
+        // No incremental compilation.
+        return MaybeAsync::Sync(LoadResult::Ok {
+            data: args,
+        });
+    }
+
     // Calling `sess.incr_comp_session_dir()` will panic if `sess.opts.incremental.is_none()`.
     // Fortunately, we just checked that this isn't the case.
     let dir = &sess.incr_comp_session_dir();
@@ -187,7 +209,6 @@ pub fn load_dep_graph(sess: &Session) -> DepGraphFuture {
 
     let report_incremental_info = sess.opts.debugging_opts.incremental_info;
     let expected_hash = sess.opts.dep_tracking_hash();
-    let use_model = sess.reconstruct_dep_graph() || cfg!(debug_assertions);
 
     let mut prev_work_products = FxHashMap::default();
 
@@ -285,7 +306,7 @@ pub fn load_dep_graph(sess: &Session) -> DepGraphFuture {
                 data: DepGraphArgs {
                     prev_graph: result.prev_graph,
                     prev_work_products,
-                    file,
+                    file: Some(file),
                     state: result.state,
                     invalidated: result.invalidated,
                     model: result.model,

src/librustc_incremental/persist/save.rs

@@ -21,7 +21,20 @@ pub fn save_dep_graph<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
     debug!("save_dep_graph()");
     tcx.dep_graph.with_ignore(|| {
         let sess = tcx.sess;
+
         if sess.opts.incremental.is_none() {
+            if !tcx.sess.opts.build_dep_graph() {
+                return;
+            }
+
+            let results = time(tcx.sess, "finish dep graph", || {
+                tcx.dep_graph.complete()
+            });
+
+            time(tcx.sess,
+                "assert dep graph",
+                || assert_dep_graph(tcx, &results));
+
             return;
         }
 
@@ -42,8 +55,6 @@ pub fn save_dep_graph<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) {
                 finish_dep_graph(tcx, &results_path)
             });
         });
-
-        dirty_clean::check_dirty_clean_annotations(tcx);
     })
 }
 
@@ -142,6 +153,9 @@ fn finish_dep_graph<'tcx>(tcx: TyCtxt<'_, 'tcx, 'tcx>, results_path: &Path) {
          "assert dep graph",
          || assert_dep_graph(tcx, &results));
 
+
+    dirty_clean::check_dirty_clean_annotations(tcx, &results);
+
     if tcx.sess.opts.debugging_opts.incremental_info {
         let data = &results.model.as_ref().unwrap().data;