compiler/rustc_query_impl/src/plumbing.rs

   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.
   4
   5 use crate::keys::Key;
   6 use crate::on_disk_cache::CacheDecoder;
   7 use crate::{on_disk_cache, Queries};
   8 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
   9 use rustc_data_structures::sync::{AtomicU64, Lock};
  10 use rustc_errors::{Diagnostic, Handler};
  11 use rustc_middle::dep_graph::{
  12     self, DepKind, DepKindStruct, DepNode, DepNodeIndex, SerializedDepNodeIndex,
  13 };
  14 use rustc_middle::ty::tls::{self, ImplicitCtxt};
  15 use rustc_middle::ty::{self, TyCtxt};
  16 use rustc_query_system::dep_graph::{DepNodeParams, HasDepContext};
  17 use rustc_query_system::ich::StableHashingContext;
  18 use rustc_query_system::query::{
  19     force_query, QueryConfig, QueryContext, QueryDescription, QueryJobId, QueryMap,
  20     QuerySideEffects, QueryStackFrame,
  21 };
  22 use rustc_query_system::{LayoutOfDepth, QueryOverflow, Value};
  23 use rustc_serialize::Decodable;
  24 use rustc_session::Limit;
  25 use rustc_span::def_id::LOCAL_CRATE;
  26 use std::any::Any;
  27 use std::num::NonZeroU64;
  28 use thin_vec::ThinVec;
  29
  30 #[derive(Copy, Clone)]
  31 pub struct QueryCtxt<'tcx> {
  32     pub tcx: TyCtxt<'tcx>,
  33     pub queries: &'tcx Queries<'tcx>,
  34 }
  35
  36 impl<'tcx> std::ops::Deref for QueryCtxt<'tcx> {
  37     type Target = TyCtxt<'tcx>;
  38
  39     #[inline]
  40     fn deref(&self) -> &Self::Target {
  41         &self.tcx
  42     }
  43 }
  44
  45 impl<'tcx> HasDepContext for QueryCtxt<'tcx> {
  46     type DepKind = rustc_middle::dep_graph::DepKind;
  47     type DepContext = TyCtxt<'tcx>;
  48
  49     #[inline]
  50     fn dep_context(&self) -> &Self::DepContext {
  51         &self.tcx
  52     }
  53 }
  54
  55 impl QueryContext for QueryCtxt<'_> {
  56     fn next_job_id(&self) -> QueryJobId {
  57         QueryJobId(
  58             NonZeroU64::new(
  59                 self.queries.jobs.fetch_add(1, rustc_data_structures::sync::Ordering::Relaxed),
  60             )
  61             .unwrap(),
  62         )
  63     }
  64
  65     fn current_query_job(&self) -> Option<QueryJobId> {
  66         tls::with_related_context(**self, |icx| icx.query)
  67     }
  68
  69     fn try_collect_active_jobs(&self) -> Option<QueryMap> {
  70         self.queries.try_collect_active_jobs(**self)
  71     }
  72
  73     // Interactions with on_disk_cache
  74     fn load_side_effects(&self, prev_dep_node_index: SerializedDepNodeIndex) -> QuerySideEffects {
  75         self.queries
  76             .on_disk_cache
  77             .as_ref()
  78             .map(|c| c.load_side_effects(**self, prev_dep_node_index))
  79             .unwrap_or_default()
  80     }
  81
  82     fn store_side_effects(&self, dep_node_index: DepNodeIndex, side_effects: QuerySideEffects) {
  83         if let Some(c) = self.queries.on_disk_cache.as_ref() {
  84             c.store_side_effects(dep_node_index, side_effects)
  85         }
  86     }
  87
  88     fn store_side_effects_for_anon_node(
  89         &self,
  90         dep_node_index: DepNodeIndex,
  91         side_effects: QuerySideEffects,
  92     ) {
  93         if let Some(c) = self.queries.on_disk_cache.as_ref() {
  94             c.store_side_effects_for_anon_node(dep_node_index, side_effects)
  95         }
  96     }
  97
  98     /// Executes a job by changing the `ImplicitCtxt` to point to the
  99     /// new query job while it executes. It returns the diagnostics
 100     /// captured during execution and the actual result.
 101     #[inline(always)]
 102     fn start_query<R>(
 103         &self,
 104         token: QueryJobId,
 105         depth_limit: bool,
 106         diagnostics: Option<&Lock<ThinVec<Diagnostic>>>,
 107         compute: impl FnOnce() -> R,
 108     ) -> R {
 109         // The `TyCtxt` stored in TLS has the same global interner lifetime
 110         // as `self`, so we use `with_related_context` to relate the 'tcx lifetimes
 111         // when accessing the `ImplicitCtxt`.
 112         tls::with_related_context(**self, move |current_icx| {
 113             if depth_limit && !self.recursion_limit().value_within_limit(current_icx.query_depth) {
 114                 self.depth_limit_error(token);
 115             }
 116
 117             // Update the `ImplicitCtxt` to point to our new query job.
 118             let new_icx = ImplicitCtxt {
 119                 tcx: **self,
 120                 query: Some(token),
 121                 diagnostics,
 122                 query_depth: current_icx.query_depth + depth_limit as usize,
 123                 task_deps: current_icx.task_deps,
 124             };
 125
 126             // Use the `ImplicitCtxt` while we execute the query.
 127             tls::enter_context(&new_icx, |_| {
 128                 rustc_data_structures::stack::ensure_sufficient_stack(compute)
 129             })
 130         })
 131     }
 132
 133     fn depth_limit_error(&self, job: QueryJobId) {
 134         let mut span = None;
 135         let mut layout_of_depth = None;
 136         if let Some(map) = self.try_collect_active_jobs() {
 137             if let Some((info, depth)) = job.try_find_layout_root(map) {
 138                 span = Some(info.job.span);
 139                 layout_of_depth = Some(LayoutOfDepth { desc: info.query.description, depth });
 140             }
 141         }
 142
 143         let suggested_limit = match self.recursion_limit() {
 144             Limit(0) => Limit(2),
 145             limit => limit * 2,
 146         };
 147
 148         self.sess.emit_fatal(QueryOverflow {
 149             span,
 150             layout_of_depth,
 151             suggested_limit,
 152             crate_name: self.crate_name(LOCAL_CRATE),
 153         });
 154     }
 155 }
 156
 157 impl<'tcx> QueryCtxt<'tcx> {
 158     #[inline]
 159     pub fn from_tcx(tcx: TyCtxt<'tcx>) -> Self {
 160         let queries = tcx.queries.as_any();
 161         let queries = unsafe {
 162             let queries = std::mem::transmute::<&dyn Any, &dyn Any>(queries);
 163             let queries = queries.downcast_ref().unwrap();
 164             let queries = std::mem::transmute::<&Queries<'_>, &Queries<'_>>(queries);
 165             queries
 166         };
 167         QueryCtxt { tcx, queries }
 168     }
 169
 170     pub(crate) fn on_disk_cache(self) -> Option<&'tcx on_disk_cache::OnDiskCache<'tcx>> {
 171         self.queries.on_disk_cache.as_ref()
 172     }
 173
 174     pub(super) fn encode_query_results(
 175         self,
 176         encoder: &mut on_disk_cache::CacheEncoder<'_, 'tcx>,
 177         query_result_index: &mut on_disk_cache::EncodedDepNodeIndex,
 178     ) {
 179         macro_rules! expand_if_cached {
 180             ([] $encode:expr) => {};
 181             ([(cache) $($rest:tt)*] $encode:expr) => {
 182                 $encode
 183             };
 184             ([$other:tt $($modifiers:tt)*] $encode:expr) => {
 185                 expand_if_cached!([$($modifiers)*] $encode)
 186             };
 187         }
 188
 189         macro_rules! encode_queries {
 190             (
 191             $($(#[$attr:meta])*
 192                 [$($modifiers:tt)*] fn $query:ident($($K:tt)*) -> $V:ty,)*) => {
 193                 $(
 194                     expand_if_cached!([$($modifiers)*] on_disk_cache::encode_query_results::<_, super::queries::$query<'_>>(
 195                         self,
 196                         encoder,
 197                         query_result_index
 198                     ));
 199                 )*
 200             }
 201         }
 202
 203         rustc_query_append!(encode_queries!);
 204     }
 205
 206     pub fn try_print_query_stack(
 207         self,
 208         query: Option<QueryJobId>,
 209         handler: &Handler,
 210         num_frames: Option<usize>,
 211     ) -> usize {
 212         rustc_query_system::query::print_query_stack(self, query, handler, num_frames)
 213     }
 214 }
 215
 216 macro_rules! handle_cycle_error {
 217     ([]) => {{
 218         rustc_query_system::HandleCycleError::Error
 219     }};
 220     ([(fatal_cycle) $($rest:tt)*]) => {{
 221         rustc_query_system::HandleCycleError::Fatal
 222     }};
 223     ([(cycle_delay_bug) $($rest:tt)*]) => {{
 224         rustc_query_system::HandleCycleError::DelayBug
 225     }};
 226     ([$other:tt $($modifiers:tt)*]) => {
 227         handle_cycle_error!([$($modifiers)*])
 228     };
 229 }
 230
 231 macro_rules! is_anon {
 232     ([]) => {{
 233         false
 234     }};
 235     ([(anon) $($rest:tt)*]) => {{
 236         true
 237     }};
 238     ([$other:tt $($modifiers:tt)*]) => {
 239         is_anon!([$($modifiers)*])
 240     };
 241 }
 242
 243 macro_rules! is_eval_always {
 244     ([]) => {{
 245         false
 246     }};
 247     ([(eval_always) $($rest:tt)*]) => {{
 248         true
 249     }};
 250     ([$other:tt $($modifiers:tt)*]) => {
 251         is_eval_always!([$($modifiers)*])
 252     };
 253 }
 254
 255 macro_rules! depth_limit {
 256     ([]) => {{
 257         false
 258     }};
 259     ([(depth_limit) $($rest:tt)*]) => {{
 260         true
 261     }};
 262     ([$other:tt $($modifiers:tt)*]) => {
 263         depth_limit!([$($modifiers)*])
 264     };
 265 }
 266
 267 macro_rules! hash_result {
 268     ([]) => {{
 269         Some(dep_graph::hash_result)
 270     }};
 271     ([(no_hash) $($rest:tt)*]) => {{
 272         None
 273     }};
 274     ([$other:tt $($modifiers:tt)*]) => {
 275         hash_result!([$($modifiers)*])
 276     };
 277 }
 278
 279 macro_rules! get_provider {
 280     ([][$tcx:expr, $name:ident, $key:expr]) => {{
 281         $tcx.queries.local_providers.$name
 282     }};
 283     ([(separate_provide_extern) $($rest:tt)*][$tcx:expr, $name:ident, $key:expr]) => {{
 284         if $key.query_crate_is_local() {
 285             $tcx.queries.local_providers.$name
 286         } else {
 287             $tcx.queries.extern_providers.$name
 288         }
 289     }};
 290     ([$other:tt $($modifiers:tt)*][$($args:tt)*]) => {
 291         get_provider!([$($modifiers)*][$($args)*])
 292     };
 293 }
 294
 295 macro_rules! should_ever_cache_on_disk {
 296     ([]) => {{
 297         None
 298     }};
 299     ([(cache) $($rest:tt)*]) => {{
 300         Some($crate::plumbing::try_load_from_disk::<Self::Value>)
 301     }};
 302     ([$other:tt $($modifiers:tt)*]) => {
 303         should_ever_cache_on_disk!([$($modifiers)*])
 304     };
 305 }
 306
 307 pub(crate) fn create_query_frame<
 308     'tcx,
 309     K: Copy + Key + for<'a> HashStable<StableHashingContext<'a>>,
 310 >(
 311     tcx: QueryCtxt<'tcx>,
 312     do_describe: fn(QueryCtxt<'tcx>, K) -> String,
 313     key: K,
 314     kind: DepKind,
 315     name: &'static str,
 316 ) -> QueryStackFrame {
 317     // Disable visible paths printing for performance reasons.
 318     // Showing visible path instead of any path is not that important in production.
 319     let description = ty::print::with_no_visible_paths!(
 320         // Force filename-line mode to avoid invoking `type_of` query.
 321         ty::print::with_forced_impl_filename_line!(do_describe(tcx, key))
 322     );
 323     let description =
 324         if tcx.sess.verbose() { format!("{} [{}]", description, name) } else { description };
 325     let span = if kind == dep_graph::DepKind::def_span {
 326         // The `def_span` query is used to calculate `default_span`,
 327         // so exit to avoid infinite recursion.
 328         None
 329     } else {
 330         Some(key.default_span(*tcx))
 331     };
 332     let def_kind = if kind == dep_graph::DepKind::opt_def_kind {
 333         // Try to avoid infinite recursion.
 334         None
 335     } else {
 336         key.key_as_def_id()
 337             .and_then(|def_id| def_id.as_local())
 338             .and_then(|def_id| tcx.opt_def_kind(def_id))
 339     };
 340     let hash = || {
 341         tcx.with_stable_hashing_context(|mut hcx| {
 342             let mut hasher = StableHasher::new();
 343             std::mem::discriminant(&kind).hash_stable(&mut hcx, &mut hasher);
 344             key.hash_stable(&mut hcx, &mut hasher);
 345             hasher.finish::<u64>()
 346         })
 347     };
 348
 349     QueryStackFrame::new(name, description, span, def_kind, hash)
 350 }
 351
 352 fn try_load_from_on_disk_cache<'tcx, Q>(tcx: TyCtxt<'tcx>, dep_node: DepNode)
 353 where
 354     Q: QueryDescription<QueryCtxt<'tcx>>,
 355     Q::Key: DepNodeParams<TyCtxt<'tcx>>,
 356 {
 357     debug_assert!(tcx.dep_graph.is_green(&dep_node));
 358
 359     let key = Q::Key::recover(tcx, &dep_node).unwrap_or_else(|| {
 360         panic!("Failed to recover key for {:?} with hash {}", dep_node, dep_node.hash)
 361     });
 362     if Q::cache_on_disk(tcx, &key) {
 363         let _ = Q::execute_query(tcx, key);
 364     }
 365 }
 366
 367 pub(crate) fn try_load_from_disk<'tcx, V>(
 368     tcx: QueryCtxt<'tcx>,
 369     id: SerializedDepNodeIndex,
 370 ) -> Option<V>
 371 where
 372     V: for<'a> Decodable<CacheDecoder<'a, 'tcx>>,
 373 {
 374     tcx.on_disk_cache().as_ref()?.try_load_query_result(*tcx, id)
 375 }
 376
 377 fn force_from_dep_node<'tcx, Q>(tcx: TyCtxt<'tcx>, dep_node: DepNode) -> bool
 378 where
 379     Q: QueryDescription<QueryCtxt<'tcx>>,
 380     Q::Key: DepNodeParams<TyCtxt<'tcx>>,
 381     Q::Value: Value<TyCtxt<'tcx>>,
 382 {
 383     // We must avoid ever having to call `force_from_dep_node()` for a
 384     // `DepNode::codegen_unit`:
 385     // Since we cannot reconstruct the query key of a `DepNode::codegen_unit`, we
 386     // would always end up having to evaluate the first caller of the
 387     // `codegen_unit` query that *is* reconstructible. This might very well be
 388     // the `compile_codegen_unit` query, thus re-codegenning the whole CGU just
 389     // to re-trigger calling the `codegen_unit` query with the right key. At
 390     // that point we would already have re-done all the work we are trying to
 391     // avoid doing in the first place.
 392     // The solution is simple: Just explicitly call the `codegen_unit` query for
 393     // each CGU, right after partitioning. This way `try_mark_green` will always
 394     // hit the cache instead of having to go through `force_from_dep_node`.
 395     // This assertion makes sure, we actually keep applying the solution above.
 396     debug_assert!(
 397         dep_node.kind != DepKind::codegen_unit,
 398         "calling force_from_dep_node() on DepKind::codegen_unit"
 399     );
 400
 401     if let Some(key) = Q::Key::recover(tcx, &dep_node) {
 402         #[cfg(debug_assertions)]
 403         let _guard = tracing::span!(tracing::Level::TRACE, stringify!($name), ?key).entered();
 404         let tcx = QueryCtxt::from_tcx(tcx);
 405         force_query::<Q, _>(tcx, key, dep_node);
 406         true
 407     } else {
 408         false
 409     }
 410 }
 411
 412 pub(crate) fn query_callback<'tcx, Q: QueryConfig>(
 413     is_anon: bool,
 414     is_eval_always: bool,
 415 ) -> DepKindStruct<'tcx>
 416 where
 417     Q: QueryDescription<QueryCtxt<'tcx>>,
 418     Q::Key: DepNodeParams<TyCtxt<'tcx>>,
 419 {
 420     let fingerprint_style = Q::Key::fingerprint_style();
 421
 422     if is_anon || !fingerprint_style.reconstructible() {
 423         return DepKindStruct {
 424             is_anon,
 425             is_eval_always,
 426             fingerprint_style,
 427             force_from_dep_node: None,
 428             try_load_from_on_disk_cache: None,
 429         };
 430     }
 431
 432     DepKindStruct {
 433         is_anon,
 434         is_eval_always,
 435         fingerprint_style,
 436         force_from_dep_node: Some(force_from_dep_node::<Q>),
 437         try_load_from_on_disk_cache: Some(try_load_from_on_disk_cache::<Q>),
 438     }
 439 }
 440
 441 // NOTE: `$V` isn't used here, but we still need to match on it so it can be passed to other macros
 442 // invoked by `rustc_query_append`.
 443 macro_rules! define_queries {
 444     (
 445      $($(#[$attr:meta])*
 446         [$($modifiers:tt)*] fn $name:ident($($K:tt)*) -> $V:ty,)*) => {
 447         define_queries_struct! {
 448             input: ($(([$($modifiers)*] [$($attr)*] [$name]))*)
 449         }
 450
 451         #[allow(nonstandard_style)]
 452         mod queries {
 453             use std::marker::PhantomData;
 454
 455             $(pub struct $name<'tcx> {
 456                 data: PhantomData<&'tcx ()>
 457             })*
 458         }
 459
 460         $(impl<'tcx> QueryConfig for queries::$name<'tcx> {
 461             type Key = query_keys::$name<'tcx>;
 462             type Value = query_values::$name<'tcx>;
 463             type Stored = query_stored::$name<'tcx>;
 464             const NAME: &'static str = stringify!($name);
 465         }
 466
 467         impl<'tcx> QueryDescription<QueryCtxt<'tcx>> for queries::$name<'tcx> {
 468             rustc_query_description! { $name }
 469
 470             type Cache = query_storage::$name<'tcx>;
 471
 472             #[inline(always)]
 473             fn query_state<'a>(tcx: QueryCtxt<'tcx>) -> &'a QueryState<Self::Key>
 474                 where QueryCtxt<'tcx>: 'a
 475             {
 476                 &tcx.queries.$name
 477             }
 478
 479             #[inline(always)]
 480             fn query_cache<'a>(tcx: QueryCtxt<'tcx>) -> &'a Self::Cache
 481                 where 'tcx:'a
 482             {
 483                 &tcx.query_caches.$name
 484             }
 485
 486             #[inline]
 487             fn make_vtable(tcx: QueryCtxt<'tcx>, key: &Self::Key) ->
 488                 QueryVTable<QueryCtxt<'tcx>, Self::Key, Self::Value>
 489             {
 490                 let compute = get_provider!([$($modifiers)*][tcx, $name, key]);
 491                 let cache_on_disk = Self::cache_on_disk(tcx.tcx, key);
 492                 QueryVTable {
 493                     anon: is_anon!([$($modifiers)*]),
 494                     eval_always: is_eval_always!([$($modifiers)*]),
 495                     depth_limit: depth_limit!([$($modifiers)*]),
 496                     dep_kind: dep_graph::DepKind::$name,
 497                     hash_result: hash_result!([$($modifiers)*]),
 498                     handle_cycle_error: handle_cycle_error!([$($modifiers)*]),
 499                     compute,
 500                     try_load_from_disk: if cache_on_disk { should_ever_cache_on_disk!([$($modifiers)*]) } else { None },
 501                 }
 502             }
 503
 504             fn execute_query(tcx: TyCtxt<'tcx>, k: Self::Key) -> Self::Stored {
 505                 tcx.$name(k)
 506             }
 507         })*
 508
 509         #[allow(nonstandard_style)]
 510         mod query_callbacks {
 511             use super::*;
 512             use rustc_query_system::dep_graph::FingerprintStyle;
 513
 514             // We use this for most things when incr. comp. is turned off.
 515             pub fn Null<'tcx>() -> DepKindStruct<'tcx> {
 516                 DepKindStruct {
 517                     is_anon: false,
 518                     is_eval_always: false,
 519                     fingerprint_style: FingerprintStyle::Unit,
 520                     force_from_dep_node: Some(|_, dep_node| bug!("force_from_dep_node: encountered {:?}", dep_node)),
 521                     try_load_from_on_disk_cache: None,
 522                 }
 523             }
 524
 525             // We use this for the forever-red node.
 526             pub fn Red<'tcx>() -> DepKindStruct<'tcx> {
 527                 DepKindStruct {
 528                     is_anon: false,
 529                     is_eval_always: false,
 530                     fingerprint_style: FingerprintStyle::Unit,
 531                     force_from_dep_node: Some(|_, dep_node| bug!("force_from_dep_node: encountered {:?}", dep_node)),
 532                     try_load_from_on_disk_cache: None,
 533                 }
 534             }
 535
 536             pub fn TraitSelect<'tcx>() -> DepKindStruct<'tcx> {
 537                 DepKindStruct {
 538                     is_anon: true,
 539                     is_eval_always: false,
 540                     fingerprint_style: FingerprintStyle::Unit,
 541                     force_from_dep_node: None,
 542                     try_load_from_on_disk_cache: None,
 543                 }
 544             }
 545
 546             pub fn CompileCodegenUnit<'tcx>() -> DepKindStruct<'tcx> {
 547                 DepKindStruct {
 548                     is_anon: false,
 549                     is_eval_always: false,
 550                     fingerprint_style: FingerprintStyle::Opaque,
 551                     force_from_dep_node: None,
 552                     try_load_from_on_disk_cache: None,
 553                 }
 554             }
 555
 556             pub fn CompileMonoItem<'tcx>() -> DepKindStruct<'tcx> {
 557                 DepKindStruct {
 558                     is_anon: false,
 559                     is_eval_always: false,
 560                     fingerprint_style: FingerprintStyle::Opaque,
 561                     force_from_dep_node: None,
 562                     try_load_from_on_disk_cache: None,
 563                 }
 564             }
 565
 566             $(pub(crate) fn $name<'tcx>()-> DepKindStruct<'tcx> {
 567                 $crate::plumbing::query_callback::<queries::$name<'tcx>>(
 568                     is_anon!([$($modifiers)*]),
 569                     is_eval_always!([$($modifiers)*]),
 570                 )
 571             })*
 572         }
 573
 574         pub fn query_callbacks<'tcx>(arena: &'tcx Arena<'tcx>) -> &'tcx [DepKindStruct<'tcx>] {
 575             arena.alloc_from_iter(make_dep_kind_array!(query_callbacks))
 576         }
 577     }
 578 }
 579
 580 use crate::{ExternProviders, OnDiskCache, Providers};
 581
 582 impl<'tcx> Queries<'tcx> {
 583     pub fn new(
 584         local_providers: Providers,
 585         extern_providers: ExternProviders,
 586         on_disk_cache: Option<OnDiskCache<'tcx>>,
 587     ) -> Self {
 588         Queries {
 589             local_providers: Box::new(local_providers),
 590             extern_providers: Box::new(extern_providers),
 591             on_disk_cache,
 592             jobs: AtomicU64::new(1),
 593             ..Queries::default()
 594         }
 595     }
 596 }
 597
 598 macro_rules! define_queries_struct {
 599     (
 600      input: ($(([$($modifiers:tt)*] [$($attr:tt)*] [$name:ident]))*)) => {
 601         #[derive(Default)]
 602         pub struct Queries<'tcx> {
 603             local_providers: Box<Providers>,
 604             extern_providers: Box<ExternProviders>,
 605
 606             pub on_disk_cache: Option<OnDiskCache<'tcx>>,
 607
 608             jobs: AtomicU64,
 609
 610             $($(#[$attr])*  $name: QueryState<<queries::$name<'tcx> as QueryConfig>::Key>,)*
 611         }
 612
 613         impl<'tcx> Queries<'tcx> {
 614             pub(crate) fn try_collect_active_jobs(
 615                 &'tcx self,
 616                 tcx: TyCtxt<'tcx>,
 617             ) -> Option<QueryMap> {
 618                 let tcx = QueryCtxt { tcx, queries: self };
 619                 let mut jobs = QueryMap::default();
 620
 621                 $(
 622                     let make_query = |tcx, key| {
 623                         let kind = dep_graph::DepKind::$name;
 624                         let name = stringify!($name);
 625                         $crate::plumbing::create_query_frame(tcx, queries::$name::describe, key, kind, name)
 626                     };
 627                     self.$name.try_collect_active_jobs(
 628                         tcx,
 629                         make_query,
 630                         &mut jobs,
 631                     )?;
 632                 )*
 633
 634                 Some(jobs)
 635             }
 636         }
 637
 638         impl<'tcx> QueryEngine<'tcx> for Queries<'tcx> {
 639             fn as_any(&'tcx self) -> &'tcx dyn std::any::Any {
 640                 let this = unsafe { std::mem::transmute::<&Queries<'_>, &Queries<'_>>(self) };
 641                 this as _
 642             }
 643
 644             fn try_mark_green(&'tcx self, tcx: TyCtxt<'tcx>, dep_node: &dep_graph::DepNode) -> bool {
 645                 let qcx = QueryCtxt { tcx, queries: self };
 646                 tcx.dep_graph.try_mark_green(qcx, dep_node).is_some()
 647             }
 648
 649             $($(#[$attr])*
 650             #[inline(always)]
 651             #[tracing::instrument(level = "trace", skip(self, tcx), ret)]
 652             fn $name(
 653                 &'tcx self,
 654                 tcx: TyCtxt<'tcx>,
 655                 span: Span,
 656                 key: <queries::$name<'tcx> as QueryConfig>::Key,
 657                 mode: QueryMode,
 658             ) -> Option<query_stored::$name<'tcx>> {
 659                 let qcx = QueryCtxt { tcx, queries: self };
 660                 get_query::<queries::$name<'tcx>, _>(qcx, span, key, mode)
 661             })*
 662         }
 663     };
 664 }