From ae216ca90d18c86900eb2600bb8937dbe4aba867 Mon Sep 17 00:00:00 2001 From: Nicholas Nethercote Date: Tue, 10 Feb 2026 22:06:35 +1100 Subject: [PATCH] Rework `rustc_query_impl::define_queries`. To make it more similar to `rustc_middle::define_callbacks`, because I think it's very helpful for the two macros to work similarly. `define_queries` currently generates one module called `query_impl::$name` for every query, and also generates a few types/consts/funcs into crate root. After this change, it instead generates one module called `queries::$name` for every query, and also generates those few types/consts/funcs into `queries`. This makes it much more like `define_callbacks`. The commit also adjusts imports so the body of `define_queries` needs fewer qualifiers, and to minimize potential confusion between `rustc_middle::queries` and `rustc_query_impl::queries`. And removes some unnecessary `$crate`/`crate` qualifiers. --- compiler/rustc_interface/src/passes.rs | 2 +- compiler/rustc_middle/src/query/plumbing.rs | 3 +- compiler/rustc_query_impl/src/lib.rs | 11 +- compiler/rustc_query_impl/src/plumbing.rs | 123 +++++++++--------- .../rustc_query_impl/src/profiling_support.rs | 2 +- 5 files changed, 71 insertions(+), 70 deletions(-) diff --git a/compiler/rustc_interface/src/passes.rs b/compiler/rustc_interface/src/passes.rs index e474f106433df..6a93ac2d97783 100644 --- a/compiler/rustc_interface/src/passes.rs +++ b/compiler/rustc_interface/src/passes.rs @@ -991,7 +991,7 @@ pub fn create_and_enter_global_ctxt FnOnce(TyCtxt<'tcx>) -> T>( hir_arena, untracked, dep_graph, - rustc_query_impl::make_dep_kind_vtables(arena), + rustc_query_impl::queries::make_dep_kind_vtables(arena), rustc_query_impl::query_system( providers.queries, providers.extern_queries, diff --git a/compiler/rustc_middle/src/query/plumbing.rs b/compiler/rustc_middle/src/query/plumbing.rs index 04a3ceb0918af..1d607a0eadea0 100644 --- a/compiler/rustc_middle/src/query/plumbing.rs +++ b/compiler/rustc_middle/src/query/plumbing.rs @@ -270,6 +270,7 @@ macro_rules! separate_provide_extern_default { }; } +// See also `define_queries!`. macro_rules! define_callbacks { ( $( @@ -277,7 +278,7 @@ macro_rules! define_callbacks { [$($modifiers:tt)*] fn $name:ident($($K:tt)*) -> $V:ty, )* ) => { - $(#[allow(unused_lifetimes)] pub mod $name { + $(pub mod $name { use super::*; use $crate::query::erase::{self, Erased}; diff --git a/compiler/rustc_query_impl/src/lib.rs b/compiler/rustc_query_impl/src/lib.rs index a33bdd22a7970..c9c2ce7a1f526 100644 --- a/compiler/rustc_query_impl/src/lib.rs +++ b/compiler/rustc_query_impl/src/lib.rs @@ -14,12 +14,11 @@ use rustc_data_structures::sync::AtomicU64; use rustc_middle::arena::Arena; use rustc_middle::dep_graph::{self, DepKind, DepKindVTable, DepNode, DepNodeIndex}; use rustc_middle::queries::{ - self, ExternProviders, Providers, QueryCaches, QueryEngine, QueryStates, + ExternProviders, PerQueryVTables, Providers, QueryCaches, QueryEngine, QueryStates, }; use rustc_middle::query::AsLocalKey; use rustc_middle::query::on_disk_cache::{CacheEncoder, EncodedDepNodeIndex, OnDiskCache}; use rustc_middle::query::plumbing::{HashResult, QuerySystem, QuerySystemFns, QueryVTable}; -use rustc_middle::query::values::Value; use rustc_middle::ty::TyCtxt; use rustc_query_system::dep_graph::SerializedDepNodeIndex; use rustc_query_system::query::{ @@ -31,6 +30,7 @@ pub use crate::plumbing::{QueryCtxt, query_key_hash_verify_all}; use crate::plumbing::{encode_all_query_results, try_mark_green}; use crate::profiling_support::QueryKeyStringCache; pub use crate::profiling_support::alloc_self_profile_query_strings; +use crate::queries::{engine, make_query_vtables}; mod error; mod execution; @@ -205,7 +205,7 @@ impl<'tcx, C: QueryCache, const FLAGS: QueryFlags> SemiDynamicQueryDispatcher<'t /// expansion. /// /// There is one macro-generated implementation of this trait for each query, -/// on the type `rustc_query_impl::query_impl::$name::QueryType`. +/// on the type `rustc_query_impl::queries::$name::QueryType`. trait QueryDispatcherUnerased<'tcx, C: QueryCache, const FLAGS: QueryFlags> { type UnerasedValue; @@ -239,7 +239,10 @@ pub fn query_system<'tcx>( } } -rustc_middle::rustc_with_all_queries! { define_queries! } +pub mod queries { + use super::*; + rustc_middle::rustc_with_all_queries! { define_queries! } +} pub fn provide(providers: &mut rustc_middle::util::Providers) { providers.hooks.alloc_self_profile_query_strings = alloc_self_profile_query_strings; diff --git a/compiler/rustc_query_impl/src/plumbing.rs b/compiler/rustc_query_impl/src/plumbing.rs index 776d720f500bd..07bf98fdc6a99 100644 --- a/compiler/rustc_query_impl/src/plumbing.rs +++ b/compiler/rustc_query_impl/src/plumbing.rs @@ -36,7 +36,7 @@ use rustc_span::def_id::LOCAL_CRATE; use crate::error::{QueryOverflow, QueryOverflowNote}; use crate::execution::{all_inactive, force_query}; -use crate::{QueryDispatcherUnerased, QueryFlags, SemiDynamicQueryDispatcher}; +use crate::{QueryDispatcherUnerased, QueryFlags, SemiDynamicQueryDispatcher, queries}; /// Implements [`QueryContext`] for use by [`rustc_query_system`], since that /// crate does not have direct access to [`TyCtxt`]. @@ -151,7 +151,7 @@ impl<'tcx> QueryContext<'tcx> for QueryCtxt<'tcx> { let mut jobs = QueryMap::default(); let mut complete = true; - for gather_fn in crate::PER_QUERY_GATHER_ACTIVE_JOBS_FNS.iter() { + for gather_fn in queries::PER_QUERY_GATHER_ACTIVE_JOBS_FNS.iter() { if gather_fn(self.tcx, &mut jobs, require_complete).is_none() { complete = false; } @@ -190,7 +190,7 @@ pub(super) fn encode_all_query_results<'tcx>( encoder: &mut CacheEncoder<'_, 'tcx>, query_result_index: &mut EncodedDepNodeIndex, ) { - for encode in super::ENCODE_QUERY_RESULTS.iter().copied().flatten() { + for encode in queries::ENCODE_QUERY_RESULTS.iter().copied().flatten() { encode(tcx, encoder, query_result_index); } } @@ -198,7 +198,7 @@ pub(super) fn encode_all_query_results<'tcx>( pub fn query_key_hash_verify_all<'tcx>(tcx: TyCtxt<'tcx>) { if tcx.sess().opts.unstable_opts.incremental_verify_ich || cfg!(debug_assertions) { tcx.sess.time("query_key_hash_verify_all", || { - for verify in super::QUERY_KEY_HASH_VERIFY.iter() { + for verify in queries::QUERY_KEY_HASH_VERIFY.iter() { verify(tcx); } }) @@ -573,6 +573,8 @@ macro_rules! expand_if_cached { }; } +// See also `define_callbacks!`. +// // NOTE: `$V` isn't used here, but we still need to match on it so it can be passed to other macros // invoked by `rustc_with_all_queries`. macro_rules! define_queries { @@ -582,11 +584,11 @@ macro_rules! define_queries { [$($modifiers:tt)*] fn $name:ident($($K:tt)*) -> $V:ty, )* ) => { - - pub(crate) mod query_impl { $(pub(crate) mod $name { - use super::super::*; + $(pub(crate) mod $name { + use super::*; use std::marker::PhantomData; - use ::rustc_middle::query::erase::{self, Erased}; + use rustc_middle::query::erase::{self, Erased}; + use rustc_middle::queries::$name::{Key, Storage, Value, provided_to_erased}; pub(crate) mod get_query_incr { use super::*; @@ -597,9 +599,9 @@ macro_rules! define_queries { pub(crate) fn __rust_end_short_backtrace<'tcx>( tcx: TyCtxt<'tcx>, span: Span, - key: queries::$name::Key<'tcx>, + key: Key<'tcx>, mode: QueryMode, - ) -> Option>> { + ) -> Option>> { #[cfg(debug_assertions)] let _guard = tracing::span!(tracing::Level::TRACE, stringify!($name), ?key).entered(); execution::get_query_incr( @@ -619,9 +621,9 @@ macro_rules! define_queries { pub(crate) fn __rust_end_short_backtrace<'tcx>( tcx: TyCtxt<'tcx>, span: Span, - key: queries::$name::Key<'tcx>, + key: Key<'tcx>, __mode: QueryMode, - ) -> Option>> { + ) -> Option>> { Some(execution::get_query_non_incr( QueryType::query_dispatcher(tcx), QueryCtxt::new(tcx), @@ -635,7 +637,6 @@ macro_rules! define_queries { /// function pointer in the query's vtable. mod compute_fn { use super::*; - use ::rustc_middle::queries::$name::{Key, Value, provided_to_erased}; /// This function would be named `compute`, but we also want it /// to mark the boundaries of an omitted region in backtraces. @@ -657,9 +658,13 @@ macro_rules! define_queries { } } - pub(crate) fn make_query_vtable<'tcx>() - -> QueryVTable<'tcx, queries::$name::Storage<'tcx>> - { + pub(crate) fn make_query_vtable<'tcx>() -> QueryVTable<'tcx, Storage<'tcx>> { + // These imports are unused for queries where `should_ever_cache_on_disk!` is false. + #[allow(unused)] + use rustc_middle::queries::$name::ProvidedValue; + #[allow(unused)] + use rustc_middle::queries::cached; + QueryVTable { name: stringify!($name), eval_always: is_eval_always!([$($modifiers)*]), @@ -668,7 +673,7 @@ macro_rules! define_queries { query_state: std::mem::offset_of!(QueryStates<'tcx>, $name), query_cache: std::mem::offset_of!(QueryCaches<'tcx>, $name), will_cache_on_disk_for_key_fn: should_ever_cache_on_disk!([$($modifiers)*] { - Some(queries::cached::$name) + Some(cached::$name) } { None }), @@ -677,34 +682,34 @@ macro_rules! define_queries { try_load_from_disk_fn: should_ever_cache_on_disk!([$($modifiers)*] { Some(|tcx, key, prev_index, index| { // Check the `cache_on_disk_if` condition for this key. - if !queries::cached::$name(tcx, key) { + if !cached::$name(tcx, key) { return None; } - let value: queries::$name::ProvidedValue<'tcx> = - $crate::plumbing::try_load_from_disk(tcx, prev_index, index)?; + let value: ProvidedValue<'tcx> = + plumbing::try_load_from_disk(tcx, prev_index, index)?; // Arena-alloc the value if appropriate, and erase it. - Some(queries::$name::provided_to_erased(tcx, value)) + Some(provided_to_erased(tcx, value)) }) } { None }), is_loadable_from_disk_fn: should_ever_cache_on_disk!([$($modifiers)*] { Some(|tcx, key, index| -> bool { - ::rustc_middle::queries::cached::$name(tcx, key) && - $crate::plumbing::loadable_from_disk(tcx, index) + cached::$name(tcx, key) && plumbing::loadable_from_disk(tcx, index) }) } { None }), value_from_cycle_error: |tcx, cycle, guar| { - let result: queries::$name::Value<'tcx> = Value::from_cycle_error(tcx, cycle, guar); + let result: Value<'tcx> = + rustc_middle::query::values::Value::from_cycle_error(tcx, cycle, guar); erase::erase_val(result) }, - hash_result: hash_result!([$($modifiers)*][queries::$name::Value<'tcx>]), - format_value: |value| format!("{:?}", erase::restore_val::>(*value)), - description_fn: $crate::queries::_description_fns::$name, + hash_result: hash_result!([$($modifiers)*][Value<'tcx>]), + format_value: |value| format!("{:?}", erase::restore_val::>(*value)), + description_fn: rustc_middle::queries::_description_fns::$name, } } @@ -719,16 +724,14 @@ macro_rules! define_queries { is_feedable: feedable!([$($modifiers)*]), }; - impl<'tcx> QueryDispatcherUnerased<'tcx, queries::$name::Storage<'tcx>, FLAGS> - for QueryType<'tcx> - { - type UnerasedValue = queries::$name::Value<'tcx>; + impl<'tcx> QueryDispatcherUnerased<'tcx, Storage<'tcx>, FLAGS> for QueryType<'tcx> { + type UnerasedValue = Value<'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, Storage<'tcx>, FLAGS> { SemiDynamicQueryDispatcher { vtable: &tcx.query_system.query_vtables.$name, @@ -736,10 +739,8 @@ macro_rules! define_queries { } #[inline(always)] - fn restore_val(value: as QueryCache>::Value) - -> Self::UnerasedValue - { - erase::restore_val::>(value) + fn restore_val(value: as QueryCache>::Value) -> Self::UnerasedValue { + erase::restore_val::>(value) } } @@ -753,11 +754,11 @@ macro_rules! define_queries { ) -> Option<()> { let make_frame = |tcx: TyCtxt<'tcx>, key| { let vtable = &tcx.query_system.query_vtables.$name; - $crate::plumbing::create_deferred_query_stack_frame(tcx, vtable, key) + plumbing::create_deferred_query_stack_frame(tcx, vtable, key) }; // Call `gather_active_jobs_inner` to do the actual work. - let res = crate::execution::gather_active_jobs_inner(&tcx.query_system.states.$name, + let res = execution::gather_active_jobs_inner(&tcx.query_system.states.$name, tcx, make_frame, qmap, @@ -780,7 +781,7 @@ macro_rules! define_queries { tcx: TyCtxt<'tcx>, string_cache: &mut QueryKeyStringCache ) { - $crate::profiling_support::alloc_self_profile_query_strings_for_query_cache( + profiling_support::alloc_self_profile_query_strings_for_query_cache( tcx, stringify!($name), &tcx.query_system.caches.$name, @@ -794,12 +795,8 @@ 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), + plumbing::encode_query_results::<$name::QueryType<'tcx>, _, _> ( + $name::QueryType::query_dispatcher(tcx), QueryCtxt::new(tcx), encoder, query_result_index, @@ -808,29 +805,29 @@ 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), + plumbing::query_key_hash_verify( + $name::QueryType::query_dispatcher(tcx), QueryCtxt::new(tcx), ) } - })*} + })* pub(crate) fn engine(incremental: bool) -> QueryEngine { if incremental { QueryEngine { - $($name: query_impl::$name::get_query_incr::__rust_end_short_backtrace,)* + $($name: $name::get_query_incr::__rust_end_short_backtrace,)* } } else { QueryEngine { - $($name: query_impl::$name::get_query_non_incr::__rust_end_short_backtrace,)* + $($name: $name::get_query_non_incr::__rust_end_short_backtrace,)* } } } - pub fn make_query_vtables<'tcx>() -> queries::PerQueryVTables<'tcx> { - queries::PerQueryVTables { + pub(crate) fn make_query_vtables<'tcx>() -> PerQueryVTables<'tcx> { + PerQueryVTables { $( - $name: query_impl::$name::make_query_vtable(), + $name: $name::make_query_vtable(), )* } } @@ -843,27 +840,27 @@ macro_rules! define_queries { /// (We arbitrarily use the word "gather" when collecting the jobs for /// each individual query, so that we have distinct function names to /// grep for.) - const PER_QUERY_GATHER_ACTIVE_JOBS_FNS: &[ + pub(crate) const PER_QUERY_GATHER_ACTIVE_JOBS_FNS: &[ for<'tcx> fn(TyCtxt<'tcx>, &mut QueryMap<'tcx>, require_complete: bool) -> Option<()> ] = &[ - $(query_impl::$name::gather_active_jobs),* + $($name::gather_active_jobs),* ]; - const ALLOC_SELF_PROFILE_QUERY_STRINGS: &[ + pub(crate) const ALLOC_SELF_PROFILE_QUERY_STRINGS: &[ for<'tcx> fn(TyCtxt<'tcx>, &mut QueryKeyStringCache) - ] = &[$(query_impl::$name::alloc_self_profile_query_strings),*]; + ] = &[$($name::alloc_self_profile_query_strings),*]; - const ENCODE_QUERY_RESULTS: &[ + pub(crate) const ENCODE_QUERY_RESULTS: &[ Option fn( TyCtxt<'tcx>, &mut CacheEncoder<'_, 'tcx>, &mut EncodedDepNodeIndex) > - ] = &[$(expand_if_cached!([$($modifiers)*], query_impl::$name::encode_query_results)),*]; + ] = &[$(expand_if_cached!([$($modifiers)*], $name::encode_query_results)),*]; - const QUERY_KEY_HASH_VERIFY: &[ + pub(crate) const QUERY_KEY_HASH_VERIFY: &[ for<'tcx> fn(TyCtxt<'tcx>) - ] = &[$(query_impl::$name::query_key_hash_verify),*]; + ] = &[$($name::query_key_hash_verify),*]; /// Module containing a named function for each dep kind (including queries) /// that creates a `DepKindVTable`. @@ -969,8 +966,8 @@ macro_rules! define_queries { } $(pub(crate) fn $name<'tcx>() -> DepKindVTable<'tcx> { - use $crate::query_impl::$name::QueryType; - $crate::plumbing::make_dep_kind_vtable_for_query::, _, _>( + use $name::QueryType; + plumbing::make_dep_kind_vtable_for_query::, _, _>( is_eval_always!([$($modifiers)*]), ) })* diff --git a/compiler/rustc_query_impl/src/profiling_support.rs b/compiler/rustc_query_impl/src/profiling_support.rs index 7be75ea88acad..31e8430f70b23 100644 --- a/compiler/rustc_query_impl/src/profiling_support.rs +++ b/compiler/rustc_query_impl/src/profiling_support.rs @@ -256,7 +256,7 @@ pub fn alloc_self_profile_query_strings(tcx: TyCtxt<'_>) { let mut string_cache = QueryKeyStringCache::new(); - for alloc in super::ALLOC_SELF_PROFILE_QUERY_STRINGS.iter() { + for alloc in crate::queries::ALLOC_SELF_PROFILE_QUERY_STRINGS.iter() { alloc(tcx, &mut string_cache) } tcx.sess.prof.store_query_cache_hits();