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

Streamline `QueryVTableUnerased` into `GetQueryVTable`

Author: bors

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::{GetQueryVTable, QueryFlags};
 
 /// [`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: GetQueryVTable<'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() {

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 GetQueryVTable<'tcx, const FLAGS: QueryFlags> {
+    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>(

compiler/rustc_query_impl/src/plumbing.rs

@@ -17,12 +17,13 @@ use rustc_middle::dep_graph::DepKindVTable;
 use rustc_middle::dep_graph::{
     self, DepNode, DepNodeIndex, DepNodeKey, SerializedDepNodeIndex, dep_kinds,
 };
+use rustc_middle::query::erase::{Erasable, Erased};
 use rustc_middle::query::on_disk_cache::{
     AbsoluteBytePos, CacheDecoder, CacheEncoder, EncodedDepNodeIndex,
 };
 use rustc_middle::query::plumbing::QueryVTable;
 use rustc_middle::query::{
-    Key, QueryCache, QueryJobId, QueryStackDeferred, QueryStackFrame, QueryStackFrameExtra,
+    Key, QueryCache, QueryJobId, QueryStackDeferred, QueryStackFrame, QueryStackFrameExtra, erase,
 };
 use rustc_middle::ty::codec::TyEncoder;
 use rustc_middle::ty::print::with_reduced_queries;
@@ -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::{GetQueryVTable, QueryFlags, SemiDynamicQueryDispatcher};
 
 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, Q, const FLAGS: QueryFlags, Value>(
     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>>,
+    Q: GetQueryVTable<'tcx, FLAGS>,
+    Q::Cache: QueryCache<Value = Erased<Value>>,
+    Value: Erasable + Encodable<CacheEncoder<'a, 'tcx>>,
 {
+    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,7 +359,7 @@ 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));
         }
     });
 }
@@ -485,7 +487,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 +504,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 +524,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 +617,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 [`GetQueryVTable`] for this query.
+            pub(crate) enum VTableGetter {}
+
+            impl<'tcx> GetQueryVTable<'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 +692,11 @@ macro_rules! define_queries {
                     encoder: &mut CacheEncoder<'_, 'tcx>,
                     query_result_index: &mut EncodedDepNodeIndex
                 ) {
-                    $crate::plumbing::encode_query_results::<
-                        query_impl::$name::QueryType<'tcx>,
+                    $crate::plumbing::encode_query_results_inner::<
+                        VTableGetter,
                         _,
                         _
                     > (
-                        query_impl::$name::QueryType::query_dispatcher(tcx),
                         tcx,
                         encoder,
                         query_result_index,
@@ -717,7 +706,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),
+                    query_impl::$name::VTableGetter::query_dispatcher(tcx),
                     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)*]),
                     )
                 }