Add a QueryKeyId to identify a query instance

Author: Zoxc

Cargo.lock

@@ -4458,7 +4458,6 @@ dependencies = [
  "rustc_macros",
  "rustc_middle",
  "rustc_serialize",
- "rustc_session",
  "rustc_span",
  "rustc_thread_pool",
  "tracing",

compiler/rustc_middle/src/query/job.rs

@@ -7,21 +7,15 @@ use parking_lot::{Condvar, Mutex};
 use rustc_span::Span;
 
 use crate::query::plumbing::CycleError;
-use crate::query::stack::{QueryStackDeferred, QueryStackFrame, QueryStackFrameExtra};
+use crate::query::stack::QueryStackFrame;
 use crate::ty::TyCtxt;
 
 /// Represents a span and a query key.
 #[derive(Clone, Debug)]
-pub struct QueryInfo<I> {
+pub struct QueryInfo<'tcx> {
     /// The span corresponding to the reason for which this query was required.
     pub span: Span,
-    pub frame: QueryStackFrame<I>,
-}
-
-impl<'tcx> QueryInfo<QueryStackDeferred<'tcx>> {
-    pub(crate) fn lift(&self) -> QueryInfo<QueryStackFrameExtra> {
-        QueryInfo { span: self.span, frame: self.frame.lift() }
-    }
+    pub frame: QueryStackFrame<'tcx>,
 }
 
 /// A value uniquely identifying an active query job.
@@ -74,7 +68,7 @@ pub struct QueryWaiter<'tcx> {
     pub query: Option<QueryJobId>,
     pub condvar: Condvar,
     pub span: Span,
-    pub cycle: Mutex<Option<CycleError<QueryStackDeferred<'tcx>>>>,
+    pub cycle: Mutex<Option<CycleError<'tcx>>>,
 }
 
 #[derive(Debug)]
@@ -101,7 +95,7 @@ impl<'tcx> QueryLatch<'tcx> {
         tcx: TyCtxt<'tcx>,
         query: Option<QueryJobId>,
         span: Span,
-    ) -> Result<(), CycleError<QueryStackDeferred<'tcx>>> {
+    ) -> Result<(), CycleError<'tcx>> {
         let waiter =
             Arc::new(QueryWaiter { query, span, cycle: Mutex::new(None), condvar: Condvar::new() });
         self.wait_on_inner(tcx, &waiter);

compiler/rustc_middle/src/query/mod.rs

@@ -7,7 +7,7 @@ pub use self::plumbing::{
     ActiveKeyStatus, CycleError, CycleErrorHandling, EnsureMode, IntoQueryParam, QueryMode,
     QueryState, TyCtxtAt, TyCtxtEnsureDone, TyCtxtEnsureOk,
 };
-pub use self::stack::{QueryStackDeferred, QueryStackFrame, QueryStackFrameExtra};
+pub use self::stack::QueryStackFrame;
 pub use crate::queries::Providers;
 use crate::ty::TyCtxt;
 

compiler/rustc_middle/src/query/plumbing.rs

@@ -15,7 +15,7 @@ use crate::dep_graph::{DepKind, DepNodeIndex, SerializedDepNodeIndex};
 use crate::ich::StableHashingContext;
 use crate::queries::{ExternProviders, Providers, QueryArenas, QueryVTables};
 use crate::query::on_disk_cache::OnDiskCache;
-use crate::query::stack::{QueryStackDeferred, QueryStackFrame, QueryStackFrameExtra};
+use crate::query::stack::QueryStackFrame;
 use crate::query::{QueryCache, QueryInfo, QueryJob};
 use crate::ty::TyCtxt;
 
@@ -62,19 +62,10 @@ pub enum CycleErrorHandling {
 }
 
 #[derive(Clone, Debug)]
-pub struct CycleError<I = QueryStackFrameExtra> {
+pub struct CycleError<'tcx> {
     /// The query and related span that uses the cycle.
-    pub usage: Option<(Span, QueryStackFrame<I>)>,
-    pub cycle: Vec<QueryInfo<I>>,
-}
-
-impl<'tcx> CycleError<QueryStackDeferred<'tcx>> {
-    pub fn lift(&self) -> CycleError<QueryStackFrameExtra> {
-        CycleError {
-            usage: self.usage.as_ref().map(|(span, frame)| (*span, frame.lift())),
-            cycle: self.cycle.iter().map(|info| info.lift()).collect(),
-        }
-    }
+    pub usage: Option<(Span, QueryStackFrame<'tcx>)>,
+    pub cycle: Vec<QueryInfo<'tcx>>,
 }
 
 #[derive(Debug)]
@@ -146,15 +137,9 @@ pub struct QueryVTable<'tcx, C: QueryCache> {
     pub hash_value_fn: Option<fn(&mut StableHashingContext<'_>, &C::Value) -> Fingerprint>,
 
     pub value_from_cycle_error:
-        fn(tcx: TyCtxt<'tcx>, cycle_error: CycleError, guar: ErrorGuaranteed) -> C::Value,
+        fn(tcx: TyCtxt<'tcx>, cycle_error: CycleError<'tcx>, guar: ErrorGuaranteed) -> C::Value,
     pub format_value: fn(&C::Value) -> String,
 
-    /// Formats a human-readable description of this query and its key, as
-    /// specified by the `desc` query modifier.
-    ///
-    /// Used when reporting query cycle errors and similar problems.
-    pub description_fn: fn(TyCtxt<'tcx>, C::Key) -> String,
-
     /// Function pointer that is called by the query methods on [`TyCtxt`] and
     /// friends[^1], after they have checked the in-memory cache and found no
     /// existing value for this key.
@@ -516,6 +501,67 @@ macro_rules! define_callbacks {
             }
         )*
 
+        /// Identifies a query by kind and key. This is in contrast to `QueryId` which is just a number.
+        #[allow(non_camel_case_types)]
+        #[derive(Clone, Debug)]
+        pub enum QueryKeyId<'tcx> {
+            $(
+                $name($name::Key<'tcx>),
+            )*
+        }
+
+        impl<'tcx> QueryKeyId<'tcx> {
+            /// Formats a human-readable description of this query and its key, as
+            /// specified by the `desc` query modifier.
+            ///
+            /// Used when reporting query cycle errors and similar problems.
+            pub fn description(&self, tcx: TyCtxt<'tcx>) -> String {
+                let (name, description) = ty::print::with_no_queries!(match self {
+                    $(
+                        QueryKeyId::$name(key) => (stringify!($name), _description_fns::$name(tcx, *key)),
+                    )*
+                });
+                if tcx.sess.verbose_internals() {
+                    format!("{description} [{name:?}]")
+                } else {
+                    description
+                }
+            }
+
+            /// Returns the default span for this query if `span` is a dummy span.
+            pub fn default_span(&self, tcx: TyCtxt<'tcx>, span: Span) -> Span {
+                if !span.is_dummy() {
+                    return span
+                }
+                if let QueryKeyId::def_span(..) = self {
+                    // The `def_span` query is used to calculate `default_span`,
+                    // so exit to avoid infinite recursion.
+                    return DUMMY_SP
+                }
+                match self {
+                    $(
+                        QueryKeyId::$name(key) => crate::query::QueryKey::default_span(key, tcx),
+                    )*
+                }
+            }
+
+            pub fn def_kind(&self, tcx: TyCtxt<'tcx>) -> Option<DefKind> {
+                fn inner<'tcx>(key: &impl crate::query::QueryKey, tcx: TyCtxt<'tcx>) -> Option<DefKind> {
+                    key.key_as_def_id().and_then(|def_id| def_id.as_local()).map(|def_id| tcx.def_kind(def_id))
+                }
+
+                if let QueryKeyId::def_kind(..) = self {
+                    // Try to avoid infinite recursion.
+                    return None
+                }
+                match self {
+                    $(
+                        QueryKeyId::$name(key) => inner(key, tcx),
+                    )*
+                }
+            }
+        }
+
         /// Holds a `QueryVTable` for each query.
         pub struct QueryVTables<'tcx> {
             $(

compiler/rustc_middle/src/query/stack.rs

@@ -1,106 +1,18 @@
 use std::fmt::Debug;
-use std::marker::PhantomData;
-use std::mem::transmute;
-use std::sync::Arc;
 
-use rustc_data_structures::sync::{DynSend, DynSync};
-use rustc_hir::def::DefKind;
-use rustc_span::Span;
 use rustc_span::def_id::DefId;
 
 use crate::dep_graph::DepKind;
+use crate::queries::QueryKeyId;
 
 /// Description of a frame in the query stack.
 ///
 /// This is mostly used in case of cycles for error reporting.
 #[derive(Clone, Debug)]
-pub struct QueryStackFrame<I> {
-    /// This field initially stores a `QueryStackDeferred` during collection,
-    /// but can later be changed to `QueryStackFrameExtra` containing concrete information
-    /// by calling `lift`. This is done so that collecting query does not need to invoke
-    /// queries, instead `lift` will call queries in a more appropriate location.
-    pub info: I,
-
+pub struct QueryStackFrame<'tcx> {
+    pub id: QueryKeyId<'tcx>,
     pub dep_kind: DepKind,
     pub def_id: Option<DefId>,
     /// A def-id that is extracted from a `Ty` in a query key
     pub def_id_for_ty_in_cycle: Option<DefId>,
 }
-
-impl<'tcx> QueryStackFrame<QueryStackDeferred<'tcx>> {
-    #[inline]
-    pub fn new(
-        info: QueryStackDeferred<'tcx>,
-        dep_kind: DepKind,
-        def_id: Option<DefId>,
-        def_id_for_ty_in_cycle: Option<DefId>,
-    ) -> Self {
-        Self { info, def_id, dep_kind, def_id_for_ty_in_cycle }
-    }
-
-    pub fn lift(&self) -> QueryStackFrame<QueryStackFrameExtra> {
-        QueryStackFrame {
-            info: self.info.extract(),
-            dep_kind: self.dep_kind,
-            def_id: self.def_id,
-            def_id_for_ty_in_cycle: self.def_id_for_ty_in_cycle,
-        }
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct QueryStackFrameExtra {
-    pub description: String,
-    pub span: Option<Span>,
-    pub def_kind: Option<DefKind>,
-}
-
-impl QueryStackFrameExtra {
-    #[inline]
-    pub fn new(description: String, span: Option<Span>, def_kind: Option<DefKind>) -> Self {
-        Self { description, span, def_kind }
-    }
-
-    // FIXME(eddyb) Get more valid `Span`s on queries.
-    #[inline]
-    pub fn default_span(&self, span: Span) -> Span {
-        if !span.is_dummy() {
-            return span;
-        }
-        self.span.unwrap_or(span)
-    }
-}
-
-/// Track a 'side effect' for a particular query.
-/// This is used to hold a closure which can create `QueryStackFrameExtra`.
-#[derive(Clone)]
-pub struct QueryStackDeferred<'tcx> {
-    _dummy: PhantomData<&'tcx ()>,
-
-    // `extract` may contain references to 'tcx, but we can't tell drop checking that it won't
-    // access it in the destructor.
-    extract: Arc<dyn Fn() -> QueryStackFrameExtra + DynSync + DynSend>,
-}
-
-impl<'tcx> QueryStackDeferred<'tcx> {
-    pub fn new<C: Copy + DynSync + DynSend + 'tcx>(
-        context: C,
-        extract: fn(C) -> QueryStackFrameExtra,
-    ) -> Self {
-        let extract: Arc<dyn Fn() -> QueryStackFrameExtra + DynSync + DynSend + 'tcx> =
-            Arc::new(move || extract(context));
-        // SAFETY: The `extract` closure does not access 'tcx in its destructor as the only
-        // captured variable is `context` which is Copy and cannot have a destructor.
-        Self { _dummy: PhantomData, extract: unsafe { transmute(extract) } }
-    }
-
-    pub fn extract(&self) -> QueryStackFrameExtra {
-        (self.extract)()
-    }
-}
-
-impl<'tcx> Debug for QueryStackDeferred<'tcx> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str("QueryStackDeferred")
-    }
-}

compiler/rustc_query_impl/Cargo.toml

@@ -14,7 +14,6 @@ rustc_index = { path = "../rustc_index" }
 rustc_macros = { path = "../rustc_macros" }
 rustc_middle = { path = "../rustc_middle" }
 rustc_serialize = { path = "../rustc_serialize" }
-rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
 rustc_thread_pool = { path = "../rustc_thread_pool" }
 tracing = "0.1"

compiler/rustc_query_impl/src/execution.rs

@@ -7,6 +7,7 @@ use rustc_data_structures::sync::{DynSend, DynSync};
 use rustc_data_structures::{outline, sharded, sync};
 use rustc_errors::{FatalError, StashKey};
 use rustc_middle::dep_graph::{DepGraphData, DepNodeKey, SerializedDepNodeIndex};
+use rustc_middle::queries::QueryKeyId;
 use rustc_middle::query::plumbing::QueryVTable;
 use rustc_middle::query::{
     ActiveKeyStatus, CycleError, CycleErrorHandling, EnsureMode, QueryCache, QueryJob, QueryJobId,
@@ -50,8 +51,8 @@ pub(crate) fn all_inactive<'tcx, K>(state: &QueryState<'tcx, K>) -> bool {
 /// grep for.)
 pub(crate) fn gather_active_jobs<'tcx, C>(
     query: &'tcx QueryVTable<'tcx, C>,
-    tcx: TyCtxt<'tcx>,
     require_complete: bool,
+    make_id: fn(C::Key) -> QueryKeyId<'tcx>,
     job_map_out: &mut QueryJobMap<'tcx>, // Out-param; job info is gathered into this map
 ) -> Option<()>
 where
@@ -97,7 +98,7 @@ where
     // Call `make_frame` while we're not holding a `state.active` lock as `make_frame` may call
     // queries leading to a deadlock.
     for (key, job) in active {
-        let frame = crate::plumbing::create_deferred_query_stack_frame(tcx, query, key);
+        let frame = crate::plumbing::create_query_stack_frame(query, key, make_id);
         job_map_out.insert(job.id, QueryJobInfo { frame, job });
     }
 
@@ -123,9 +124,9 @@ where
 fn mk_cycle<'tcx, C: QueryCache>(
     query: &'tcx QueryVTable<'tcx, C>,
     tcx: TyCtxt<'tcx>,
-    cycle_error: CycleError,
+    cycle_error: CycleError<'tcx>,
 ) -> C::Value {
-    let error = report_cycle(tcx.sess, &cycle_error);
+    let error = report_cycle(tcx, &cycle_error);
     match query.cycle_error_handling {
         CycleErrorHandling::Error => {
             let guar = error.emit();
@@ -137,7 +138,8 @@ fn mk_cycle<'tcx, C: QueryCache>(
         }
         CycleErrorHandling::Stash => {
             let guar = if let Some(root) = cycle_error.cycle.first()
-                && let Some(span) = root.frame.info.span
+                && let span = root.frame.id.default_span(tcx, DUMMY_SP)
+                && !span.is_dummy()
             {
                 error.stash(span, StashKey::Cycle).unwrap()
             } else {
@@ -225,7 +227,7 @@ fn cycle_error<'tcx, C: QueryCache>(
         .expect("failed to collect active queries");
 
     let error = find_cycle_in_stack(try_execute, job_map, &current_query_job(tcx), span);
-    (mk_cycle(query, tcx, error.lift()), None)
+    (mk_cycle(query, tcx, error), None)
 }
 
 #[inline(always)]
@@ -270,7 +272,7 @@ fn wait_for_query<'tcx, C: QueryCache>(
 
             (v, Some(index))
         }
-        Err(cycle) => (mk_cycle(query, tcx, cycle.lift()), None),
+        Err(cycle) => (mk_cycle(query, tcx, cycle), None),
     }
 }