diff --git a/compiler/rustc_middle/src/query/inner.rs b/compiler/rustc_middle/src/query/inner.rs index 0b575b536cb6e..38f8b782ca76a 100644 --- a/compiler/rustc_middle/src/query/inner.rs +++ b/compiler/rustc_middle/src/query/inner.rs @@ -32,15 +32,15 @@ where /// Shared implementation of `tcx.$query(..)` and `tcx.at(span).$query(..)` /// for all queries. #[inline(always)] -pub(crate) fn query_get_at<'tcx, Cache>( +pub(crate) fn query_get_at<'tcx, C>( tcx: TyCtxt<'tcx>, - execute_query: fn(TyCtxt<'tcx>, Span, Cache::Key, QueryMode) -> Option, - query_cache: &Cache, + execute_query: fn(TyCtxt<'tcx>, Span, C::Key, QueryMode) -> Option, + query_cache: &C, span: Span, - key: Cache::Key, -) -> Cache::Value + key: C::Key, +) -> C::Value where - Cache: QueryCache, + C: QueryCache, { match try_get_cached(tcx, query_cache, &key) { Some(value) => value, @@ -51,14 +51,14 @@ where /// Shared implementation of `tcx.ensure_ok().$query(..)` for most queries, /// and `tcx.ensure_done().$query(..)` for all queries. #[inline] -pub(crate) fn query_ensure<'tcx, Cache>( +pub(crate) fn query_ensure<'tcx, C>( tcx: TyCtxt<'tcx>, - execute_query: fn(TyCtxt<'tcx>, Span, Cache::Key, QueryMode) -> Option, - query_cache: &Cache, - key: Cache::Key, + execute_query: fn(TyCtxt<'tcx>, Span, C::Key, QueryMode) -> Option, + query_cache: &C, + key: C::Key, check_cache: bool, ) where - Cache: QueryCache, + C: QueryCache, { if try_get_cached(tcx, query_cache, &key).is_none() { execute_query(tcx, DUMMY_SP, key, QueryMode::Ensure { check_cache }); @@ -68,15 +68,15 @@ pub(crate) fn query_ensure<'tcx, Cache>( /// Shared implementation of `tcx.ensure_ok().$query(..)` for queries that /// have the `return_result_from_ensure_ok` modifier. #[inline] -pub(crate) fn query_ensure_error_guaranteed<'tcx, Cache, T>( +pub(crate) fn query_ensure_error_guaranteed<'tcx, C, T>( tcx: TyCtxt<'tcx>, - execute_query: fn(TyCtxt<'tcx>, Span, Cache::Key, QueryMode) -> Option, - query_cache: &Cache, - key: Cache::Key, + execute_query: fn(TyCtxt<'tcx>, Span, C::Key, QueryMode) -> Option, + query_cache: &C, + key: C::Key, check_cache: bool, ) -> Result<(), ErrorGuaranteed> where - Cache: QueryCache>>, + C: QueryCache>>, Result: Erasable, { if let Some(res) = try_get_cached(tcx, query_cache, &key) { @@ -96,21 +96,20 @@ where } /// Common implementation of query feeding, used by `define_feedable!`. -pub(crate) fn query_feed<'tcx, Cache>( +pub(crate) fn query_feed<'tcx, C>( tcx: TyCtxt<'tcx>, dep_kind: DepKind, - query_vtable: &QueryVTable<'tcx, Cache>, - cache: &Cache, - key: Cache::Key, - value: Cache::Value, + query_vtable: &QueryVTable<'tcx, C>, + key: C::Key, + value: C::Value, ) where - Cache: QueryCache, - Cache::Key: DepNodeKey<'tcx>, + C: QueryCache, + C::Key: DepNodeKey<'tcx>, { let format_value = query_vtable.format_value; // Check whether the in-memory cache already has a value for this key. - match try_get_cached(tcx, cache, &key) { + match try_get_cached(tcx, &query_vtable.query_cache, &key) { Some(old) => { // The query already has a cached value for this key. // That's OK if both values are the same, i.e. they have the same hash, @@ -153,7 +152,7 @@ pub(crate) fn query_feed<'tcx, Cache>( query_vtable.hash_result, query_vtable.format_value, ); - cache.complete(key, value, dep_node_index); + query_vtable.query_cache.complete(key, value, dep_node_index); } } } diff --git a/compiler/rustc_middle/src/query/plumbing.rs b/compiler/rustc_middle/src/query/plumbing.rs index 47b6aea077d17..1243a2138132d 100644 --- a/compiler/rustc_middle/src/query/plumbing.rs +++ b/compiler/rustc_middle/src/query/plumbing.rs @@ -14,9 +14,7 @@ pub use sealed::IntoQueryParam; use crate::dep_graph; use crate::dep_graph::{DepKind, DepNodeIndex, SerializedDepNodeIndex}; use crate::ich::StableHashingContext; -use crate::queries::{ - ExternProviders, PerQueryVTables, Providers, QueryArenas, QueryCaches, QueryEngine, QueryStates, -}; +use crate::queries::{ExternProviders, PerQueryVTables, Providers, QueryArenas}; use crate::query::on_disk_cache::{CacheEncoder, EncodedDepNodeIndex, OnDiskCache}; use crate::query::stack::{QueryStackDeferred, QueryStackFrame, QueryStackFrameExtra}; use crate::query::{QueryCache, QueryInfo, QueryJob}; @@ -108,10 +106,8 @@ pub struct QueryVTable<'tcx, C: QueryCache> { pub dep_kind: DepKind, /// How this query deals with query cycle errors. pub cycle_error_handling: CycleErrorHandling, - // Offset of this query's state field in the QueryStates struct - pub query_state: usize, - // Offset of this query's cache field in the QueryCaches struct - pub query_cache: usize, + pub query_state: QueryState<'tcx, C::Key>, + pub query_cache: C, pub will_cache_on_disk_for_key_fn: Option>, /// Function pointer that calls `tcx.$query(key)` for this query and @@ -140,10 +136,11 @@ pub struct QueryVTable<'tcx, C: QueryCache> { /// /// Used when reporting query cycle errors and similar problems. pub description_fn: fn(TyCtxt<'tcx>, C::Key) -> String, + + pub execute_query_fn: fn(TyCtxt<'tcx>, Span, C::Key, QueryMode) -> Option, } pub struct QuerySystemFns { - pub engine: QueryEngine, pub local_providers: Providers, pub extern_providers: ExternProviders, pub encode_query_results: for<'tcx> fn( @@ -155,9 +152,7 @@ pub struct QuerySystemFns { } pub struct QuerySystem<'tcx> { - pub states: QueryStates<'tcx>, pub arenas: WorkerLocal>, - pub caches: QueryCaches<'tcx>, pub query_vtables: PerQueryVTables<'tcx>, /// This provides access to the incremental compilation on-disk cache for query results. @@ -445,11 +440,6 @@ macro_rules! define_callbacks { )* } - #[derive(Default)] - pub struct QueryCaches<'tcx> { - $($(#[$attr])* pub $name: $name::Storage<'tcx>,)* - } - impl<'tcx> $crate::query::TyCtxtEnsureOk<'tcx> { $($(#[$attr])* #[inline(always)] @@ -460,8 +450,8 @@ macro_rules! define_callbacks { query_ensure_select!( [$($modifiers)*] self.tcx, - self.tcx.query_system.fns.engine.$name, - &self.tcx.query_system.caches.$name, + self.tcx.query_system.query_vtables.$name.execute_query_fn, + &self.tcx.query_system.query_vtables.$name.query_cache, $crate::query::IntoQueryParam::into_query_param(key), false, ) @@ -474,8 +464,8 @@ macro_rules! define_callbacks { pub fn $name(self, key: query_helper_param_ty!($($K)*)) { crate::query::inner::query_ensure( self.tcx, - self.tcx.query_system.fns.engine.$name, - &self.tcx.query_system.caches.$name, + self.tcx.query_system.query_vtables.$name.execute_query_fn, + &self.tcx.query_system.query_vtables.$name.query_cache, $crate::query::IntoQueryParam::into_query_param(key), true, ); @@ -501,8 +491,8 @@ macro_rules! define_callbacks { erase::restore_val::<$V>(inner::query_get_at( self.tcx, - self.tcx.query_system.fns.engine.$name, - &self.tcx.query_system.caches.$name, + self.tcx.query_system.query_vtables.$name.execute_query_fn, + &self.tcx.query_system.query_vtables.$name.query_cache, self.span, $crate::query::IntoQueryParam::into_query_param(key), )) @@ -518,13 +508,6 @@ macro_rules! define_callbacks { )* } - #[derive(Default)] - pub struct QueryStates<'tcx> { - $( - pub $name: $crate::query::QueryState<'tcx, $($K)*>, - )* - } - pub struct Providers { $( /// This is the provider for the query. Use `Find references` on this to @@ -565,15 +548,6 @@ macro_rules! define_callbacks { impl Clone for ExternProviders { fn clone(&self) -> Self { *self } } - - pub struct QueryEngine { - $(pub $name: for<'tcx> fn( - TyCtxt<'tcx>, - Span, - $name::Key<'tcx>, - $crate::query::QueryMode, - ) -> Option<$crate::query::erase::Erased<$V>>,)* - } }; } @@ -594,7 +568,6 @@ macro_rules! define_feedable { tcx, dep_kind, &tcx.query_system.query_vtables.$name, - &tcx.query_system.caches.$name, key, erased_value, ); diff --git a/compiler/rustc_query_impl/src/dep_kind_vtables.rs b/compiler/rustc_query_impl/src/dep_kind_vtables.rs index 39bd2569ef468..198db70d21658 100644 --- a/compiler/rustc_query_impl/src/dep_kind_vtables.rs +++ b/compiler/rustc_query_impl/src/dep_kind_vtables.rs @@ -110,18 +110,18 @@ 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, C, const FLAGS: QueryFlags>( is_eval_always: bool, ) -> DepKindVTable<'tcx> where - Q: QueryDispatcherUnerased<'tcx, Cache, FLAGS>, - Cache: QueryCache + 'tcx, + Q: QueryDispatcherUnerased<'tcx, C, FLAGS>, + C: QueryCache + 'tcx, { let is_anon = FLAGS.is_anon; let key_fingerprint_style = if is_anon { KeyFingerprintStyle::Opaque } else { - >::key_fingerprint_style() + >::key_fingerprint_style() }; if is_anon || !key_fingerprint_style.reconstructible() { diff --git a/compiler/rustc_query_impl/src/execution.rs b/compiler/rustc_query_impl/src/execution.rs index 1f064599332c1..eaae619e86f84 100644 --- a/compiler/rustc_query_impl/src/execution.rs +++ b/compiler/rustc_query_impl/src/execution.rs @@ -244,12 +244,12 @@ fn wait_for_query<'tcx, C: QueryCache, const FLAGS: QueryFlags>( match result { Ok(()) => { - let Some((v, index)) = query.query_cache(tcx).lookup(&key) else { + let Some((v, index)) = query.query_cache().lookup(&key) else { outline(|| { // We didn't find the query result in the query cache. Check if it was // poisoned due to a panic instead. let key_hash = sharded::make_hash(&key); - let shard = query.query_state(tcx).active.lock_shard_by_hash(key_hash); + let shard = query.query_state().active.lock_shard_by_hash(key_hash); match shard.find(key_hash, equivalent_key(&key)) { // The query we waited on panicked. Continue unwinding here. Some((_, ActiveKeyStatus::Poisoned)) => FatalError.raise(), @@ -278,9 +278,8 @@ fn try_execute_query<'tcx, C: QueryCache, const FLAGS: QueryFlags, const INCR: b key: C::Key, dep_node: Option, ) -> (C::Value, Option) { - let state = query.query_state(tcx); let key_hash = sharded::make_hash(&key); - let mut state_lock = state.active.lock_shard_by_hash(key_hash); + let mut state_lock = query.query_state().active.lock_shard_by_hash(key_hash); // For the parallel compiler we need to check both the query cache and query state structures // while holding the state lock to ensure that 1) the query has not yet completed and 2) the @@ -289,7 +288,7 @@ fn try_execute_query<'tcx, C: QueryCache, const FLAGS: QueryFlags, const INCR: b // executing, but another thread may have already completed the query and stores it result // in the query cache. if tcx.sess.threads() > 1 { - if let Some((value, index)) = query.query_cache(tcx).lookup(&key) { + if let Some((value, index)) = query.query_cache().lookup(&key) { tcx.prof.query_cache_hit(index.into()); return (value, Some(index)); } @@ -308,7 +307,7 @@ fn try_execute_query<'tcx, C: QueryCache, const FLAGS: QueryFlags, const INCR: b // Drop the lock before we start executing the query drop(state_lock); - execute_job::(query, tcx, state, key, key_hash, id, dep_node) + execute_job::(query, tcx, key, key_hash, id, dep_node) } Entry::Occupied(mut entry) => { match &mut entry.get_mut().1 { @@ -340,7 +339,6 @@ fn try_execute_query<'tcx, C: QueryCache, const FLAGS: QueryFlags, const INCR: b fn execute_job<'tcx, C: QueryCache, const FLAGS: QueryFlags, const INCR: bool>( query: SemiDynamicQueryDispatcher<'tcx, C, FLAGS>, tcx: TyCtxt<'tcx>, - state: &'tcx QueryState<'tcx, C::Key>, key: C::Key, key_hash: u64, id: QueryJobId, @@ -348,7 +346,7 @@ fn execute_job<'tcx, C: QueryCache, const FLAGS: QueryFlags, const INCR: bool>( ) -> (C::Value, Option) { // Set up a guard object that will automatically poison the query if a // panic occurs while executing the query (or any intermediate plumbing). - let job_guard = ActiveJobGuard { state, key, key_hash }; + let job_guard = ActiveJobGuard { state: query.query_state(), key, key_hash }; debug_assert_eq!(tcx.dep_graph.is_fully_enabled(), INCR); @@ -359,7 +357,7 @@ fn execute_job<'tcx, C: QueryCache, const FLAGS: QueryFlags, const INCR: bool>( execute_job_non_incr(query, tcx, key, id) }; - let cache = query.query_cache(tcx); + let cache = query.query_cache(); if query.feedable() { // We should not compute queries that also got a value via feeding. // This can't happen, as query feeding adds the very dependencies to the fed query @@ -680,7 +678,7 @@ pub(crate) fn force_query<'tcx, C: QueryCache, const FLAGS: QueryFlags>( ) { // We may be concurrently trying both execute and force a query. // Ensure that only one of them runs the query. - if let Some((_, index)) = query.query_cache(tcx).lookup(&key) { + if let Some((_, index)) = query.query_cache().lookup(&key) { tcx.prof.query_cache_hit(index.into()); return; } diff --git a/compiler/rustc_query_impl/src/lib.rs b/compiler/rustc_query_impl/src/lib.rs index b4a64686728f1..036ea647817ed 100644 --- a/compiler/rustc_query_impl/src/lib.rs +++ b/compiler/rustc_query_impl/src/lib.rs @@ -14,9 +14,7 @@ use std::marker::ConstParamTy; use rustc_data_structures::sync::AtomicU64; use rustc_middle::dep_graph::{self, DepKind, DepNode, DepNodeIndex, SerializedDepNodeIndex}; -use rustc_middle::queries::{ - self, ExternProviders, Providers, QueryCaches, QueryEngine, QueryStates, -}; +use rustc_middle::queries::{self, ExternProviders, Providers}; use rustc_middle::query::on_disk_cache::{CacheEncoder, EncodedDepNodeIndex, OnDiskCache}; use rustc_middle::query::plumbing::{ HashResult, QueryState, QuerySystem, QuerySystemFns, QueryVTable, @@ -104,26 +102,14 @@ impl<'tcx, C: QueryCache, const FLAGS: QueryFlags> SemiDynamicQueryDispatcher<'t // Don't use this method to access query results, instead use the methods on TyCtxt. #[inline(always)] - fn query_state(self, tcx: TyCtxt<'tcx>) -> &'tcx QueryState<'tcx, C::Key> { - // Safety: - // This is just manually doing the subfield referencing through pointer math. - unsafe { - &*(&tcx.query_system.states as *const QueryStates<'tcx>) - .byte_add(self.vtable.query_state) - .cast::>() - } + fn query_state(self) -> &'tcx QueryState<'tcx, C::Key> { + &self.vtable.query_state } // Don't use this method to access query results, instead use the methods on TyCtxt. #[inline(always)] - fn query_cache(self, tcx: TyCtxt<'tcx>) -> &'tcx C { - // Safety: - // This is just manually doing the subfield referencing through pointer math. - unsafe { - &*(&tcx.query_system.caches as *const QueryCaches<'tcx>) - .byte_add(self.vtable.query_cache) - .cast::() - } + fn query_cache(self) -> &'tcx C { + &self.vtable.query_cache } /// Calls `tcx.$query(key)` for this query, and discards the returned value. @@ -245,13 +231,10 @@ pub fn query_system<'tcx>( incremental: bool, ) -> QuerySystem<'tcx> { QuerySystem { - states: Default::default(), arenas: Default::default(), - caches: Default::default(), - query_vtables: make_query_vtables(), + query_vtables: make_query_vtables(incremental), on_disk_cache, fns: QuerySystemFns { - engine: engine(incremental), local_providers, extern_providers, encode_query_results: encode_all_query_results, diff --git a/compiler/rustc_query_impl/src/plumbing.rs b/compiler/rustc_query_impl/src/plumbing.rs index 5981e7e0f5269..80aef9428733c 100644 --- a/compiler/rustc_query_impl/src/plumbing.rs +++ b/compiler/rustc_query_impl/src/plumbing.rs @@ -15,7 +15,7 @@ use rustc_middle::bug; #[expect(unused_imports, reason = "used by doc comments")] use rustc_middle::dep_graph::DepKindVTable; use rustc_middle::dep_graph::{ - self, DepNode, DepNodeIndex, DepNodeKey, SerializedDepNodeIndex, dep_kinds, + self, DepKind, DepNode, DepNodeIndex, DepNodeKey, SerializedDepNodeIndex, dep_kinds, }; use rustc_middle::query::on_disk_cache::{ AbsoluteBytePos, CacheDecoder, CacheEncoder, EncodedDepNodeIndex, @@ -123,7 +123,7 @@ pub fn collect_active_jobs_from_all_queries<'tcx>( if complete { Ok(job_map_out) } else { Err(job_map_out) } } -pub(super) fn try_mark_green<'tcx>(tcx: TyCtxt<'tcx>, dep_node: &dep_graph::DepNode) -> bool { +pub(super) fn try_mark_green<'tcx>(tcx: TyCtxt<'tcx>, dep_node: &DepNode) -> bool { tcx.dep_graph.try_mark_green(tcx, dep_node).is_some() } @@ -273,12 +273,17 @@ macro_rules! item_if_cache_on_disk { } /// The deferred part of a deferred query stack frame. -fn mk_query_stack_frame_extra<'tcx, Cache>( - (tcx, vtable, key): (TyCtxt<'tcx>, &'tcx QueryVTable<'tcx, Cache>, Cache::Key), +fn mk_query_stack_frame_extra<'tcx, K>( + (tcx, name, dep_kind, description_fn, key): ( + TyCtxt<'tcx>, + &'static str, + DepKind, + fn(TyCtxt<'tcx>, K) -> String, + K, + ), ) -> QueryStackFrameExtra where - Cache: QueryCache, - Cache::Key: Key, + K: Key + Copy, { let def_id = key.key_as_def_id(); @@ -287,13 +292,13 @@ where let reduce_queries = with_reduced_queries(); // Avoid calling queries while formatting the description - let description = ty::print::with_no_queries!((vtable.description_fn)(tcx, key)); + let description = ty::print::with_no_queries!(description_fn(tcx, key)); let description = if tcx.sess.verbose_internals() { - format!("{description} [{name:?}]", name = vtable.name) + format!("{description} [{name:?}]") } else { description }; - let span = if vtable.dep_kind == dep_graph::dep_kinds::def_span || reduce_queries { + let span = if dep_kind == dep_graph::dep_kinds::def_span || reduce_queries { // The `def_span` query is used to calculate `default_span`, // so exit to avoid infinite recursion. None @@ -301,7 +306,7 @@ where Some(key.default_span(tcx)) }; - let def_kind = if vtable.dep_kind == dep_graph::dep_kinds::def_kind || reduce_queries { + let def_kind = if dep_kind == dep_graph::dep_kinds::def_kind || reduce_queries { // Try to avoid infinite recursion. None } else { @@ -310,14 +315,14 @@ where QueryStackFrameExtra::new(description, span, def_kind) } -pub(crate) fn create_deferred_query_stack_frame<'tcx, Cache>( +pub(crate) fn create_deferred_query_stack_frame<'tcx, C>( tcx: TyCtxt<'tcx>, - vtable: &'tcx QueryVTable<'tcx, Cache>, - key: Cache::Key, + vtable: &'tcx QueryVTable<'tcx, C>, + key: C::Key, ) -> QueryStackFrame> where - Cache: QueryCache, - Cache::Key: Key + DynSend + DynSync, + C: QueryCache, + C::Key: Key + DynSend + DynSync, { let kind = vtable.dep_kind; @@ -331,7 +336,10 @@ where let def_id: Option = key.key_as_def_id(); let def_id_for_ty_in_cycle: Option = key.def_id_for_ty_in_cycle(); - let info = QueryStackDeferred::new((tcx, vtable, key), mk_query_stack_frame_extra); + let info = QueryStackDeferred::new( + (tcx, vtable.name, vtable.dep_kind, vtable.description_fn, key), + mk_query_stack_frame_extra, + ); QueryStackFrame::new(info, kind, hash, def_id, def_id_for_ty_in_cycle) } @@ -346,9 +354,8 @@ pub(crate) fn encode_query_results<'a, 'tcx, Q, C: QueryCache, const FLAGS: Quer { let _timer = tcx.prof.generic_activity_with_arg("encode_query_results_for", query.name()); - assert!(all_inactive(query.query_state(tcx))); - let cache = query.query_cache(tcx); - cache.iter(&mut |key, value, dep_node| { + assert!(all_inactive(query.query_state())); + query.query_cache().iter(&mut |key, value, dep_node| { if query.will_cache_on_disk_for_key(tcx, key) { let dep_node = SerializedDepNodeIndex::new(dep_node.index()); @@ -368,7 +375,7 @@ pub(crate) fn query_key_hash_verify<'tcx, C: QueryCache, const FLAGS: QueryFlags ) { let _timer = tcx.prof.generic_activity_with_arg("query_key_hash_verify_for", query.name()); - let cache = query.query_cache(tcx); + let cache = query.query_cache(); let mut map = UnordMap::with_capacity(cache.len()); cache.iter(&mut |key, _, _| { let node = DepNode::construct(tcx, query.dep_kind(), key); @@ -561,7 +568,7 @@ macro_rules! define_queries { } } - pub(crate) fn make_query_vtable<'tcx>() + pub(crate) fn make_query_vtable<'tcx>(incremental: bool) -> QueryVTable<'tcx, queries::$name::Storage<'tcx>> { QueryVTable { @@ -569,8 +576,8 @@ macro_rules! define_queries { eval_always: is_eval_always!([$($modifiers)*]), dep_kind: dep_graph::dep_kinds::$name, cycle_error_handling: cycle_error_handling!([$($modifiers)*]), - query_state: std::mem::offset_of!(QueryStates<'tcx>, $name), - query_cache: std::mem::offset_of!(QueryCaches<'tcx>, $name), + query_state: Default::default(), + query_cache: Default::default(), will_cache_on_disk_for_key_fn: if_cache_on_disk!([$($modifiers)*] { Some(::rustc_middle::queries::_cache_on_disk_if_fns::$name) } { @@ -613,6 +620,11 @@ macro_rules! define_queries { hash_result: hash_result!([$($modifiers)*][queries::$name::Value<'tcx>]), format_value: |value| format!("{:?}", erase::restore_val::>(*value)), description_fn: $crate::queries::_description_fns::$name, + execute_query_fn: if incremental { + query_impl::$name::get_query_incr::__rust_end_short_backtrace + } else { + query_impl::$name::get_query_non_incr::__rust_end_short_backtrace + }, } } @@ -665,7 +677,8 @@ macro_rules! define_queries { }; // 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 = crate::execution::gather_active_jobs_inner( + &tcx.query_system.query_vtables.$name.query_state, tcx, make_frame, require_complete, @@ -691,7 +704,7 @@ macro_rules! define_queries { $crate::profiling_support::alloc_self_profile_query_strings_for_query_cache( tcx, stringify!($name), - &tcx.query_system.caches.$name, + &tcx.query_system.query_vtables.$name.query_cache, string_cache, ) } @@ -723,22 +736,10 @@ macro_rules! define_queries { } })*} - pub(crate) fn engine(incremental: bool) -> QueryEngine { - if incremental { - QueryEngine { - $($name: query_impl::$name::get_query_incr::__rust_end_short_backtrace,)* - } - } else { - QueryEngine { - $($name: query_impl::$name::get_query_non_incr::__rust_end_short_backtrace,)* - } - } - } - - pub fn make_query_vtables<'tcx>() -> queries::PerQueryVTables<'tcx> { + pub fn make_query_vtables<'tcx>(incremental: bool) -> queries::PerQueryVTables<'tcx> { queries::PerQueryVTables { $( - $name: query_impl::$name::make_query_vtable(), + $name: query_impl::$name::make_query_vtable(incremental), )* } }