Some tweaks and addressing of comments

Author: Zoxc

compiler/rustc_interface/src/callbacks.rs

@@ -10,8 +10,10 @@
 //! origin crate when the `TyCtxt` is not present in TLS.
 
 use rustc_errors::{Diagnostic, TRACK_DIAGNOSTICS};
-use rustc_middle::dep_graph::{dep_kind_debug, dep_node_debug, TaskDepsRef};
+use rustc_middle::dep_graph::{DepNodeExt, TaskDepsRef};
 use rustc_middle::ty::tls;
+use rustc_query_system::dep_graph::dep_node::default_dep_kind_debug;
+use rustc_query_system::dep_graph::{DepContext, DepKind, DepNode};
 use std::fmt;
 
 fn track_span_parent(def_id: rustc_span::def_id::LocalDefId) {
@@ -59,6 +61,41 @@ fn def_id_debug(def_id: rustc_hir::def_id::DefId, f: &mut fmt::Formatter<'_>) ->
     write!(f, ")")
 }
 
+/// This is a callback from `rustc_query_system` as it cannot access the implicit state
+/// in `rustc_middle` otherwise.
+pub fn dep_kind_debug(kind: DepKind, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    tls::with_opt(|opt_tcx| {
+        if let Some(tcx) = opt_tcx {
+            write!(f, "{}", tcx.dep_kind_info(kind).name)
+        } else {
+            default_dep_kind_debug(kind, f)
+        }
+    })
+}
+
+/// This is a callback from `rustc_query_system` as it cannot access the implicit state
+/// in `rustc_middle` otherwise.
+pub fn dep_node_debug(node: DepNode, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    write!(f, "{:?}(", node.kind)?;
+
+    tls::with_opt(|opt_tcx| {
+        if let Some(tcx) = opt_tcx {
+            if let Some(def_id) = node.extract_def_id(tcx) {
+                write!(f, "{}", tcx.def_path_debug_str(def_id))?;
+            } else if let Some(ref s) = tcx.dep_graph.dep_node_debug_str(node) {
+                write!(f, "{s}")?;
+            } else {
+                write!(f, "{}", node.hash)?;
+            }
+        } else {
+            write!(f, "{}", node.hash)?;
+        }
+        Ok(())
+    })?;
+
+    write!(f, ")")
+}
+
 /// Sets up the callbacks in prior crates which we want to refer to the
 /// TyCtxt in.
 pub fn setup_callbacks() {

compiler/rustc_middle/src/dep_graph/dep_node.rs

@@ -65,7 +65,6 @@ use rustc_hir::definitions::DefPathHash;
 use rustc_hir::{HirId, ItemLocalId, OwnerId};
 use rustc_query_system::dep_graph::FingerprintStyle;
 use rustc_span::symbol::Symbol;
-use std::hash::Hash;
 
 pub use rustc_query_system::dep_graph::dep_node::DepKind;
 pub use rustc_query_system::dep_graph::{DepContext, DepNode, DepNodeParams};
@@ -85,9 +84,8 @@ macro_rules! define_dep_nodes {
         // encoding. The derived Encodable/Decodable uses leb128 encoding which is
         // dense when only considering this enum. But DepKind is encoded in a larger
         // struct, and there we can take advantage of the unused bits in the u16.
-        #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
         #[allow(non_camel_case_types)]
-        #[repr(u16)]
+        #[repr(u16)] // Must be kept in sync with the inner type of `DepKind`.
         enum DepKindDefs {
             $( $( #[$attr] )* $variant),*
         }
@@ -97,14 +95,15 @@ macro_rules! define_dep_nodes {
             use super::*;
 
             $(
+                // The `as u16` cast must be kept in sync with the inner type of `DepKind`.
                 pub const $variant: DepKind = DepKind::new(DepKindDefs::$variant as u16);
             )*
         }
 
         // This checks that the discriminants of the variants have been assigned consecutively
         // from 0 so that they can be used as a dense index.
         pub const DEP_KIND_VARIANTS: u16 = {
-            let deps: &[DepKind] = &[$(dep_kinds::$variant,)*];
+            let deps = &[$(dep_kinds::$variant,)*];
             let mut i = 0;
             while i < deps.len() {
                 if i != deps[i].as_usize() {
@@ -143,8 +142,6 @@ rustc_query_append!(define_dep_nodes![
     [] fn CompileMonoItem() -> (),
 ]);
 
-static_assert_size!(DepKind, 2);
-
 // WARNING: `construct` is generic and does not know that `CompileCodegenUnit` takes `Symbol`s as keys.
 // Be very careful changing this type signature!
 pub(crate) fn make_compile_codegen_unit(tcx: TyCtxt<'_>, name: Symbol) -> DepNode {

compiler/rustc_middle/src/dep_graph/mod.rs

@@ -7,7 +7,6 @@ use rustc_session::Session;
 mod dep_node;
 
 pub use rustc_query_system::dep_graph::debug::EdgeFilter;
-use rustc_query_system::dep_graph::dep_node::default_dep_kind_debug;
 pub use rustc_query_system::dep_graph::{
     debug::DepNodeFilter, hash_result, DepContext, DepGraphQuery, DepNodeColor, DepNodeIndex, Deps,
     SerializedDepGraph, SerializedDepNodeIndex, TaskDeps, TaskDepsRef, WorkProduct, WorkProductId,
@@ -79,34 +78,3 @@ impl<'tcx> DepContext for TyCtxt<'tcx> {
         &self.query_kinds[dk.as_usize()]
     }
 }
-
-pub fn dep_kind_debug(kind: DepKind, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-    ty::tls::with_opt(|opt_tcx| {
-        if let Some(tcx) = opt_tcx {
-            write!(f, "{}", tcx.dep_kind_info(kind).name)
-        } else {
-            default_dep_kind_debug(kind, f)
-        }
-    })
-}
-
-pub fn dep_node_debug(node: DepNode, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-    write!(f, "{:?}(", node.kind)?;
-
-    ty::tls::with_opt(|opt_tcx| {
-        if let Some(tcx) = opt_tcx {
-            if let Some(def_id) = node.extract_def_id(tcx) {
-                write!(f, "{}", tcx.def_path_debug_str(def_id))?;
-            } else if let Some(ref s) = tcx.dep_graph.dep_node_debug_str(node) {
-                write!(f, "{s}")?;
-            } else {
-                write!(f, "{}", node.hash)?;
-            }
-        } else {
-            write!(f, "{}", node.hash)?;
-        }
-        Ok(())
-    })?;
-
-    write!(f, ")")
-}

compiler/rustc_query_system/src/dep_graph/dep_node.rs

@@ -53,7 +53,7 @@ use std::fmt;
 use std::hash::Hash;
 
 /// This serves as an index into arrays built by `make_dep_kind_array`.
-#[derive(Clone, Copy, PartialEq, Eq, Ord, PartialOrd, Hash, Encodable, Decodable)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
 pub struct DepKind {
     variant: u16,
 }
@@ -75,6 +75,8 @@ impl DepKind {
     }
 }
 
+static_assert_size!(DepKind, 2);
+
 pub fn default_dep_kind_debug(kind: DepKind, f: &mut fmt::Formatter<'_>) -> fmt::Result {
     f.debug_struct("DepKind").field("variant", &kind.variant).finish()
 }
@@ -88,7 +90,7 @@ impl fmt::Debug for DepKind {
     }
 }
 
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Encodable, Decodable)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
 pub struct DepNode {
     pub kind: DepKind,
     pub hash: PackedFingerprint,

compiler/rustc_query_system/src/dep_graph/mod.rs

@@ -94,8 +94,14 @@ pub trait Deps {
     where
         OP: for<'a> FnOnce(TaskDepsRef<'a>);
 
+    /// We use this for most things when incr. comp. is turned off.
     const DEP_KIND_NULL: DepKind;
+
+    /// We use this to create a forever-red node.
     const DEP_KIND_RED: DepKind;
+
+    /// This is the highest value a `DepKind` can have. It's used during encoding to
+    /// pack information into the unused bits.
     const DEP_KIND_MAX: u16;
 }