Define DepKind in rustc_query_system.

Author: cjgillot

compiler/rustc_incremental/src/assert_dep_graph.rs

@@ -41,7 +41,7 @@ use rustc_hir as hir;
 use rustc_hir::def_id::DefId;
 use rustc_hir::intravisit::{self, Visitor};
 use rustc_middle::dep_graph::{
- DepGraphQuery, DepKind, DepNode, DepNodeExt, DepNodeFilter, EdgeFilter,
+ dep_kind, DepGraphQuery, DepNode, DepNodeExt, DepNodeFilter, EdgeFilter,
 };
 use rustc_middle::hir::nested_filter;
 use rustc_middle::ty::TyCtxt;
@@ -128,7 +128,7 @@ impl<'tcx> IfThisChanged<'tcx> {
  let dep_node_interned = self.argument(attr);
  let dep_node = match dep_node_interned {
  None => {
- DepNode::from_def_path_hash(self.tcx, def_path_hash, DepKind::hir_owner)
+ DepNode::from_def_path_hash(self.tcx, def_path_hash, dep_kind::hir_owner)
  }
  Some(n) => {
  match DepNode::from_label_string(self.tcx, n.as_str(), def_path_hash) {

compiler/rustc_interface/src/callbacks.rs

@@ -9,7 +9,9 @@
 //! The functions in this file should fall back to the default set in their
 //! origin crate when the `TyCtxt` is not present in TLS.
 
+use rustc_middle::dep_graph::DepNodeExt;
 use rustc_middle::ty::tls;
+use rustc_query_system::dep_graph::{DepKind, DepNode};
 use std::fmt;
 
 fn track_span_parent(def_id: rustc_span::def_id::LocalDefId) {
@@ -35,10 +37,42 @@ fn def_id_debug(def_id: rustc_hir::def_id::DefId, f: &mut fmt::Formatter<'_>) ->
  write!(f, ")")
 }
 
+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.query_name(*kind))
+ } else {
+ write!(f, "DepKind({:?})", kind.index())
+ }
+ })
+}
+
+fn dep_node_debug(node: &DepNode, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ tls::with_opt(|opt_tcx| {
+ if let Some(tcx) = opt_tcx {
+ write!(f, "{}(", tcx.query_name(node.kind))?;
+
+ 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)?;
+ }
+
+ write!(f, ")")
+ } else {
+ write!(f, "DepKind({:?})({})", node.kind.index(), node.hash)
+ }
+ })
+}
+
 /// Sets up the callbacks in prior crates which we want to refer to the
 /// TyCtxt in.
 pub fn setup_callbacks() {
  rustc_span::SPAN_TRACK.swap(&(track_span_parent as fn(_)));
  rustc_hir::def_id::DEF_ID_DEBUG.swap(&(def_id_debug as fn(_, &mut fmt::Formatter<'_>) -> _));
+ rustc_query_system::dep_graph::KIND_DEBUG.swap(&(dep_kind_debug as _));
+ rustc_query_system::dep_graph::NODE_DEBUG.swap(&(dep_node_debug as _));
  rustc_errors::TRACK_DIAGNOSTICS.swap(&(rustc_query_system::tls::track_diagnostic as fn(&_)));
 }

compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs

@@ -50,8 +50,8 @@ macro_rules! provide_one {
  // External query providers call `crate_hash` in order to register a dependency
  // on the crate metadata. The exception is `crate_hash` itself, which obviously
  // doesn't need to do this (and can't, as it would cause a query cycle).
- use rustc_middle::dep_graph::DepKind;
- if DepKind::$name != DepKind::crate_hash && $tcx.dep_graph.is_fully_enabled() {
+ use rustc_middle::dep_graph::dep_kind;
+ if dep_kind::$name != dep_kind::crate_hash && $tcx.dep_graph.is_fully_enabled() {
  $tcx.ensure().crate_hash($def_id.krate);
  }
 

compiler/rustc_middle/src/dep_graph/dep_node.rs

@@ -63,11 +63,8 @@ use rustc_data_structures::fingerprint::Fingerprint;
 use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, CRATE_DEF_INDEX};
 use rustc_hir::definitions::DefPathHash;
 use rustc_hir::HirId;
-use rustc_query_system::dep_graph::FingerprintStyle;
+use rustc_query_system::dep_graph::{DepKind, DepNode, DepNodeParams, FingerprintStyle};
 use rustc_span::symbol::Symbol;
-use std::hash::Hash;
-
-pub use rustc_query_system::dep_graph::{DepContext, DepNodeParams};
 
 /// This struct stores metadata about each DepKind.
 ///
@@ -89,6 +86,9 @@ pub struct DepKindStruct {
  /// See [DepNodeParams] trait for the behaviour of each key type.
  pub fingerprint_style: FingerprintStyle,
 
+ /// Name of the query for pretty-printing.
+ pub label: &'static str,
+
  /// The red/green evaluation system will try to mark a specific DepNode in the
  /// dependency graph as green by recursively trying to mark the dependencies of
  /// that `DepNode` as green. While doing so, it will sometimes encounter a `DepNode`
@@ -130,16 +130,21 @@ pub struct DepKindStruct {
  pub try_load_from_on_disk_cache: Option<fn(TyCtxt<'_>, DepNode)>,
 }
 
-impl DepKind {
+impl TyCtxt<'_> {
  #[inline(always)]
- pub fn fingerprint_style(self, tcx: TyCtxt<'_>) -> FingerprintStyle {
+ crate fn query_fingerprint_style(self, dep_kind: DepKind) -> FingerprintStyle {
  // Only fetch the DepKindStruct once.
- let data = tcx.query_kind(self);
+ let data = self.query_kind(dep_kind);
  if data.is_anon {
  return FingerprintStyle::Opaque;
  }
  data.fingerprint_style
  }
+
+ #[inline(always)]
+ pub fn query_name(self, dep_kind: DepKind) -> &'static str {
+ self.query_kind(dep_kind).label
+ }
 }
 
 macro_rules! define_dep_nodes {
@@ -151,38 +156,40 @@ macro_rules! define_dep_nodes {
  ) => (
  #[macro_export]
  macro_rules! make_dep_kind_array {
- ($mod:ident) => {[ $($mod::$variant()),* ]};
+ ($mod:ident) => {[ $mod::NULL(), $($mod::$variant()),* ]};
  }
 
- /// This enum serves as an index into arrays built by `make_dep_kind_array`.
- #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Encodable, Decodable)]
- #[allow(non_camel_case_types)]
- pub enum DepKind {
- $($variant),*
+ /// Definition of the `DepKind`s for the known queries.
+ /// The constants are indices in the arrays produced by `make_dep_kind_array`,
+ /// and should be kept in sync.
+ #[allow(non_upper_case_globals)]
+ pub mod dep_kind {
+ use super::DepKind;
+
+ /// We use this for most things when incr. comp. is turned off.
+ pub const NULL: DepKind = DepKind::NULL;
+ $(pub const $variant: DepKind = DepKind::new(1 + ${index()});)*
  }
 
  fn dep_kind_from_label_string(label: &str) -> Result<DepKind, ()> {
  match label {
- $(stringify!($variant) => Ok(DepKind::$variant),)*
+ "NULL" => Ok(dep_kind::NULL),
+ $(stringify!($variant) => Ok(dep_kind::$variant),)*
  _ => Err(()),
  }
  }
 
  /// Contains variant => str representations for constructing
  /// DepNode groups for tests.
- #[allow(dead_code, non_upper_case_globals)]
+ #[allow(non_upper_case_globals)]
  pub mod label_strs {
- $(
- pub const $variant: &str = stringify!($variant);
- )*
+ pub const NULL: &str = "NULL";
+ $(pub const $variant: &str = stringify!($variant);)*
  }
  );
 }
 
 rustc_dep_node_append!([define_dep_nodes!][ <'tcx>
- // We use this for most things when incr. comp. is turned off.
- [] Null,
-
  [anon] TraitSelect,
 
  // WARNING: if `Symbol` is changed, make sure you update `make_compile_codegen_unit` below.
@@ -196,28 +203,15 @@ rustc_dep_node_append!([define_dep_nodes!][ <'tcx>
 // WARNING: `construct` is generic and does not know that `CompileCodegenUnit` takes `Symbol`s as keys.
 // Be very careful changing this type signature!
 crate fn make_compile_codegen_unit(tcx: TyCtxt<'_>, name: Symbol) -> DepNode {
- DepNode::construct(tcx, DepKind::CompileCodegenUnit, &name)
+ DepNode::construct(tcx, dep_kind::CompileCodegenUnit, &name)
 }
 
 // WARNING: `construct` is generic and does not know that `CompileMonoItem` takes `MonoItem`s as keys.
 // Be very careful changing this type signature!
 crate fn make_compile_mono_item<'tcx>(tcx: TyCtxt<'tcx>, mono_item: &MonoItem<'tcx>) -> DepNode {
- DepNode::construct(tcx, DepKind::CompileMonoItem, mono_item)
+ DepNode::construct(tcx, dep_kind::CompileMonoItem, mono_item)
 }
 
-pub type DepNode = rustc_query_system::dep_graph::DepNode<DepKind>;
-
-// We keep a lot of `DepNode`s in memory during compilation. It's not
-// required that their size stay the same, but we don't want to change
-// it inadvertently. This assert just ensures we're aware of any change.
-#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
-static_assert_size!(DepNode, 18);
-
-#[cfg(not(any(target_arch = "x86", target_arch = "x86_64")))]
-static_assert_size!(DepNode, 24);
-
-static_assert_size!(DepKind, 2);
-
 pub trait DepNodeExt: Sized {
  /// Construct a DepNode from the given DepKind and DefPathHash. This
  /// method will assert that the given DepKind actually requires a
@@ -252,7 +246,7 @@ impl DepNodeExt for DepNode {
  /// method will assert that the given DepKind actually requires a
  /// single DefId/DefPathHash parameter.
  fn from_def_path_hash(tcx: TyCtxt<'_>, def_path_hash: DefPathHash, kind: DepKind) -> DepNode {
- debug_assert!(kind.fingerprint_style(tcx) == FingerprintStyle::DefPathHash);
+ debug_assert!(tcx.query_fingerprint_style(kind) == FingerprintStyle::DefPathHash);
  DepNode { kind, hash: def_path_hash.0.into() }
  }
 
@@ -267,7 +261,7 @@ impl DepNodeExt for DepNode {
  /// refers to something from the previous compilation session that
  /// has been removed.
  fn extract_def_id<'tcx>(&self, tcx: TyCtxt<'tcx>) -> Option<DefId> {
- if self.kind.fingerprint_style(tcx) == FingerprintStyle::DefPathHash {
+ if tcx.query_fingerprint_style(self.kind) == FingerprintStyle::DefPathHash {
  Some(tcx.def_path_hash_to_def_id(DefPathHash(self.hash.into()), &mut || {
  panic!("Failed to extract DefId: {:?} {}", self.kind, self.hash)
  }))
@@ -284,7 +278,7 @@ impl DepNodeExt for DepNode {
  ) -> Result<DepNode, ()> {
  let kind = dep_kind_from_label_string(label)?;
 
- match kind.fingerprint_style(tcx) {
+ match tcx.query_fingerprint_style(kind) {
  FingerprintStyle::Opaque => Err(()),
  FingerprintStyle::Unit => Ok(DepNode::new_no_params(tcx, kind)),
  FingerprintStyle::DefPathHash => {

compiler/rustc_middle/src/dep_graph/mod.rs

@@ -1,4 +1,4 @@
-use crate::ty::{self, TyCtxt};
+use crate::ty::TyCtxt;
 use rustc_data_structures::profiling::SelfProfilerRef;
 use rustc_query_system::ich::StableHashingContext;
 use rustc_session::Session;
@@ -7,48 +7,15 @@ use rustc_session::Session;
 mod dep_node;
 
 pub use rustc_query_system::dep_graph::{
- debug::DepNodeFilter, hash_result, DepContext, DepNodeColor, DepNodeIndex,
- SerializedDepNodeIndex, WorkProduct, WorkProductId,
+ debug::DepNodeFilter, debug::EdgeFilter, hash_result, DepContext, DepGraph, DepGraphQuery,
+ DepKind, DepNode, DepNodeColor, DepNodeIndex, SerializedDepGraph, SerializedDepNodeIndex,
+ TaskDeps, WorkProduct, WorkProductId,
 };
 
-pub use dep_node::{label_strs, DepKind, DepKindStruct, DepNode, DepNodeExt};
+pub use dep_node::{dep_kind, label_strs, DepKindStruct, DepNodeExt};
 crate use dep_node::{make_compile_codegen_unit, make_compile_mono_item};
 
-pub type DepGraph = rustc_query_system::dep_graph::DepGraph<DepKind>;
-pub type TaskDeps = rustc_query_system::dep_graph::TaskDeps<DepKind>;
-pub type TaskDepsRef<'a> = rustc_query_system::dep_graph::TaskDepsRef<'a, DepKind>;
-pub type DepGraphQuery = rustc_query_system::dep_graph::DepGraphQuery<DepKind>;
-pub type SerializedDepGraph = rustc_query_system::dep_graph::SerializedDepGraph<DepKind>;
-pub type EdgeFilter = rustc_query_system::dep_graph::debug::EdgeFilter<DepKind>;
-
-impl rustc_query_system::dep_graph::DepKind for DepKind {
- const NULL: Self = DepKind::Null;
-
- fn debug_node(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, ")")
- }
-}
-
 impl<'tcx> DepContext for TyCtxt<'tcx> {
- type DepKind = DepKind;
-
  #[inline]
  fn create_stable_hashing_context(&self) -> StableHashingContext<'_> {
  TyCtxt::create_stable_hashing_context(*self)
@@ -71,7 +38,7 @@ impl<'tcx> DepContext for TyCtxt<'tcx> {
 
  #[inline(always)]
  fn fingerprint_style(&self, kind: DepKind) -> rustc_query_system::dep_graph::FingerprintStyle {
- kind.fingerprint_style(*self)
+ self.query_fingerprint_style(kind)
  }
 
  #[inline(always)]
@@ -96,8 +63,8 @@ impl<'tcx> DepContext for TyCtxt<'tcx> {
  // hit the cache instead of having to go through `force_from_dep_node`.
  // This assertion makes sure, we actually keep applying the solution above.
  debug_assert!(
- dep_node.kind != DepKind::codegen_unit,
- "calling force_from_dep_node() on DepKind::codegen_unit"
+ dep_node.kind != dep_kind::codegen_unit,
+ "calling force_from_dep_node() on dep_kind::codegen_unit"
  );
 
  let cb = self.query_kind(dep_node.kind);

compiler/rustc_middle/src/lib.rs

@@ -43,6 +43,7 @@
 #![feature(once_cell)]
 #![feature(let_chains)]
 #![feature(let_else)]
+#![feature(macro_metavar_expr)]
 #![feature(min_specialization)]
 #![feature(trusted_len)]
 #![feature(type_alias_impl_trait)]

compiler/rustc_middle/src/ty/context.rs

@@ -1176,7 +1176,7 @@ impl<'tcx> TyCtxt<'tcx> {
  }
 
  crate fn query_kind(self, k: DepKind) -> &'tcx DepKindStruct {
- &self.query_kinds[k as usize]
+ &self.query_kinds[k.index() as usize]
  }
 
  /// Constructs a `TyKind::Error` type and registers a `delay_span_bug` to ensure it gets used.

compiler/rustc_query_impl/src/lib.rs

@@ -17,7 +17,7 @@ extern crate rustc_middle;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
 use rustc_data_structures::sync::AtomicU64;
 use rustc_middle::arena::Arena;
-use rustc_middle::dep_graph::{self, DepKindStruct, SerializedDepNodeIndex};
+use rustc_middle::dep_graph::{self, label_strs, DepKindStruct, SerializedDepNodeIndex};
 use rustc_middle::ty::query::{query_keys, query_storage, query_stored, query_values};
 use rustc_middle::ty::query::{ExternProviders, Providers, QueryEngine};
 use rustc_middle::ty::{self, TyCtxt};