Address review.

Author: cjgillot

src/librustc/dep_graph/mod.rs

@@ -91,22 +91,22 @@ impl<'tcx> DepContext for TyCtxt<'tcx> {
         TyCtxt::create_stable_hashing_context(*self)
     }
 
-    fn try_force_previous_green(&self, dep_dep_node: &DepNode) -> bool {
+    fn try_force_from_dep_node(&self, dep_node: &DepNode) -> bool {
         // FIXME: This match is just a workaround for incremental bugs and should
         // be removed. https://github.com/rust-lang/rust/issues/62649 is one such
         // bug that must be fixed before removing this.
-        match dep_dep_node.kind {
+        match dep_node.kind {
             DepKind::hir_owner | DepKind::hir_owner_nodes | DepKind::CrateMetadata => {
-                if let Some(def_id) = dep_dep_node.extract_def_id(*self) {
+                if let Some(def_id) = dep_node.extract_def_id(*self) {
                     if def_id_corresponds_to_hir_dep_node(*self, def_id) {
-                        if dep_dep_node.kind == DepKind::CrateMetadata {
+                        if dep_node.kind == DepKind::CrateMetadata {
                             // The `DefPath` has corresponding node,
                             // and that node should have been marked
                             // either red or green in `data.colors`.
                             bug!(
                                 "DepNode {:?} should have been \
                              pre-marked as red or green but wasn't.",
-                                dep_dep_node
+                                dep_node
                             );
                         }
                     } else {
@@ -134,8 +134,8 @@ impl<'tcx> DepContext for TyCtxt<'tcx> {
             }
         }
 
-        debug!("try_force_previous_green({:?}) --- trying to force", dep_dep_node);
-        ty::query::force_from_dep_node(*self, dep_dep_node)
+        debug!("try_force_from_dep_node({:?}) --- trying to force", dep_node);
+        ty::query::force_from_dep_node(*self, dep_node)
     }
 
     fn has_errors_or_delayed_span_bugs(&self) -> bool {
@@ -148,10 +148,8 @@ impl<'tcx> DepContext for TyCtxt<'tcx> {
 
     // Interactions with on_disk_cache
     fn try_load_from_on_disk_cache(&self, dep_node: &DepNode) {
-        use crate::mir::interpret::GlobalId;
-        use crate::ty::query::queries;
-        use crate::ty::query::QueryDescription;
-        rustc_dep_node_try_load_from_on_disk_cache!(dep_node, *self)
+        use crate::ty::query::try_load_from_on_disk_cache;
+        try_load_from_on_disk_cache(*self, dep_node)
     }
 
     fn load_diagnostics(&self, prev_dep_node_index: SerializedDepNodeIndex) -> Vec<Diagnostic> {

src/librustc/ty/query/mod.rs

@@ -191,3 +191,9 @@ pub fn force_from_dep_node<'tcx>(tcx: TyCtxt<'tcx>, dep_node: &DepNode) -> bool
 
     false
 }
+
+pub(crate) fn try_load_from_on_disk_cache<'tcx>(tcx: TyCtxt<'tcx>, dep_node: &DepNode) {
+    use crate::dep_graph::DepKind;
+
+    rustc_dep_node_try_load_from_on_disk_cache!(dep_node, tcx)
+}

src/librustc_query_system/dep_graph/graph.rs

@@ -13,8 +13,8 @@ use smallvec::{smallvec, SmallVec};
 use std::collections::hash_map::Entry;
 use std::env;
 use std::hash::Hash;
+use std::marker::PhantomData;
 use std::mem;
-use std::panic as bug;
 use std::sync::atomic::Ordering::Relaxed;
 
 use super::debug::EdgeFilter;
@@ -215,7 +215,7 @@ impl<K: DepKind> DepGraph<K> {
                     node: Some(_key),
                     reads: SmallVec::new(),
                     read_set: Default::default(),
-                    phantom_data: std::marker::PhantomData,
+                    phantom_data: PhantomData,
                 })
             },
             |data, key, fingerprint, task| data.complete_task(key, task.unwrap(), fingerprint),
@@ -367,7 +367,7 @@ impl<K: DepKind> DepGraph<K> {
                 std::mem::drop(map);
                 data.read_index(dep_node_index);
             } else {
-                bug!("DepKind {:?} should be pre-allocated but isn't.", v.kind)
+                panic!("DepKind {:?} should be pre-allocated but isn't.", v.kind)
             }
         }
     }
@@ -645,7 +645,7 @@ impl<K: DepKind> DepGraph<K> {
                             dependency {:?}",
                         dep_node, dep_dep_node
                     );
-                    if tcx.try_force_previous_green(dep_dep_node) {
+                    if tcx.try_force_from_dep_node(dep_dep_node) {
                         let dep_dep_node_color = data.colors.get(dep_dep_node_index);
 
                         match dep_dep_node_color {
@@ -667,7 +667,7 @@ impl<K: DepKind> DepGraph<K> {
                             }
                             None => {
                                 if !tcx.has_errors_or_delayed_span_bugs() {
-                                    bug!(
+                                    panic!(
                                         "try_mark_previous_green() - Forcing the DepNode \
                                           should have set its color"
                                     )
@@ -948,7 +948,7 @@ impl<K: DepKind> CurrentDepGraph<K> {
             match env::var("RUST_FORBID_DEP_GRAPH_EDGE") {
                 Ok(s) => match EdgeFilter::new(&s) {
                     Ok(f) => Some(f),
-                    Err(err) => bug!("RUST_FORBID_DEP_GRAPH_EDGE invalid: {}", err),
+                    Err(err) => panic!("RUST_FORBID_DEP_GRAPH_EDGE invalid: {}", err),
                 },
                 Err(_) => None,
             }
@@ -1074,7 +1074,7 @@ impl<K: DepKind> DepGraphData<K> {
                             if let Some(ref forbidden_edge) = self.current.forbidden_edge {
                                 let source = data[source].node;
                                 if forbidden_edge.test(&source, &target) {
-                                    bug!("forbidden edge {:?} -> {:?} created", source, target)
+                                    panic!("forbidden edge {:?} -> {:?} created", source, target)
                                 }
                             }
                         }
@@ -1096,7 +1096,7 @@ pub struct TaskDeps<K> {
     node: Option<DepNode<K>>,
     reads: EdgesVec,
     read_set: FxHashSet<DepNodeIndex>,
-    phantom_data: std::marker::PhantomData<DepNode<K>>,
+    phantom_data: PhantomData<DepNode<K>>,
 }
 
 impl<K> Default for TaskDeps<K> {
@@ -1106,7 +1106,7 @@ impl<K> Default for TaskDeps<K> {
             node: None,
             reads: EdgesVec::new(),
             read_set: FxHashSet::default(),
-            phantom_data: std::marker::PhantomData,
+            phantom_data: PhantomData,
         }
     }
 }

src/librustc_query_system/dep_graph/mod.rs

@@ -31,7 +31,7 @@ pub trait DepContext: Copy {
     fn create_stable_hashing_context(&self) -> Self::StableHashingContext;
 
     /// Try to force a dep node to execute and see if it's green.
-    fn try_force_previous_green(&self, node: &DepNode<Self::DepKind>) -> bool;
+    fn try_force_from_dep_node(&self, dep_node: &DepNode<Self::DepKind>) -> bool;
 
     /// Return whether the current session is tainted by errors.
     fn has_errors_or_delayed_span_bugs(&self) -> bool;