Auto merge of #152841 - Zalathar:unerased, r=<try>

bors · bors · commit b46d288105b7 · 2026-02-19T11:22:37.000Z
Streamline `QueryVTableUnerased` into `QueryVTableGetter`
diff --git a/compiler/rustc_query_impl/src/dep_kind_vtables.rs b/compiler/rustc_query_impl/src/dep_kind_vtables.rs
@@ -3,7 +3,7 @@ use rustc_middle::dep_graph::{DepKindVTable, DepNodeKey, KeyFingerprintStyle};
 use rustc_middle::query::QueryCache;
 
 use crate::plumbing::{force_from_dep_node_inner, try_load_from_on_disk_cache_inner};
-use crate::{QueryDispatcherUnerased, QueryFlags};
+use crate::{QueryFlags, QueryVTableGetter};
 
 /// [`DepKindVTable`] constructors for special dep kinds that aren't queries.
 #[expect(non_snake_case, reason = "use non-snake case to avoid collision with query names")]
@@ -110,18 +110,17 @@ mod non_query {
 
 /// Shared implementation of the [`DepKindVTable`] constructor for queries.
 /// Called from macro-generated code for each query.
-pub(crate) fn make_dep_kind_vtable_for_query<'tcx, Q, Cache, const FLAGS: QueryFlags>(
+pub(crate) fn make_dep_kind_vtable_for_query<'tcx, Q, const FLAGS: QueryFlags>(
     is_eval_always: bool,
 ) -> DepKindVTable<'tcx>
 where
-    Q: QueryDispatcherUnerased<'tcx, Cache, FLAGS>,
-    Cache: QueryCache + 'tcx,
+    Q: QueryVTableGetter<'tcx, FLAGS>,
 {
     let is_anon = FLAGS.is_anon;
     let key_fingerprint_style = if is_anon {
         KeyFingerprintStyle::Opaque
     } else {
-        <Cache::Key as DepNodeKey<'tcx>>::key_fingerprint_style()
+        <Q::Cache as QueryCache>::Key::key_fingerprint_style()
     };
 
     if is_anon || !key_fingerprint_style.reconstructible() {
@@ -139,12 +138,8 @@ where
         is_anon,
         is_eval_always,
         key_fingerprint_style,
-        force_from_dep_node: Some(|tcx, dep_node, _| {
-            force_from_dep_node_inner(Q::query_dispatcher(tcx), tcx, dep_node)
-        }),
-        try_load_from_on_disk_cache: Some(|tcx, dep_node| {
-            try_load_from_on_disk_cache_inner(Q::query_dispatcher(tcx), tcx, dep_node)
-        }),
+        force_from_dep_node: Some(force_from_dep_node_inner::<'tcx, Q, FLAGS>),
+        try_load_from_on_disk_cache: Some(try_load_from_on_disk_cache_inner::<'tcx, Q, FLAGS>),
         name: Q::NAME,
     }
 }
diff --git a/compiler/rustc_query_impl/src/lib.rs b/compiler/rustc_query_impl/src/lib.rs
@@ -217,25 +217,22 @@ impl<'tcx, C: QueryCache, const FLAGS: QueryFlags> SemiDynamicQueryDispatcher<'t
     }
 }
 
-/// Provides access to vtable-like operations for a query
-/// (by creating a [`SemiDynamicQueryDispatcher`]),
-/// but also keeps track of the "unerased" value type of the query
-/// (i.e. the actual result type in the query declaration).
+/// Trait that knows how to look up the [`QueryVTable`] for a particular query,
+/// and can combine it with static query flags to produce a
+/// [`SemiDynamicQueryDispatcher`].
 ///
 /// This trait allows some per-query code to be defined in generic functions
 /// with a trait bound, instead of having to be defined inline within a macro
 /// expansion.
 ///
 /// There is one macro-generated implementation of this trait for each query,
-/// on the type `rustc_query_impl::query_impl::$name::QueryType`.
-trait QueryDispatcherUnerased<'tcx, C: QueryCache, const FLAGS: QueryFlags> {
-    type UnerasedValue;
+/// on the type `rustc_query_impl::query_impl::$name::VTableGetter`.
+trait QueryVTableGetter<'tcx, const FLAGS: QueryFlags>: 'tcx {
+    type Cache: QueryCache + 'tcx;
 
     const NAME: &'static &'static str;
 
-    fn query_dispatcher(tcx: TyCtxt<'tcx>) -> SemiDynamicQueryDispatcher<'tcx, C, FLAGS>;
-
-    fn restore_val(value: C::Value) -> Self::UnerasedValue;
+    fn query_dispatcher(tcx: TyCtxt<'tcx>) -> SemiDynamicQueryDispatcher<'tcx, Self::Cache, FLAGS>;
 }
 
 pub fn query_system<'tcx>(
diff --git a/compiler/rustc_query_impl/src/plumbing.rs b/compiler/rustc_query_impl/src/plumbing.rs
@@ -17,6 +17,7 @@ use rustc_middle::dep_graph::DepKindVTable;
 use rustc_middle::dep_graph::{
     self, DepNode, DepNodeIndex, DepNodeKey, SerializedDepNodeIndex, dep_kinds,
 };
+use rustc_middle::query::erase::{self, Erasable, Erased};
 use rustc_middle::query::on_disk_cache::{
     AbsoluteBytePos, CacheDecoder, CacheEncoder, EncodedDepNodeIndex,
 };
@@ -34,7 +35,7 @@ use rustc_span::def_id::LOCAL_CRATE;
 use crate::error::{QueryOverflow, QueryOverflowNote};
 use crate::execution::{all_inactive, force_query};
 use crate::job::{QueryJobMap, find_dep_kind_root};
-use crate::{QueryDispatcherUnerased, QueryFlags, SemiDynamicQueryDispatcher};
+use crate::{QueryFlags, QueryVTableGetter};
 
 fn depth_limit_error<'tcx>(tcx: TyCtxt<'tcx>, job: QueryJobId) {
     let job_map =
@@ -335,15 +336,16 @@ where
     QueryStackFrame::new(info, kind, hash, def_id, def_id_for_ty_in_cycle)
 }
 
-pub(crate) fn encode_query_results<'a, 'tcx, Q, C: QueryCache, const FLAGS: QueryFlags>(
-    query: SemiDynamicQueryDispatcher<'tcx, C, FLAGS>,
+pub(crate) fn encode_query_results_inner<'a, 'tcx, Value, Q, const FLAGS: QueryFlags>(
     tcx: TyCtxt<'tcx>,
     encoder: &mut CacheEncoder<'a, 'tcx>,
     query_result_index: &mut EncodedDepNodeIndex,
 ) where
-    Q: QueryDispatcherUnerased<'tcx, C, FLAGS>,
-    Q::UnerasedValue: Encodable<CacheEncoder<'a, 'tcx>>,
+    Value: Erasable + Encodable<CacheEncoder<'a, 'tcx>>,
+    Q: QueryVTableGetter<'tcx, FLAGS>,
+    Q::Cache: QueryCache<Value = Erased<Value>>,
 {
+    let query = Q::query_dispatcher(tcx);
     let _timer = tcx.prof.generic_activity_with_arg("encode_query_results_for", query.name());
 
     assert!(all_inactive(query.query_state(tcx)));
@@ -357,15 +359,16 @@ pub(crate) fn encode_query_results<'a, 'tcx, Q, C: QueryCache, const FLAGS: Quer
 
             // Encode the type check tables with the `SerializedDepNodeIndex`
             // as tag.
-            encoder.encode_tagged(dep_node, &Q::restore_val(*value));
+            encoder.encode_tagged(dep_node, &erase::restore_val(*value));
         }
     });
 }
 
-pub(crate) fn query_key_hash_verify<'tcx, C: QueryCache, const FLAGS: QueryFlags>(
-    query: SemiDynamicQueryDispatcher<'tcx, C, FLAGS>,
-    tcx: TyCtxt<'tcx>,
-) {
+pub(crate) fn query_key_hash_verify_inner<'tcx, Q, const FLAGS: QueryFlags>(tcx: TyCtxt<'tcx>)
+where
+    Q: QueryVTableGetter<'tcx, FLAGS>,
+{
+    let query = Q::query_dispatcher(tcx);
     let _timer = tcx.prof.generic_activity_with_arg("query_key_hash_verify_for", query.name());
 
     let cache = query.query_cache(tcx);
@@ -389,19 +392,21 @@ pub(crate) fn query_key_hash_verify<'tcx, C: QueryCache, const FLAGS: QueryFlags
 }
 
 /// Implementation of [`DepKindVTable::try_load_from_on_disk_cache`] for queries.
-pub(crate) fn try_load_from_on_disk_cache_inner<'tcx, C: QueryCache, const FLAGS: QueryFlags>(
-    query: SemiDynamicQueryDispatcher<'tcx, C, FLAGS>,
+pub(crate) fn try_load_from_on_disk_cache_inner<'tcx, Q, const FLAGS: QueryFlags>(
     tcx: TyCtxt<'tcx>,
     dep_node: DepNode,
-) {
+) where
+    Q: QueryVTableGetter<'tcx, FLAGS>,
+{
     debug_assert!(tcx.dep_graph.is_green(&dep_node));
 
-    let key = C::Key::try_recover_key(tcx, &dep_node).unwrap_or_else(|| {
+    let key = <Q::Cache as QueryCache>::Key::try_recover_key(tcx, &dep_node).unwrap_or_else(|| {
         panic!(
             "Failed to recover key for {dep_node:?} with key fingerprint {}",
             dep_node.key_fingerprint
         )
     });
+    let query = Q::query_dispatcher(tcx);
     if query.will_cache_on_disk_for_key(tcx, &key) {
         // Call `tcx.$query(key)` for its side-effect of loading the disk-cached
         // value into memory.
@@ -442,11 +447,14 @@ where
 }
 
 /// Implementation of [`DepKindVTable::force_from_dep_node`] for queries.
-pub(crate) fn force_from_dep_node_inner<'tcx, C: QueryCache, const FLAGS: QueryFlags>(
-    query: SemiDynamicQueryDispatcher<'tcx, C, FLAGS>,
+pub(crate) fn force_from_dep_node_inner<'tcx, Q, const FLAGS: QueryFlags>(
     tcx: TyCtxt<'tcx>,
     dep_node: DepNode,
-) -> bool {
+    _prev_index: SerializedDepNodeIndex, // Required by vtable but not used by queries
+) -> bool
+where
+    Q: QueryVTableGetter<'tcx, FLAGS>,
+{
     // We must avoid ever having to call `force_from_dep_node()` for a
     // `DepNode::codegen_unit`:
     // Since we cannot reconstruct the query key of a `DepNode::codegen_unit`, we
@@ -465,7 +473,8 @@ pub(crate) fn force_from_dep_node_inner<'tcx, C: QueryCache, const FLAGS: QueryF
         "calling force_from_dep_node() on dep_kinds::codegen_unit"
     );
 
-    if let Some(key) = C::Key::try_recover_key(tcx, &dep_node) {
+    if let Some(key) = <Q::Cache as QueryCache>::Key::try_recover_key(tcx, &dep_node) {
+        let query = Q::query_dispatcher(tcx);
         force_query(query, tcx, key, dep_node);
         true
     } else {
@@ -485,7 +494,6 @@ macro_rules! define_queries {
 
         pub(crate) mod query_impl { $(pub(crate) mod $name {
             use super::super::*;
-            use std::marker::PhantomData;
             use ::rustc_middle::query::erase::{self, Erased};
 
             pub(crate) mod get_query_incr {
@@ -503,7 +511,7 @@ macro_rules! define_queries {
                     #[cfg(debug_assertions)]
                     let _guard = tracing::span!(tracing::Level::TRACE, stringify!($name), ?key).entered();
                     execution::get_query_incr(
-                        QueryType::query_dispatcher(tcx),
+                        VTableGetter::query_dispatcher(tcx),
                         tcx,
                         span,
                         key,
@@ -523,7 +531,7 @@ macro_rules! define_queries {
                     __mode: QueryMode,
                 ) -> Option<Erased<queries::$name::Value<'tcx>>> {
                     Some(execution::get_query_non_incr(
-                        QueryType::query_dispatcher(tcx),
+                        VTableGetter::query_dispatcher(tcx),
                         tcx,
                         span,
                         key,
@@ -616,39 +624,28 @@ macro_rules! define_queries {
                 }
             }
 
-            #[derive(Copy, Clone, Default)]
-            pub(crate) struct QueryType<'tcx> {
-                data: PhantomData<&'tcx ()>
-            }
-
             const FLAGS: QueryFlags = QueryFlags {
                 is_anon: is_anon!([$($modifiers)*]),
                 is_depth_limit: depth_limit!([$($modifiers)*]),
                 is_feedable: feedable!([$($modifiers)*]),
             };
 
-            impl<'tcx> QueryDispatcherUnerased<'tcx, queries::$name::Storage<'tcx>, FLAGS>
-                for QueryType<'tcx>
-            {
-                type UnerasedValue = queries::$name::Value<'tcx>;
+            /// Marker type that implements [`QueryVTableGetter`] for this query.
+            pub(crate) enum VTableGetter {}
+
+            impl<'tcx> QueryVTableGetter<'tcx, FLAGS> for VTableGetter {
+                type Cache = queries::$name::Storage<'tcx>;
 
                 const NAME: &'static &'static str = &stringify!($name);
 
                 #[inline(always)]
                 fn query_dispatcher(tcx: TyCtxt<'tcx>)
-                    -> SemiDynamicQueryDispatcher<'tcx, queries::$name::Storage<'tcx>, FLAGS>
+                    -> SemiDynamicQueryDispatcher<'tcx, Self::Cache, FLAGS>
                 {
                     SemiDynamicQueryDispatcher {
                         vtable: &tcx.query_system.query_vtables.$name,
                     }
                 }
-
-                #[inline(always)]
-                fn restore_val(value: <queries::$name::Storage<'tcx> as QueryCache>::Value)
-                    -> Self::UnerasedValue
-                {
-                    erase::restore_val::<queries::$name::Value<'tcx>>(value)
-                }
             }
 
             /// Internal per-query plumbing for collecting the set of active jobs for this query.
@@ -702,12 +699,7 @@ macro_rules! define_queries {
                     encoder: &mut CacheEncoder<'_, 'tcx>,
                     query_result_index: &mut EncodedDepNodeIndex
                 ) {
-                    $crate::plumbing::encode_query_results::<
-                        query_impl::$name::QueryType<'tcx>,
-                        _,
-                        _
-                    > (
-                        query_impl::$name::QueryType::query_dispatcher(tcx),
+                    $crate::plumbing::encode_query_results_inner::<_, VTableGetter, _>(
                         tcx,
                         encoder,
                         query_result_index,
@@ -716,10 +708,7 @@ macro_rules! define_queries {
             }
 
             pub(crate) fn query_key_hash_verify<'tcx>(tcx: TyCtxt<'tcx>) {
-                $crate::plumbing::query_key_hash_verify(
-                    query_impl::$name::QueryType::query_dispatcher(tcx),
-                    tcx,
-                )
+                $crate::plumbing::query_key_hash_verify_inner::<VTableGetter, _>(tcx)
             }
         })*}
 
@@ -793,8 +782,8 @@ macro_rules! define_queries {
             $(
                 /// `DepKindVTable` constructor for this query.
                 pub(crate) fn $name<'tcx>() -> DepKindVTable<'tcx> {
-                    use $crate::query_impl::$name::QueryType;
-                    make_dep_kind_vtable_for_query::<QueryType<'tcx>, _, _>(
+                    use $crate::query_impl::$name::VTableGetter;
+                    make_dep_kind_vtable_for_query::<VTableGetter, _>(
                         is_eval_always!([$($modifiers)*]),
                     )
                 }
