1 //! The implementation of the query system itself. This defines the macros that
2 //! generate the actual methods on tcx which find and execute the provider,
3 //! manage the caches, and so forth.
6 use crate::{on_disk_cache, Queries};
7 use rustc_middle::dep_graph::{self, DepKind, DepNodeIndex, SerializedDepNodeIndex};
8 use rustc_middle::ty::tls::{self, ImplicitCtxt};
9 use rustc_middle::ty::{self, TyCtxt};
10 use rustc_query_system::dep_graph::HasDepContext;
11 use rustc_query_system::ich::StableHashingContext;
12 use rustc_query_system::query::{
13 QueryContext, QueryJobId, QueryMap, QuerySideEffects, QueryStackFrame,
16 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
17 use rustc_data_structures::sync::Lock;
18 use rustc_data_structures::thin_vec::ThinVec;
19 use rustc_errors::{Diagnostic, Handler};
22 use std::num::NonZeroU64;
24 #[derive(Copy, Clone)]
25 pub struct QueryCtxt<'tcx> {
26 pub tcx: TyCtxt<'tcx>,
27 pub queries: &'tcx Queries<'tcx>,
30 impl<'tcx> std::ops::Deref for QueryCtxt<'tcx> {
31 type Target = TyCtxt<'tcx>;
34 fn deref(&self) -> &Self::Target {
39 impl<'tcx> HasDepContext for QueryCtxt<'tcx> {
40 type DepKind = rustc_middle::dep_graph::DepKind;
41 type DepContext = TyCtxt<'tcx>;
44 fn dep_context(&self) -> &Self::DepContext {
49 impl QueryContext for QueryCtxt<'_> {
50 fn next_job_id(&self) -> QueryJobId {
53 self.queries.jobs.fetch_add(1, rustc_data_structures::sync::Ordering::Relaxed),
59 fn current_query_job(&self) -> Option<QueryJobId> {
60 tls::with_related_context(**self, |icx| icx.query)
63 fn try_collect_active_jobs(&self) -> Option<QueryMap> {
64 self.queries.try_collect_active_jobs(**self)
67 // Interactions with on_disk_cache
68 fn load_side_effects(&self, prev_dep_node_index: SerializedDepNodeIndex) -> QuerySideEffects {
72 .map(|c| c.load_side_effects(**self, prev_dep_node_index))
76 fn store_side_effects(&self, dep_node_index: DepNodeIndex, side_effects: QuerySideEffects) {
77 if let Some(c) = self.queries.on_disk_cache.as_ref() {
78 c.store_side_effects(dep_node_index, side_effects)
82 fn store_side_effects_for_anon_node(
84 dep_node_index: DepNodeIndex,
85 side_effects: QuerySideEffects,
87 if let Some(c) = self.queries.on_disk_cache.as_ref() {
88 c.store_side_effects_for_anon_node(dep_node_index, side_effects)
92 /// Executes a job by changing the `ImplicitCtxt` to point to the
93 /// new query job while it executes. It returns the diagnostics
94 /// captured during execution and the actual result.
99 diagnostics: Option<&Lock<ThinVec<Diagnostic>>>,
100 compute: impl FnOnce() -> R,
102 // The `TyCtxt` stored in TLS has the same global interner lifetime
103 // as `self`, so we use `with_related_context` to relate the 'tcx lifetimes
104 // when accessing the `ImplicitCtxt`.
105 tls::with_related_context(**self, move |current_icx| {
106 // Update the `ImplicitCtxt` to point to our new query job.
107 let new_icx = ImplicitCtxt {
111 layout_depth: current_icx.layout_depth,
112 task_deps: current_icx.task_deps,
115 // Use the `ImplicitCtxt` while we execute the query.
116 tls::enter_context(&new_icx, |_| {
117 rustc_data_structures::stack::ensure_sufficient_stack(compute)
123 impl<'tcx> QueryCtxt<'tcx> {
125 pub fn from_tcx(tcx: TyCtxt<'tcx>) -> Self {
126 let queries = tcx.queries.as_any();
127 let queries = unsafe {
128 let queries = std::mem::transmute::<&dyn Any, &dyn Any>(queries);
129 let queries = queries.downcast_ref().unwrap();
130 let queries = std::mem::transmute::<&Queries<'_>, &Queries<'_>>(queries);
133 QueryCtxt { tcx, queries }
136 pub(crate) fn on_disk_cache(self) -> Option<&'tcx on_disk_cache::OnDiskCache<'tcx>> {
137 self.queries.on_disk_cache.as_ref()
140 pub(super) fn encode_query_results(
142 encoder: &mut on_disk_cache::CacheEncoder<'_, 'tcx>,
143 query_result_index: &mut on_disk_cache::EncodedDepNodeIndex,
145 macro_rules! encode_queries {
146 ($($query:ident,)*) => {
148 on_disk_cache::encode_query_results::<_, super::queries::$query<'_>>(
157 rustc_cached_queries!(encode_queries!);
160 pub fn try_print_query_stack(
162 query: Option<QueryJobId>,
164 num_frames: Option<usize>,
166 rustc_query_system::query::print_query_stack(self, query, handler, num_frames)
170 macro_rules! handle_cycle_error {
171 ([][$tcx: expr, $error:expr]) => {{
173 Value::from_cycle_error($tcx)
175 ([(fatal_cycle) $($rest:tt)*][$tcx:expr, $error:expr]) => {{
177 $tcx.sess.abort_if_errors();
180 ([(cycle_delay_bug) $($rest:tt)*][$tcx:expr, $error:expr]) => {{
181 $error.delay_as_bug();
182 Value::from_cycle_error($tcx)
184 ([$other:tt $($modifiers:tt)*][$($args:tt)*]) => {
185 handle_cycle_error!([$($modifiers)*][$($args)*])
189 macro_rules! is_anon {
193 ([(anon) $($rest:tt)*]) => {{
196 ([$other:tt $($modifiers:tt)*]) => {
197 is_anon!([$($modifiers)*])
201 macro_rules! is_eval_always {
205 ([(eval_always) $($rest:tt)*]) => {{
208 ([$other:tt $($modifiers:tt)*]) => {
209 is_eval_always!([$($modifiers)*])
213 macro_rules! hash_result {
215 Some(dep_graph::hash_result)
217 ([(no_hash) $($rest:tt)*]) => {{
220 ([$other:tt $($modifiers:tt)*]) => {
221 hash_result!([$($modifiers)*])
225 macro_rules! get_provider {
226 ([][$tcx:expr, $name:ident, $key:expr]) => {{
227 $tcx.queries.local_providers.$name
229 ([(separate_provide_extern) $($rest:tt)*][$tcx:expr, $name:ident, $key:expr]) => {{
230 if $key.query_crate_is_local() {
231 $tcx.queries.local_providers.$name
233 $tcx.queries.extern_providers.$name
236 ([$other:tt $($modifiers:tt)*][$($args:tt)*]) => {
237 get_provider!([$($modifiers)*][$($args)*])
241 pub(crate) fn create_query_frame<
243 K: Copy + Key + for<'a> HashStable<StableHashingContext<'a>>,
245 tcx: QueryCtxt<'tcx>,
246 do_describe: fn(QueryCtxt<'tcx>, K) -> String,
250 ) -> QueryStackFrame {
251 // Disable visible paths printing for performance reasons.
252 // Showing visible path instead of any path is not that important in production.
253 let description = ty::print::with_no_visible_paths!(
254 // Force filename-line mode to avoid invoking `type_of` query.
255 ty::print::with_forced_impl_filename_line!(do_describe(tcx, key))
258 if tcx.sess.verbose() { format!("{} [{}]", description, name) } else { description };
259 let span = if kind == dep_graph::DepKind::def_span {
260 // The `def_span` query is used to calculate `default_span`,
261 // so exit to avoid infinite recursion.
264 Some(key.default_span(*tcx))
266 let def_kind = if kind == dep_graph::DepKind::opt_def_kind {
267 // Try to avoid infinite recursion.
271 .and_then(|def_id| def_id.as_local())
272 .and_then(|def_id| tcx.opt_def_kind(def_id))
275 tcx.with_stable_hashing_context(|mut hcx| {
276 let mut hasher = StableHasher::new();
277 std::mem::discriminant(&kind).hash_stable(&mut hcx, &mut hasher);
278 key.hash_stable(&mut hcx, &mut hasher);
279 hasher.finish::<u64>()
283 QueryStackFrame::new(name, description, span, def_kind, hash)
286 // NOTE: `$V` isn't used here, but we still need to match on it so it can be passed to other macros
287 // invoked by `rustc_query_append`.
288 macro_rules! define_queries {
291 [$($modifiers:tt)*] fn $name:ident($($K:tt)*) -> $V:ty,)*) => {
292 define_queries_struct! {
293 input: ($(([$($modifiers)*] [$($attr)*] [$name]))*)
299 // Create an eponymous constructor for each query.
300 $(#[allow(nonstandard_style)] $(#[$attr])*
301 pub fn $name<'tcx>(tcx: QueryCtxt<'tcx>, key: <queries::$name<'tcx> as QueryConfig>::Key) -> QueryStackFrame {
302 let kind = dep_graph::DepKind::$name;
303 let name = stringify!($name);
304 $crate::plumbing::create_query_frame(tcx, queries::$name::describe, key, kind, name)
308 #[allow(nonstandard_style)]
310 use std::marker::PhantomData;
312 $(pub struct $name<'tcx> {
313 data: PhantomData<&'tcx ()>
317 $(impl<'tcx> QueryConfig for queries::$name<'tcx> {
318 type Key = query_keys::$name<'tcx>;
319 type Value = query_values::$name<'tcx>;
320 type Stored = query_stored::$name<'tcx>;
321 const NAME: &'static str = stringify!($name);
324 impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for queries::$name<'tcx> {
325 rustc_query_description! { $name<'tcx> }
327 type Cache = query_storage::$name<'tcx>;
330 fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>
331 where QueryCtxt<'tcx>: 'a
337 fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cache
340 &tcx.query_caches.$name
344 fn make_vtable(tcx: QueryCtxt<'tcx>, key: &Self::Key) ->
345 QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>
347 let compute = get_provider!([$($modifiers)*][tcx, $name, key]);
348 let cache_on_disk = Self::cache_on_disk(tcx.tcx, key);
350 anon: is_anon!([$($modifiers)*]),
351 eval_always: is_eval_always!([$($modifiers)*]),
352 dep_kind: dep_graph::DepKind::$name,
353 hash_result: hash_result!([$($modifiers)*]),
354 handle_cycle_error: |tcx, mut error| handle_cycle_error!([$($modifiers)*][tcx, error]),
357 try_load_from_disk: Self::TRY_LOAD_FROM_DISK,
362 #[allow(nonstandard_style)]
363 mod query_callbacks {
365 use rustc_middle::dep_graph::DepNode;
366 use rustc_query_system::dep_graph::DepNodeParams;
367 use rustc_query_system::query::{force_query, QueryDescription};
368 use rustc_query_system::dep_graph::FingerprintStyle;
370 // We use this for most things when incr. comp. is turned off.
371 pub fn Null() -> DepKindStruct {
374 is_eval_always: false,
375 fingerprint_style: FingerprintStyle::Unit,
376 force_from_dep_node: Some(|_, dep_node| bug!("force_from_dep_node: encountered {:?}", dep_node)),
377 try_load_from_on_disk_cache: None,
381 // We use this for the forever-red node.
382 pub fn Red() -> DepKindStruct {
385 is_eval_always: false,
386 fingerprint_style: FingerprintStyle::Unit,
387 force_from_dep_node: Some(|_, dep_node| bug!("force_from_dep_node: encountered {:?}", dep_node)),
388 try_load_from_on_disk_cache: None,
392 pub fn TraitSelect() -> DepKindStruct {
395 is_eval_always: false,
396 fingerprint_style: FingerprintStyle::Unit,
397 force_from_dep_node: None,
398 try_load_from_on_disk_cache: None,
402 pub fn CompileCodegenUnit() -> DepKindStruct {
405 is_eval_always: false,
406 fingerprint_style: FingerprintStyle::Opaque,
407 force_from_dep_node: None,
408 try_load_from_on_disk_cache: None,
412 pub fn CompileMonoItem() -> DepKindStruct {
415 is_eval_always: false,
416 fingerprint_style: FingerprintStyle::Opaque,
417 force_from_dep_node: None,
418 try_load_from_on_disk_cache: None,
422 $(pub(crate) fn $name()-> DepKindStruct {
423 let is_anon = is_anon!([$($modifiers)*]);
424 let is_eval_always = is_eval_always!([$($modifiers)*]);
426 let fingerprint_style =
427 <<queries::$name<'_> as QueryConfig>::Key as DepNodeParams<TyCtxt<'_>>>::fingerprint_style();
429 if is_anon || !fingerprint_style.reconstructible() {
430 return DepKindStruct {
434 force_from_dep_node: None,
435 try_load_from_on_disk_cache: None,
440 fn recover<'tcx>(tcx: TyCtxt<'tcx>, dep_node: DepNode) -> Option<<queries::$name<'tcx> as QueryConfig>::Key> {
441 <<queries::$name<'_> as QueryConfig>::Key as DepNodeParams<TyCtxt<'_>>>::recover(tcx, &dep_node)
444 fn force_from_dep_node(tcx: TyCtxt<'_>, dep_node: DepNode) -> bool {
445 if let Some(key) = recover(tcx, dep_node) {
446 #[cfg(debug_assertions)]
447 let _guard = tracing::span!(tracing::Level::TRACE, stringify!($name), ?key).entered();
448 let tcx = QueryCtxt::from_tcx(tcx);
449 force_query::<queries::$name<'_>, _>(tcx, key, dep_node);
456 fn try_load_from_on_disk_cache(tcx: TyCtxt<'_>, dep_node: DepNode) {
457 debug_assert!(tcx.dep_graph.is_green(&dep_node));
459 let key = recover(tcx, dep_node).unwrap_or_else(|| panic!("Failed to recover key for {:?} with hash {}", dep_node, dep_node.hash));
460 if queries::$name::cache_on_disk(tcx, &key) {
461 let _ = tcx.$name(key);
469 force_from_dep_node: Some(force_from_dep_node),
470 try_load_from_on_disk_cache: Some(try_load_from_on_disk_cache),
475 pub fn query_callbacks<'tcx>(arena: &'tcx Arena<'tcx>) -> &'tcx [DepKindStruct] {
476 arena.alloc_from_iter(make_dep_kind_array!(query_callbacks))
481 macro_rules! define_queries_struct {
483 input: ($(([$($modifiers:tt)*] [$($attr:tt)*] [$name:ident]))*)) => {
484 pub struct Queries<'tcx> {
485 local_providers: Box<Providers>,
486 extern_providers: Box<ExternProviders>,
488 pub on_disk_cache: Option<OnDiskCache<'tcx>>,
492 $($(#[$attr])* $name: QueryState<<queries::$name<'tcx> as QueryConfig>::Key>,)*
495 impl<'tcx> Queries<'tcx> {
497 local_providers: Providers,
498 extern_providers: ExternProviders,
499 on_disk_cache: Option<OnDiskCache<'tcx>>,
502 local_providers: Box::new(local_providers),
503 extern_providers: Box::new(extern_providers),
505 jobs: AtomicU64::new(1),
506 $($name: Default::default()),*
510 pub(crate) fn try_collect_active_jobs(
513 ) -> Option<QueryMap> {
514 let tcx = QueryCtxt { tcx, queries: self };
515 let mut jobs = QueryMap::default();
518 self.$name.try_collect_active_jobs(
529 impl<'tcx> QueryEngine<'tcx> for Queries<'tcx> {
530 fn as_any(&'tcx self) -> &'tcx dyn std::any::Any {
531 let this = unsafe { std::mem::transmute::<&Queries<'_>, &Queries<'_>>(self) };
535 fn try_mark_green(&'tcx self, tcx: TyCtxt<'tcx>, dep_node: &dep_graph::DepNode) -> bool {
536 let qcx = QueryCtxt { tcx, queries: self };
537 tcx.dep_graph.try_mark_green(qcx, dep_node).is_some()
542 #[tracing::instrument(level = "trace", skip(self, tcx))]
547 key: <queries::$name<'tcx> as QueryConfig>::Key,
549 ) -> Option<query_stored::$name<'tcx>> {
550 let qcx = QueryCtxt { tcx, queries: self };
551 get_query::<queries::$name<'tcx>, _>(qcx, span, key, mode)