Rollup merge of #152033 - Zalathar:dep-node-key, r=nnethercote

Rename trait `DepNodeParams` to `DepNodeKey`

In query system plumbing, we usually refer to a query's explicit argument value as a “key”.

The first few commits do some preliminary cleanup that would conflict with the rename; the rename itself is in the final commit.

r? nnethercote (or compiler)

compiler/rustc_middle/src/dep_graph/dep_node.rs

@@ -1,11 +1,7 @@
-use rustc_data_structures::fingerprint::Fingerprint;
-use rustc_hir::def_id::{CrateNum, DefId, LOCAL_CRATE, LocalDefId, LocalModDefId, ModDefId};
+use rustc_hir::def_id::DefId;
 use rustc_hir::definitions::DefPathHash;
-use rustc_hir::{HirId, ItemLocalId, OwnerId};
-pub use rustc_query_system::dep_graph::DepNode;
-use rustc_query_system::dep_graph::FingerprintStyle;
-pub use rustc_query_system::dep_graph::dep_node::DepKind;
-pub(crate) use rustc_query_system::dep_graph::{DepContext, DepNodeParams};
+use rustc_query_system::dep_graph::dep_node::DepKind;
+use rustc_query_system::dep_graph::{DepContext, DepNode, FingerprintStyle};
 use rustc_span::Symbol;
 
 use crate::mir::mono::MonoItem;
@@ -176,223 +172,3 @@ pub fn dep_kind_from_label(label: &str) -> DepKind {
     dep_kind_from_label_string(label)
         .unwrap_or_else(|_| panic!("Query label {label} does not exist"))
 }
-
-impl<'tcx> DepNodeParams<TyCtxt<'tcx>> for () {
-    #[inline(always)]
-    fn fingerprint_style() -> FingerprintStyle {
-        FingerprintStyle::Unit
-    }
-
-    #[inline(always)]
-    fn to_fingerprint(&self, _: TyCtxt<'tcx>) -> Fingerprint {
-        Fingerprint::ZERO
-    }
-
-    #[inline(always)]
-    fn recover(_: TyCtxt<'tcx>, _: &DepNode) -> Option<Self> {
-        Some(())
-    }
-}
-
-impl<'tcx> DepNodeParams<TyCtxt<'tcx>> for DefId {
-    #[inline(always)]
-    fn fingerprint_style() -> FingerprintStyle {
-        FingerprintStyle::DefPathHash
-    }
-
-    #[inline(always)]
-    fn to_fingerprint(&self, tcx: TyCtxt<'tcx>) -> Fingerprint {
-        tcx.def_path_hash(*self).0
-    }
-
-    #[inline(always)]
-    fn to_debug_str(&self, tcx: TyCtxt<'tcx>) -> String {
-        tcx.def_path_str(*self)
-    }
-
-    #[inline(always)]
-    fn recover(tcx: TyCtxt<'tcx>, dep_node: &DepNode) -> Option<Self> {
-        dep_node.extract_def_id(tcx)
-    }
-}
-
-impl<'tcx> DepNodeParams<TyCtxt<'tcx>> for LocalDefId {
-    #[inline(always)]
-    fn fingerprint_style() -> FingerprintStyle {
-        FingerprintStyle::DefPathHash
-    }
-
-    #[inline(always)]
-    fn to_fingerprint(&self, tcx: TyCtxt<'tcx>) -> Fingerprint {
-        self.to_def_id().to_fingerprint(tcx)
-    }
-
-    #[inline(always)]
-    fn to_debug_str(&self, tcx: TyCtxt<'tcx>) -> String {
-        self.to_def_id().to_debug_str(tcx)
-    }
-
-    #[inline(always)]
-    fn recover(tcx: TyCtxt<'tcx>, dep_node: &DepNode) -> Option<Self> {
-        dep_node.extract_def_id(tcx).map(|id| id.expect_local())
-    }
-}
-
-impl<'tcx> DepNodeParams<TyCtxt<'tcx>> for OwnerId {
-    #[inline(always)]
-    fn fingerprint_style() -> FingerprintStyle {
-        FingerprintStyle::DefPathHash
-    }
-
-    #[inline(always)]
-    fn to_fingerprint(&self, tcx: TyCtxt<'tcx>) -> Fingerprint {
-        self.to_def_id().to_fingerprint(tcx)
-    }
-
-    #[inline(always)]
-    fn to_debug_str(&self, tcx: TyCtxt<'tcx>) -> String {
-        self.to_def_id().to_debug_str(tcx)
-    }
-
-    #[inline(always)]
-    fn recover(tcx: TyCtxt<'tcx>, dep_node: &DepNode) -> Option<Self> {
-        dep_node.extract_def_id(tcx).map(|id| OwnerId { def_id: id.expect_local() })
-    }
-}
-
-impl<'tcx> DepNodeParams<TyCtxt<'tcx>> for CrateNum {
-    #[inline(always)]
-    fn fingerprint_style() -> FingerprintStyle {
-        FingerprintStyle::DefPathHash
-    }
-
-    #[inline(always)]
-    fn to_fingerprint(&self, tcx: TyCtxt<'tcx>) -> Fingerprint {
-        let def_id = self.as_def_id();
-        def_id.to_fingerprint(tcx)
-    }
-
-    #[inline(always)]
-    fn to_debug_str(&self, tcx: TyCtxt<'tcx>) -> String {
-        tcx.crate_name(*self).to_string()
-    }
-
-    #[inline(always)]
-    fn recover(tcx: TyCtxt<'tcx>, dep_node: &DepNode) -> Option<Self> {
-        dep_node.extract_def_id(tcx).map(|id| id.krate)
-    }
-}
-
-impl<'tcx> DepNodeParams<TyCtxt<'tcx>> for (DefId, DefId) {
-    #[inline(always)]
-    fn fingerprint_style() -> FingerprintStyle {
-        FingerprintStyle::Opaque
-    }
-
-    // We actually would not need to specialize the implementation of this
-    // method but it's faster to combine the hashes than to instantiate a full
-    // hashing context and stable-hashing state.
-    #[inline(always)]
-    fn to_fingerprint(&self, tcx: TyCtxt<'tcx>) -> Fingerprint {
-        let (def_id_0, def_id_1) = *self;
-
-        let def_path_hash_0 = tcx.def_path_hash(def_id_0);
-        let def_path_hash_1 = tcx.def_path_hash(def_id_1);
-
-        def_path_hash_0.0.combine(def_path_hash_1.0)
-    }
-
-    #[inline(always)]
-    fn to_debug_str(&self, tcx: TyCtxt<'tcx>) -> String {
-        let (def_id_0, def_id_1) = *self;
-
-        format!("({}, {})", tcx.def_path_debug_str(def_id_0), tcx.def_path_debug_str(def_id_1))
-    }
-}
-
-impl<'tcx> DepNodeParams<TyCtxt<'tcx>> for HirId {
-    #[inline(always)]
-    fn fingerprint_style() -> FingerprintStyle {
-        FingerprintStyle::HirId
-    }
-
-    // We actually would not need to specialize the implementation of this
-    // method but it's faster to combine the hashes than to instantiate a full
-    // hashing context and stable-hashing state.
-    #[inline(always)]
-    fn to_fingerprint(&self, tcx: TyCtxt<'tcx>) -> Fingerprint {
-        let HirId { owner, local_id } = *self;
-        let def_path_hash = tcx.def_path_hash(owner.to_def_id());
-        Fingerprint::new(
-            // `owner` is local, so is completely defined by the local hash
-            def_path_hash.local_hash(),
-            local_id.as_u32() as u64,
-        )
-    }
-
-    #[inline(always)]
-    fn to_debug_str(&self, tcx: TyCtxt<'tcx>) -> String {
-        let HirId { owner, local_id } = *self;
-        format!("{}.{}", tcx.def_path_str(owner), local_id.as_u32())
-    }
-
-    #[inline(always)]
-    fn recover(tcx: TyCtxt<'tcx>, dep_node: &DepNode) -> Option<Self> {
-        if tcx.fingerprint_style(dep_node.kind) == FingerprintStyle::HirId {
-            let (local_hash, local_id) = Fingerprint::from(dep_node.hash).split();
-            let def_path_hash = DefPathHash::new(tcx.stable_crate_id(LOCAL_CRATE), local_hash);
-            let def_id = tcx.def_path_hash_to_def_id(def_path_hash)?.expect_local();
-            let local_id = local_id
-                .as_u64()
-                .try_into()
-                .unwrap_or_else(|_| panic!("local id should be u32, found {local_id:?}"));
-            Some(HirId { owner: OwnerId { def_id }, local_id: ItemLocalId::from_u32(local_id) })
-        } else {
-            None
-        }
-    }
-}
-
-impl<'tcx> DepNodeParams<TyCtxt<'tcx>> for ModDefId {
-    #[inline(always)]
-    fn fingerprint_style() -> FingerprintStyle {
-        FingerprintStyle::DefPathHash
-    }
-
-    #[inline(always)]
-    fn to_fingerprint(&self, tcx: TyCtxt<'tcx>) -> Fingerprint {
-        self.to_def_id().to_fingerprint(tcx)
-    }
-
-    #[inline(always)]
-    fn to_debug_str(&self, tcx: TyCtxt<'tcx>) -> String {
-        self.to_def_id().to_debug_str(tcx)
-    }
-
-    #[inline(always)]
-    fn recover(tcx: TyCtxt<'tcx>, dep_node: &DepNode) -> Option<Self> {
-        DefId::recover(tcx, dep_node).map(ModDefId::new_unchecked)
-    }
-}
-
-impl<'tcx> DepNodeParams<TyCtxt<'tcx>> for LocalModDefId {
-    #[inline(always)]
-    fn fingerprint_style() -> FingerprintStyle {
-        FingerprintStyle::DefPathHash
-    }
-
-    #[inline(always)]
-    fn to_fingerprint(&self, tcx: TyCtxt<'tcx>) -> Fingerprint {
-        self.to_def_id().to_fingerprint(tcx)
-    }
-
-    #[inline(always)]
-    fn to_debug_str(&self, tcx: TyCtxt<'tcx>) -> String {
-        self.to_def_id().to_debug_str(tcx)
-    }
-
-    #[inline(always)]
-    fn recover(tcx: TyCtxt<'tcx>, dep_node: &DepNode) -> Option<Self> {
-        LocalDefId::recover(tcx, dep_node).map(LocalModDefId::new_unchecked)
-    }
-}

compiler/rustc_middle/src/dep_graph/dep_node_key.rs

@@ -0,0 +1,228 @@
+use rustc_data_structures::fingerprint::Fingerprint;
+use rustc_hir::def_id::{CrateNum, DefId, LOCAL_CRATE, LocalDefId, LocalModDefId, ModDefId};
+use rustc_hir::definitions::DefPathHash;
+use rustc_hir::{HirId, ItemLocalId, OwnerId};
+use rustc_query_system::dep_graph::{DepContext, DepNode, DepNodeKey, FingerprintStyle};
+
+use crate::dep_graph::DepNodeExt;
+use crate::ty::TyCtxt;
+
+impl<'tcx> DepNodeKey<TyCtxt<'tcx>> for () {
+    #[inline(always)]
+    fn fingerprint_style() -> FingerprintStyle {
+        FingerprintStyle::Unit
+    }
+
+    #[inline(always)]
+    fn to_fingerprint(&self, _: TyCtxt<'tcx>) -> Fingerprint {
+        Fingerprint::ZERO
+    }
+
+    #[inline(always)]
+    fn recover(_: TyCtxt<'tcx>, _: &DepNode) -> Option<Self> {
+        Some(())
+    }
+}
+
+impl<'tcx> DepNodeKey<TyCtxt<'tcx>> for DefId {
+    #[inline(always)]
+    fn fingerprint_style() -> FingerprintStyle {
+        FingerprintStyle::DefPathHash
+    }
+
+    #[inline(always)]
+    fn to_fingerprint(&self, tcx: TyCtxt<'tcx>) -> Fingerprint {
+        tcx.def_path_hash(*self).0
+    }
+
+    #[inline(always)]
+    fn to_debug_str(&self, tcx: TyCtxt<'tcx>) -> String {
+        tcx.def_path_str(*self)
+    }
+
+    #[inline(always)]
+    fn recover(tcx: TyCtxt<'tcx>, dep_node: &DepNode) -> Option<Self> {
+        dep_node.extract_def_id(tcx)
+    }
+}
+
+impl<'tcx> DepNodeKey<TyCtxt<'tcx>> for LocalDefId {
+    #[inline(always)]
+    fn fingerprint_style() -> FingerprintStyle {
+        FingerprintStyle::DefPathHash
+    }
+
+    #[inline(always)]
+    fn to_fingerprint(&self, tcx: TyCtxt<'tcx>) -> Fingerprint {
+        self.to_def_id().to_fingerprint(tcx)
+    }
+
+    #[inline(always)]
+    fn to_debug_str(&self, tcx: TyCtxt<'tcx>) -> String {
+        self.to_def_id().to_debug_str(tcx)
+    }
+
+    #[inline(always)]
+    fn recover(tcx: TyCtxt<'tcx>, dep_node: &DepNode) -> Option<Self> {
+        dep_node.extract_def_id(tcx).map(|id| id.expect_local())
+    }
+}
+
+impl<'tcx> DepNodeKey<TyCtxt<'tcx>> for OwnerId {
+    #[inline(always)]
+    fn fingerprint_style() -> FingerprintStyle {
+        FingerprintStyle::DefPathHash
+    }
+
+    #[inline(always)]
+    fn to_fingerprint(&self, tcx: TyCtxt<'tcx>) -> Fingerprint {
+        self.to_def_id().to_fingerprint(tcx)
+    }
+
+    #[inline(always)]
+    fn to_debug_str(&self, tcx: TyCtxt<'tcx>) -> String {
+        self.to_def_id().to_debug_str(tcx)
+    }
+
+    #[inline(always)]
+    fn recover(tcx: TyCtxt<'tcx>, dep_node: &DepNode) -> Option<Self> {
+        dep_node.extract_def_id(tcx).map(|id| OwnerId { def_id: id.expect_local() })
+    }
+}
+
+impl<'tcx> DepNodeKey<TyCtxt<'tcx>> for CrateNum {
+    #[inline(always)]
+    fn fingerprint_style() -> FingerprintStyle {
+        FingerprintStyle::DefPathHash
+    }
+
+    #[inline(always)]
+    fn to_fingerprint(&self, tcx: TyCtxt<'tcx>) -> Fingerprint {
+        let def_id = self.as_def_id();
+        def_id.to_fingerprint(tcx)
+    }
+
+    #[inline(always)]
+    fn to_debug_str(&self, tcx: TyCtxt<'tcx>) -> String {
+        tcx.crate_name(*self).to_string()
+    }
+
+    #[inline(always)]
+    fn recover(tcx: TyCtxt<'tcx>, dep_node: &DepNode) -> Option<Self> {
+        dep_node.extract_def_id(tcx).map(|id| id.krate)
+    }
+}
+
+impl<'tcx> DepNodeKey<TyCtxt<'tcx>> for (DefId, DefId) {
+    #[inline(always)]
+    fn fingerprint_style() -> FingerprintStyle {
+        FingerprintStyle::Opaque
+    }
+
+    // We actually would not need to specialize the implementation of this
+    // method but it's faster to combine the hashes than to instantiate a full
+    // hashing context and stable-hashing state.
+    #[inline(always)]
+    fn to_fingerprint(&self, tcx: TyCtxt<'tcx>) -> Fingerprint {
+        let (def_id_0, def_id_1) = *self;
+
+        let def_path_hash_0 = tcx.def_path_hash(def_id_0);
+        let def_path_hash_1 = tcx.def_path_hash(def_id_1);
+
+        def_path_hash_0.0.combine(def_path_hash_1.0)
+    }
+
+    #[inline(always)]
+    fn to_debug_str(&self, tcx: TyCtxt<'tcx>) -> String {
+        let (def_id_0, def_id_1) = *self;
+
+        format!("({}, {})", tcx.def_path_debug_str(def_id_0), tcx.def_path_debug_str(def_id_1))
+    }
+}
+
+impl<'tcx> DepNodeKey<TyCtxt<'tcx>> for HirId {
+    #[inline(always)]
+    fn fingerprint_style() -> FingerprintStyle {
+        FingerprintStyle::HirId
+    }
+
+    // We actually would not need to specialize the implementation of this
+    // method but it's faster to combine the hashes than to instantiate a full
+    // hashing context and stable-hashing state.
+    #[inline(always)]
+    fn to_fingerprint(&self, tcx: TyCtxt<'tcx>) -> Fingerprint {
+        let HirId { owner, local_id } = *self;
+        let def_path_hash = tcx.def_path_hash(owner.to_def_id());
+        Fingerprint::new(
+            // `owner` is local, so is completely defined by the local hash
+            def_path_hash.local_hash(),
+            local_id.as_u32() as u64,
+        )
+    }
+
+    #[inline(always)]
+    fn to_debug_str(&self, tcx: TyCtxt<'tcx>) -> String {
+        let HirId { owner, local_id } = *self;
+        format!("{}.{}", tcx.def_path_str(owner), local_id.as_u32())
+    }
+
+    #[inline(always)]
+    fn recover(tcx: TyCtxt<'tcx>, dep_node: &DepNode) -> Option<Self> {
+        if tcx.fingerprint_style(dep_node.kind) == FingerprintStyle::HirId {
+            let (local_hash, local_id) = Fingerprint::from(dep_node.hash).split();
+            let def_path_hash = DefPathHash::new(tcx.stable_crate_id(LOCAL_CRATE), local_hash);
+            let def_id = tcx.def_path_hash_to_def_id(def_path_hash)?.expect_local();
+            let local_id = local_id
+                .as_u64()
+                .try_into()
+                .unwrap_or_else(|_| panic!("local id should be u32, found {local_id:?}"));
+            Some(HirId { owner: OwnerId { def_id }, local_id: ItemLocalId::from_u32(local_id) })
+        } else {
+            None
+        }
+    }
+}
+
+impl<'tcx> DepNodeKey<TyCtxt<'tcx>> for ModDefId {
+    #[inline(always)]
+    fn fingerprint_style() -> FingerprintStyle {
+        FingerprintStyle::DefPathHash
+    }
+
+    #[inline(always)]
+    fn to_fingerprint(&self, tcx: TyCtxt<'tcx>) -> Fingerprint {
+        self.to_def_id().to_fingerprint(tcx)
+    }
+
+    #[inline(always)]
+    fn to_debug_str(&self, tcx: TyCtxt<'tcx>) -> String {
+        self.to_def_id().to_debug_str(tcx)
+    }
+
+    #[inline(always)]
+    fn recover(tcx: TyCtxt<'tcx>, dep_node: &DepNode) -> Option<Self> {
+        DefId::recover(tcx, dep_node).map(ModDefId::new_unchecked)
+    }
+}
+
+impl<'tcx> DepNodeKey<TyCtxt<'tcx>> for LocalModDefId {
+    #[inline(always)]
+    fn fingerprint_style() -> FingerprintStyle {
+        FingerprintStyle::DefPathHash
+    }
+
+    #[inline(always)]
+    fn to_fingerprint(&self, tcx: TyCtxt<'tcx>) -> Fingerprint {
+        self.to_def_id().to_fingerprint(tcx)
+    }
+
+    #[inline(always)]
+    fn to_debug_str(&self, tcx: TyCtxt<'tcx>) -> String {
+        self.to_def_id().to_debug_str(tcx)
+    }
+
+    #[inline(always)]
+    fn recover(tcx: TyCtxt<'tcx>, dep_node: &DepNode) -> Option<Self> {
+        LocalDefId::recover(tcx, dep_node).map(LocalModDefId::new_unchecked)
+    }
+}

compiler/rustc_middle/src/dep_graph/mod.rs

@@ -7,15 +7,17 @@
 
 #[macro_use]
 mod dep_node;
+mod dep_node_key;
 
-pub use dep_node::{DepKind, DepNode, DepNodeExt, dep_kind_from_label, dep_kinds, label_strs};
-pub(crate) use dep_node::{make_compile_codegen_unit, make_compile_mono_item, make_metadata};
 pub use rustc_query_system::dep_graph::debug::{DepNodeFilter, EdgeFilter};
 pub use rustc_query_system::dep_graph::{
-    DepContext, DepGraphQuery, DepNodeIndex, Deps, SerializedDepGraph, SerializedDepNodeIndex,
-    TaskDepsRef, WorkProduct, WorkProductId, WorkProductMap, hash_result,
+    DepContext, DepGraphQuery, DepKind, DepNode, DepNodeIndex, Deps, SerializedDepGraph,
+    SerializedDepNodeIndex, TaskDepsRef, WorkProduct, WorkProductId, WorkProductMap, hash_result,
 };
 
+pub use self::dep_node::{DepNodeExt, dep_kind_from_label, dep_kinds, label_strs};
+pub(crate) use self::dep_node::{make_compile_codegen_unit, make_compile_mono_item, make_metadata};
+
 pub type DepGraph = rustc_query_system::dep_graph::DepGraph<DepsType>;
 
 pub type DepKindVTable<'tcx> = rustc_query_system::dep_graph::DepKindVTable<TyCtxt<'tcx>>;

compiler/rustc_middle/src/query/inner.rs

@@ -1,7 +1,7 @@
 //! Helper functions that serve as the immediate implementation of
 //! `tcx.$query(..)` and its variations.
 
-use rustc_query_system::dep_graph::{DepKind, DepNodeParams};
+use rustc_query_system::dep_graph::{DepKind, DepNodeKey};
 use rustc_query_system::query::{QueryCache, QueryMode, try_get_cached};
 use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span};
 
@@ -86,7 +86,7 @@ pub(crate) fn query_feed<'tcx, Cache>(
     value: Cache::Value,
 ) where
     Cache: QueryCache,
-    Cache::Key: DepNodeParams<TyCtxt<'tcx>>,
+    Cache::Key: DepNodeKey<TyCtxt<'tcx>>,
 {
     let format_value = query_vtable.format_value;
 

compiler/rustc_query_impl/src/plumbing.rs

@@ -24,7 +24,7 @@
 use rustc_middle::ty::print::with_reduced_queries;
 use rustc_middle::ty::tls::{self, ImplicitCtxt};
 use rustc_middle::ty::{self, TyCtxt};
-use rustc_query_system::dep_graph::{DepNodeParams, FingerprintStyle, HasDepContext};
+use rustc_query_system::dep_graph::{DepNodeKey, FingerprintStyle, HasDepContext};
 use rustc_query_system::ich::StableHashingContext;
 use rustc_query_system::query::{
     QueryCache, QueryContext, QueryDispatcher, QueryJobId, QueryMap, QuerySideEffect,

compiler/rustc_query_system/src/dep_graph/dep_node.rs

@@ -124,7 +124,7 @@ pub fn new_no_params<Tcx>(tcx: Tcx, kind: DepKind) -> DepNode
     pub fn construct<Tcx, Key>(tcx: Tcx, kind: DepKind, arg: &Key) -> DepNode
     where
         Tcx: super::DepContext,
-        Key: DepNodeParams<Tcx>,
+        Key: DepNodeKey<Tcx>,
     {
         let hash = arg.to_fingerprint(tcx);
         let dep_node = DepNode { kind, hash: hash.into() };
@@ -167,16 +167,13 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
     }
 }
 
-pub trait DepNodeParams<Tcx: DepContext>: fmt::Debug + Sized {
+/// Trait for query keys as seen by dependency-node tracking.
+pub trait DepNodeKey<Tcx: DepContext>: fmt::Debug + Sized {
     fn fingerprint_style() -> FingerprintStyle;
 
-    /// This method turns the parameters of a DepNodeConstructor into an opaque
-    /// Fingerprint to be used in DepNode.
-    /// Not all DepNodeParams support being turned into a Fingerprint (they
-    /// don't need to if the corresponding DepNode is anonymous).
-    fn to_fingerprint(&self, _: Tcx) -> Fingerprint {
-        panic!("Not implemented. Accidentally called on anonymous node?")
-    }
+    /// This method turns a query key into an opaque `Fingerprint` to be used
+    /// in `DepNode`.
+    fn to_fingerprint(&self, _: Tcx) -> Fingerprint;
 
     fn to_debug_str(&self, tcx: Tcx) -> String;
 
@@ -189,7 +186,8 @@ fn to_fingerprint(&self, _: Tcx) -> Fingerprint {
     fn recover(tcx: Tcx, dep_node: &DepNode) -> Option<Self>;
 }
 
-impl<Tcx: DepContext, T> DepNodeParams<Tcx> for T
+// Blanket impl of `DepNodeKey`, which is specialized by other impls elsewhere.
+impl<Tcx: DepContext, T> DepNodeKey<Tcx> for T
 where
     T: for<'a> HashStable<StableHashingContext<'a>> + fmt::Debug,
 {
@@ -239,7 +237,7 @@ pub struct DepKindVTable<Tcx: DepContext> {
 
     /// Indicates whether and how the query key can be recovered from its hashed fingerprint.
     ///
-    /// The [`DepNodeParams`] trait determines the fingerprint style for each key type.
+    /// The [`DepNodeKey`] trait determines the fingerprint style for each key type.
     pub fingerprint_style: FingerprintStyle,
 
     /// The red/green evaluation system will try to mark a specific DepNode in the

compiler/rustc_query_system/src/dep_graph/mod.rs

@@ -7,7 +7,7 @@
 
 use std::panic;
 
-pub use dep_node::{DepKind, DepKindVTable, DepNode, DepNodeParams, WorkProductId};
+pub use dep_node::{DepKind, DepKindVTable, DepNode, DepNodeKey, WorkProductId};
 pub(crate) use graph::DepGraphData;
 pub use graph::{DepGraph, DepNodeIndex, TaskDepsRef, WorkProduct, WorkProductMap, hash_result};
 pub use query::DepGraphQuery;

compiler/rustc_query_system/src/query/dispatcher.rs

@@ -5,7 +5,7 @@
 use rustc_span::ErrorGuaranteed;
 
 use super::QueryStackFrameExtra;
-use crate::dep_graph::{DepKind, DepNode, DepNodeParams, HasDepContext, SerializedDepNodeIndex};
+use crate::dep_graph::{DepKind, DepNode, DepNodeKey, HasDepContext, SerializedDepNodeIndex};
 use crate::ich::StableHashingContext;
 use crate::query::caches::QueryCache;
 use crate::query::{CycleError, CycleErrorHandling, DepNodeIndex, QueryContext, QueryState};
@@ -33,7 +33,7 @@ pub trait QueryDispatcher<'tcx>: Copy + 'tcx {
 
     // `Key` and `Value` are `Copy` instead of `Clone` to ensure copying them stays cheap,
     // but it isn't necessary.
-    type Key: DepNodeParams<DepContextOf<'tcx, Self>> + Eq + Hash + Copy + Debug;
+    type Key: DepNodeKey<DepContextOf<'tcx, Self>> + Eq + Hash + Copy + Debug;
     type Value: Copy;
 
     type Cache: QueryCache<Key = Self::Key, Value = Self::Value>;

compiler/rustc_query_system/src/query/plumbing.rs

@@ -18,7 +18,7 @@
 
 use super::{QueryDispatcher, QueryStackDeferred, QueryStackFrameExtra};
 use crate::dep_graph::{
-    DepContext, DepGraphData, DepNode, DepNodeIndex, DepNodeParams, HasDepContext,
+    DepContext, DepGraphData, DepNode, DepNodeIndex, DepNodeKey, HasDepContext,
 };
 use crate::ich::StableHashingContext;
 use crate::query::caches::QueryCache;

compiler/rustc_span/src/def_id.rs

@@ -540,7 +540,7 @@ fn from(typed: $LocalName) -> Self {
 }
 
 // N.B.: when adding new typed `DefId`s update the corresponding trait impls in
-// `rustc_middle::dep_graph::def_node` for `DepNodeParams`.
+// `rustc_middle::dep_graph::dep_node_key` for `DepNodeKey`.
 typed_def_id! { ModDefId, LocalModDefId }
 
 impl LocalModDefId {