(EXPERIMENT) Expand to a series of named function calls

Author: Zalathar

compiler/rustc_query_impl/src/execution.rs

@@ -47,12 +47,14 @@ pub fn collect_active_jobs_from_all_queries<'tcx>(
     let mut job_map_out = QueryJobMap::default();
     let mut complete = true;
 
-    for_each_query_vtable!(ALL, tcx, |query| {
-        let res = gather_active_jobs(query, tcx, require_complete, &mut job_map_out);
-        if res.is_none() {
-            complete = false;
-        }
-    });
+    for_each_query_vtable!(
+        gather_active_jobs,
+        tcx,
+        ALL_QUERIES,
+        require_complete,
+        &mut job_map_out,
+        &mut complete,
+    );
 
     if complete { Ok(job_map_out) } else { Err(job_map_out) }
 }
@@ -65,12 +67,12 @@ pub fn collect_active_jobs_from_all_queries<'tcx>(
 /// each individual query, so that we have distinct function names to
 /// grep for.)
 fn gather_active_jobs<'tcx, C>(
-    query: &'tcx QueryVTable<'tcx, C>,
     tcx: TyCtxt<'tcx>,
+    query: &'tcx QueryVTable<'tcx, C>,
     require_complete: bool,
     job_map_out: &mut QueryJobMap<'tcx>, // Out-param; job info is gathered into this map
-) -> Option<()>
-where
+    complete: &mut bool, // Out-param; set to false if `try_lock` fails for any shard
+) where
     C: QueryCache<Key: QueryKey + DynSend + DynSync>,
     QueryVTable<'tcx, C>: DynSync,
 {
@@ -103,7 +105,8 @@ where
                         "Failed to collect active jobs for query with name `{}`!",
                         query.name
                     );
-                    return None;
+                    *complete = false;
+                    return;
                 }
                 Some(shard) => gather_shard_jobs(&shard),
             }
@@ -116,8 +119,6 @@ where
         let frame = crate::plumbing::create_deferred_query_stack_frame(tcx, query, key);
         job_map_out.insert(job.id, QueryJobInfo { frame, job });
     }
-
-    Some(())
 }
 
 #[cold]

compiler/rustc_query_impl/src/lib.rs

@@ -3,6 +3,7 @@
 // tidy-alphabetical-start
 #![allow(internal_features)]
 #![feature(core_intrinsics)]
+#![feature(macro_metavar_expr)]
 #![feature(min_specialization)]
 #![feature(rustc_attrs)]
 #![feature(try_blocks)]

compiler/rustc_query_impl/src/plumbing.rs

@@ -151,9 +151,13 @@ pub(crate) fn encode_all_query_results<'tcx>(
     encoder: &mut CacheEncoder<'_, 'tcx>,
     query_result_index: &mut EncodedDepNodeIndex,
 ) {
-    for_each_query_vtable!(CACHE_ON_DISK, tcx, |query| {
-        encode_query_results(tcx, query, encoder, query_result_index)
-    });
+    for_each_query_vtable!(
+        encode_query_results,
+        tcx,
+        CACHE_ON_DISK_QUERIES,
+        encoder,
+        query_result_index,
+    );
 }
 
 fn encode_query_results<'a, 'tcx, C, V>(
@@ -185,16 +189,14 @@ fn encode_query_results<'a, 'tcx, C, V>(
 pub(crate) fn query_key_hash_verify_all<'tcx>(tcx: TyCtxt<'tcx>) {
     if tcx.sess.opts.unstable_opts.incremental_verify_ich || cfg!(debug_assertions) {
         tcx.sess.time("query_key_hash_verify_all", || {
-            for_each_query_vtable!(ALL, tcx, |query| {
-                query_key_hash_verify(query, tcx);
-            });
+            for_each_query_vtable!(query_key_hash_verify, tcx, ALL_QUERIES)
         });
     }
 }
 
 fn query_key_hash_verify<'tcx, C: QueryCache>(
-    query: &'tcx QueryVTable<'tcx, C>,
     tcx: TyCtxt<'tcx>,
+    query: &'tcx QueryVTable<'tcx, C>,
 ) {
     let _timer = tcx.prof.generic_activity_with_arg("query_key_hash_verify_for", query.name);
 
@@ -532,10 +534,15 @@ macro_rules! define_queries {
             }
         }
 
-        /// Given a filter condition (e.g. `ALL` or `CACHE_ON_DISK`), a `tcx`,
-        /// and a closure expression that accepts `&QueryVTable`, this macro
-        /// calls that closure with each query vtable that satisfies the filter
-        /// condition.
+        /// Given a function name, a `tcx`, and a filter condition
+        /// (e.g. `ALL_QUERIES` or `CACHE_ON_DISK_QUERIES`),
+        /// this macro calls that function with each query vtable that satisfies
+        /// the filter condition.
+        ///
+        /// The arguments passed to each function call are:
+        /// - `tcx`
+        /// - A query vtable that satisfies the filter condition
+        /// - All other arguments given after the filter condition
         ///
         /// This needs to be a macro, because the vtables can have different
         /// key/value/cache types for different queries.
@@ -548,30 +555,32 @@ macro_rules! define_queries {
         /// implemented by hand as needed.
         macro_rules! for_each_query_vtable {
             // Call with all queries.
-            (ALL, $tcx:expr, $closure:expr) => {{
+            ($inner_fn:expr, $tcx:expr, ALL_QUERIES $$(,$args:expr)* $$(,)?) => {{
                 let tcx: rustc_middle::ty::TyCtxt<'_> = $tcx;
                 $(
-                    let query: &rustc_middle::query::plumbing::QueryVTable<'_, _> =
-                        &tcx.query_system.query_vtables.$name;
-                    $closure(query);
+                    $inner_fn(
+                        tcx,
+                        &tcx.query_system.query_vtables.$name,
+                        $$($args),*
+                    );
                 )*
             }};
 
             // Only call with queries that can potentially cache to disk.
             //
             // This allows the use of trait bounds that only need to be satisfied
             // by the subset of queries that actually cache to disk.
-            (CACHE_ON_DISK, $tcx:expr, $closure:expr) => {{
+            ($inner_fn:expr, $tcx:expr, CACHE_ON_DISK_QUERIES $$(,$args:expr)* $$(,)?) => {{
                 let tcx: rustc_middle::ty::TyCtxt<'_> = $tcx;
                 $(
                     #[cfg($cache_on_disk)]
-                    {
-                        let query: &rustc_middle::query::plumbing::QueryVTable<'_, _> =
-                            &tcx.query_system.query_vtables.$name;
-                        $closure(query);
-                    }
+                    $inner_fn(
+                        tcx,
+                        &tcx.query_system.query_vtables.$name,
+                        $$($args),*
+                    );
                 )*
-            }}
+            }};
         }
 
         pub(crate) use for_each_query_vtable;

compiler/rustc_query_impl/src/profiling_support.rs

@@ -191,9 +191,12 @@ pub(crate) fn alloc_self_profile_query_strings(tcx: TyCtxt<'_>) {
 
     let mut string_cache = QueryKeyStringCache::new();
 
-    for_each_query_vtable!(ALL, tcx, |query| {
-        alloc_self_profile_query_strings_for_query_cache(tcx, query, &mut string_cache);
-    });
+    for_each_query_vtable!(
+        alloc_self_profile_query_strings_for_query_cache,
+        tcx,
+        ALL_QUERIES,
+        &mut string_cache,
+    );
 
     tcx.sess.prof.store_query_cache_hits();
 }