Rename QueryKeyId to TaggedQueryKey

Author: Zoxc

compiler/rustc_middle/src/query/plumbing.rs

@@ -510,21 +510,21 @@ macro_rules! define_callbacks {
         /// Identifies a query by kind and key. This is in contrast to `QueryId` which is just a number.
         #[allow(non_camel_case_types)]
         #[derive(Clone, Debug)]
-        pub enum QueryKeyId<'tcx> {
+        pub enum TaggedQueryKey<'tcx> {
             $(
                 $name($name::Key<'tcx>),
             )*
         }
 
-        impl<'tcx> QueryKeyId<'tcx> {
+        impl<'tcx> TaggedQueryKey<'tcx> {
             /// Formats a human-readable description of this query and its key, as
             /// specified by the `desc` query modifier.
             ///
             /// Used when reporting query cycle errors and similar problems.
             pub fn description(&self, tcx: TyCtxt<'tcx>) -> String {
                 let (name, description) = ty::print::with_no_queries!(match self {
                     $(
-                        QueryKeyId::$name(key) => (stringify!($name), _description_fns::$name(tcx, *key)),
+                        TaggedQueryKey::$name(key) => (stringify!($name), _description_fns::$name(tcx, *key)),
                     )*
                 });
                 if tcx.sess.verbose_internals() {
@@ -539,14 +539,14 @@ macro_rules! define_callbacks {
                 if !span.is_dummy() {
                     return span
                 }
-                if let QueryKeyId::def_span(..) = self {
+                if let TaggedQueryKey::def_span(..) = self {
                     // The `def_span` query is used to calculate `default_span`,
                     // so exit to avoid infinite recursion.
                     return DUMMY_SP
                 }
                 match self {
                     $(
-                        QueryKeyId::$name(key) => crate::query::QueryKey::default_span(key, tcx),
+                        TaggedQueryKey::$name(key) => crate::query::QueryKey::default_span(key, tcx),
                     )*
                 }
             }
@@ -556,13 +556,13 @@ macro_rules! define_callbacks {
                     key.key_as_def_id().and_then(|def_id| def_id.as_local()).map(|def_id| tcx.def_kind(def_id))
                 }
 
-                if let QueryKeyId::def_kind(..) = self {
+                if let TaggedQueryKey::def_kind(..) = self {
                     // Try to avoid infinite recursion.
                     return None
                 }
                 match self {
                     $(
-                        QueryKeyId::$name(key) => inner(key, tcx),
+                        TaggedQueryKey::$name(key) => inner(key, tcx),
                     )*
                 }
             }

compiler/rustc_middle/src/query/stack.rs

@@ -3,14 +3,14 @@ use std::fmt::Debug;
 use rustc_span::def_id::DefId;
 
 use crate::dep_graph::DepKind;
-use crate::queries::QueryKeyId;
+use crate::queries::TaggedQueryKey;
 
 /// Description of a frame in the query stack.
 ///
 /// This is mostly used in case of cycles for error reporting.
 #[derive(Clone, Debug)]
 pub struct QueryStackFrame<'tcx> {
-    pub id: QueryKeyId<'tcx>,
+    pub id: TaggedQueryKey<'tcx>,
     pub dep_kind: DepKind,
     pub def_id: Option<DefId>,
     /// A def-id that is extracted from a `Ty` in a query key

compiler/rustc_query_impl/src/execution.rs

@@ -7,7 +7,7 @@ use rustc_data_structures::sync::{DynSend, DynSync};
 use rustc_data_structures::{outline, sharded, sync};
 use rustc_errors::{FatalError, StashKey};
 use rustc_middle::dep_graph::{DepGraphData, DepNodeKey, SerializedDepNodeIndex};
-use rustc_middle::queries::QueryKeyId;
+use rustc_middle::queries::TaggedQueryKey;
 use rustc_middle::query::plumbing::QueryVTable;
 use rustc_middle::query::{
     ActiveKeyStatus, CycleError, CycleErrorHandling, EnsureMode, QueryCache, QueryJob, QueryJobId,
@@ -41,7 +41,7 @@ pub(crate) fn all_inactive<'tcx, K>(state: &QueryState<'tcx, K>) -> bool {
 pub(crate) fn gather_active_jobs<'tcx, C>(
     query: &'tcx QueryVTable<'tcx, C>,
     require_complete: bool,
-    make_id: fn(C::Key) -> QueryKeyId<'tcx>,
+    make_id: fn(C::Key) -> TaggedQueryKey<'tcx>,
     job_map_out: &mut QueryJobMap<'tcx>, // Out-param; job info is gathered into this map
 ) -> Option<()>
 where

compiler/rustc_query_impl/src/lib.rs

@@ -10,7 +10,7 @@
 
 use rustc_data_structures::sync::AtomicU64;
 use rustc_middle::dep_graph;
-use rustc_middle::queries::{self, ExternProviders, Providers, QueryKeyId};
+use rustc_middle::queries::{self, ExternProviders, Providers, TaggedQueryKey};
 use rustc_middle::query::on_disk_cache::{CacheEncoder, EncodedDepNodeIndex, OnDiskCache};
 use rustc_middle::query::plumbing::{QuerySystem, QueryVTable};
 use rustc_middle::query::{AsLocalQueryKey, QueryCache, QueryMode};

compiler/rustc_query_impl/src/plumbing.rs

@@ -13,7 +13,7 @@ use rustc_middle::bug;
 #[expect(unused_imports, reason = "used by doc comments")]
 use rustc_middle::dep_graph::DepKindVTable;
 use rustc_middle::dep_graph::{DepKind, DepNode, DepNodeIndex, DepNodeKey, SerializedDepNodeIndex};
-use rustc_middle::queries::QueryKeyId;
+use rustc_middle::queries::TaggedQueryKey;
 use rustc_middle::query::erase::{Erasable, Erased};
 use rustc_middle::query::on_disk_cache::{
     AbsoluteBytePos, CacheDecoder, CacheEncoder, EncodedDepNodeIndex,
@@ -90,7 +90,7 @@ pub(crate) fn start_query<R>(
 pub(crate) fn create_query_stack_frame<'tcx, C>(
     vtable: &'tcx QueryVTable<'tcx, C>,
     key: C::Key,
-    make_id: fn(C::Key) -> QueryKeyId<'tcx>,
+    make_id: fn(C::Key) -> TaggedQueryKey<'tcx>,
 ) -> QueryStackFrame<'tcx>
 where
     C: QueryCache<Key: QueryKey + DynSend + DynSync>,
@@ -486,7 +486,7 @@ macro_rules! define_queries {
                 let res = crate::execution::gather_active_jobs(
                     &tcx.query_system.query_vtables.$name,
                     require_complete,
-                    QueryKeyId::$name,
+                    TaggedQueryKey::$name,
                     &mut job_map_out,
                 );
                 if res.is_none() {