Rename several parts of active-query-job collection

Author: Zalathar

compiler/rustc_interface/src/util.rs

@@ -244,12 +244,12 @@ pub(crate) fn run_in_thread_pool_with_globals<
                             tls::with(|tcx| {
                                 // Accessing session globals is sound as they outlive `GlobalCtxt`.
                                 // They are needed to hash query keys containing spans or symbols.
-                                let query_map = rustc_span::set_session_globals_then(unsafe { &*(session_globals as *const SessionGlobals) }, || {
+                                let job_map = rustc_span::set_session_globals_then(unsafe { &*(session_globals as *const SessionGlobals) }, || {
                                     // Ensure there was no errors collecting all active jobs.
                                     // We need the complete map to ensure we find a cycle to break.
-                                    QueryCtxt::new(tcx).collect_active_jobs(false).expect("failed to collect active queries in deadlock handler")
+                                    QueryCtxt::new(tcx).collect_active_jobs_from_all_queries(false).expect("failed to collect active queries in deadlock handler")
                                 });
-                                break_query_cycles(query_map, &registry);
+                                break_query_cycles(job_map, &registry);
                             })
                         })
                     });

compiler/rustc_query_impl/src/lib.rs

@@ -20,7 +20,7 @@ use rustc_query_system::Value;
 use rustc_query_system::dep_graph::SerializedDepNodeIndex;
 use rustc_query_system::ich::StableHashingContext;
 use rustc_query_system::query::{
-    CycleError, CycleErrorHandling, HashResult, QueryCache, QueryDispatcher, QueryMap, QueryMode,
+    CycleError, CycleErrorHandling, HashResult, JobMap, QueryCache, QueryDispatcher, QueryMode,
     QueryState, get_query_incr, get_query_non_incr,
 };
 use rustc_span::{ErrorGuaranteed, Span};

compiler/rustc_query_impl/src/plumbing.rs

@@ -27,7 +27,7 @@ use rustc_middle::ty::{self, TyCtxt};
 use rustc_query_system::dep_graph::{DepNodeParams, HasDepContext};
 use rustc_query_system::ich::StableHashingContext;
 use rustc_query_system::query::{
-    QueryCache, QueryContext, QueryDispatcher, QueryJobId, QueryMap, QuerySideEffect,
+    JobMap, QueryCache, QueryContext, QueryDispatcher, QueryJobId, QuerySideEffect,
     QueryStackDeferred, QueryStackFrame, QueryStackFrameExtra, force_query,
 };
 use rustc_query_system::{QueryOverflow, QueryOverflowNote};
@@ -81,7 +81,7 @@ impl<'tcx> QueryContext<'tcx> for QueryCtxt<'tcx> {
         tls::with_related_context(self.tcx, |icx| icx.query)
     }
 
-    /// Returns a map of currently active query jobs.
+    /// Returns a map of currently active query jobs, collected from all queries.
     ///
     /// If `require_complete` is `true`, this function locks all shards of the
     /// query results to produce a complete map, which always returns `Ok`.
@@ -91,17 +91,20 @@ impl<'tcx> QueryContext<'tcx> for QueryCtxt<'tcx> {
     /// Prefer passing `false` to `require_complete` to avoid potential deadlocks,
     /// especially when called from within a deadlock handler, unless a
     /// complete map is needed and no deadlock is possible at this call site.
-    fn collect_active_jobs(self, require_complete: bool) -> Result<QueryMap<'tcx>, QueryMap<'tcx>> {
-        let mut jobs = QueryMap::default();
+    fn collect_active_jobs_from_all_queries(
+        self,
+        require_complete: bool,
+    ) -> Result<JobMap<'tcx>, JobMap<'tcx>> {
+        let mut job_map = JobMap::default();
         let mut complete = true;
 
-        for collect in super::COLLECT_ACTIVE_JOBS.iter() {
-            if collect(self.tcx, &mut jobs, require_complete).is_none() {
+        for gather_fn in crate::PER_QUERY_GATHER_ACTIVE_JOBS_FNS.iter() {
+            if gather_fn(self.tcx, &mut job_map, require_complete).is_none() {
                 complete = false;
             }
         }
 
-        if complete { Ok(jobs) } else { Err(jobs) }
+        if complete { Ok(job_map) } else { Err(job_map) }
     }
 
     fn lift_query_info(
@@ -164,18 +167,20 @@ impl<'tcx> QueryContext<'tcx> for QueryCtxt<'tcx> {
     }
 
     fn depth_limit_error(self, job: QueryJobId) {
-        let query_map = self.collect_active_jobs(true).expect("failed to collect active queries");
-        let (info, depth) = job.find_dep_kind_root(query_map);
+        let job_map = self
+            .collect_active_jobs_from_all_queries(true)
+            .expect("failed to collect active queries");
+        let (job_info, depth) = job.find_dep_kind_root(job_map);
 
         let suggested_limit = match self.tcx.recursion_limit() {
             Limit(0) => Limit(2),
             limit => limit * 2,
         };
 
         self.tcx.sess.dcx().emit_fatal(QueryOverflow {
-            span: info.job.span,
+            span: job_info.job.span,
             note: QueryOverflowNote {
-                desc: self.lift_query_info(&info.query.info).description,
+                desc: self.lift_query_info(&job_info.deferred_frame.info).description,
                 depth,
             },
             suggested_limit,
@@ -356,7 +361,7 @@ fn mk_query_stack_frame_extra<'tcx, K: Key + Copy + 'tcx>(
     QueryStackFrameExtra::new(description, span, def_kind)
 }
 
-pub(crate) fn create_query_frame<
+pub(crate) fn mk_deferred_query_stack_frame<
     'tcx,
     K: Copy + DynSend + DynSync + Key + for<'a> HashStable<StableHashingContext<'a>> + 'tcx,
 >(
@@ -733,20 +738,28 @@ macro_rules! define_queries {
                 }
             }
 
-            pub(crate) fn collect_active_jobs<'tcx>(
+            /// Internal per-query plumbing for collecting the set of active jobs for this query.
+            ///
+            /// Should only be called through `PER_QUERY_GATHER_ACTIVE_JOBS_FNS`.
+            pub(crate) fn gather_active_jobs_outer<'tcx>(
                 tcx: TyCtxt<'tcx>,
-                qmap: &mut QueryMap<'tcx>,
+                job_map: &mut JobMap<'tcx>,
                 require_complete: bool,
             ) -> Option<()> {
-                let make_query = |tcx, key| {
-                    let kind = rustc_middle::dep_graph::dep_kinds::$name;
-                    let name = stringify!($name);
-                    $crate::plumbing::create_query_frame(tcx, rustc_middle::query::descs::$name, key, kind, name)
+                let mk_deferred_frame_fn = |tcx, key| {
+                    $crate::plumbing::mk_deferred_query_stack_frame(
+                        tcx,
+                        rustc_middle::query::descs::$name,
+                        key,
+                        rustc_middle::dep_graph::dep_kinds::$name,
+                        stringify!($name),
+                    )
                 };
-                let res = tcx.query_system.states.$name.collect_active_jobs(
+                // We can call `gather_active_jobs_inner` here.
+                let res = tcx.query_system.states.$name.gather_active_jobs_inner(
                     tcx,
-                    make_query,
-                    qmap,
+                    mk_deferred_frame_fn,
+                    job_map,
                     require_complete,
                 );
                 // this can be called during unwinding, and the function has a `try_`-prefix, so
@@ -818,10 +831,17 @@ macro_rules! define_queries {
 
         // These arrays are used for iteration and can't be indexed by `DepKind`.
 
-        const COLLECT_ACTIVE_JOBS: &[
-            for<'tcx> fn(TyCtxt<'tcx>, &mut QueryMap<'tcx>, bool) -> Option<()>
-        ] =
-            &[$(query_impl::$name::collect_active_jobs),*];
+        /// Used by [`QueryCtxt::collect_active_jobs_from_all_queries`] to iterate over all
+        /// queries, and gather the active jobs for each query.
+        ///
+        /// (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: &[
+            for<'tcx> fn(TyCtxt<'tcx>, &mut JobMap<'tcx>, require_complete: bool) -> Option<()>
+        ] = &[
+            $(query_impl::$name::gather_active_jobs_outer),*
+        ];
 
         const ALLOC_SELF_PROFILE_QUERY_STRINGS: &[
             for<'tcx> fn(TyCtxt<'tcx>, &mut QueryKeyStringCache)