Make rustc_with_all_queries! pass query modifiers as named values

Author: Zalathar

compiler/rustc_macros/src/query.rs

@@ -1,6 +1,6 @@
 use proc_macro::TokenStream;
 use proc_macro2::Span;
-use quote::{quote, quote_spanned};
+use quote::quote;
 use syn::parse::{Parse, ParseStream, Result};
 use syn::punctuated::Punctuated;
 use syn::spanned::Spanned;
@@ -315,51 +315,13 @@ pub(super) fn rustc_queries(input: TokenStream) -> TokenStream {
             ReturnType::Type(..) => quote! { #return_ty },
         };
 
-        let mut modifiers_out = vec![];
-
-        macro_rules! passthrough {
-            ( $( $modifier:ident ),+ $(,)? ) => {
-                $( if let Some($modifier) = &modifiers.$modifier {
-                    modifiers_out.push(quote! { (#$modifier) });
-                }; )+
-            }
-        }
-
-        passthrough!(
-            arena_cache,
-            cycle_fatal,
-            cycle_delay_bug,
-            cycle_stash,
-            no_hash,
-            anon,
-            eval_always,
-            feedable,
-            depth_limit,
-            separate_provide_extern,
-            return_result_from_ensure_ok,
-        );
-
-        // If there was a `cache_on_disk_if` modifier in the real input, pass
-        // on a synthetic `(cache_on_disk)` modifier that can be inspected by
-        // macro-rules macros.
-        if modifiers.cache_on_disk_if.is_some() {
-            modifiers_out.push(quote! { (cache_on_disk) });
-        }
-
-        // This uses the span of the query definition for the commas,
-        // which can be important if we later encounter any ambiguity
-        // errors with any of the numerous macro_rules! macros that
-        // we use. Using the call-site span would result in a span pointing
-        // at the entire `rustc_queries!` invocation, which wouldn't
-        // be very useful.
-        let span = name.span();
-        let modifiers_stream = quote_spanned! { span => #(#modifiers_out),* };
+        let modifiers_stream = modifiers::make_modifiers_stream(&query, modifiers);
 
         // Add the query to the group
         query_stream.extend(quote! {
             #(#doc_comments)*
-            [#modifiers_stream]
-            fn #name(#key_ty) #return_ty,
+            fn #name(#key_ty) #return_ty
+            { #modifiers_stream }
         });
 
         if let Some(feedable) = &modifiers.feedable {

compiler/rustc_macros/src/query/modifiers.rs

@@ -1,7 +1,10 @@
+use quote::{quote, quote_spanned};
 use syn::parse::{Parse, ParseStream, Result};
 use syn::punctuated::Punctuated;
 use syn::{Block, Error, Expr, Ident, Token, braced};
 
+use crate::query::Query;
+
 pub(crate) struct Desc {
     pub(crate) modifier: Ident,
     pub(crate) expr_list: Punctuated<Expr, Token![,]>,
@@ -115,3 +118,68 @@ pub(crate) fn parse_query_modifiers(input: ParseStream<'_>) -> Result<QueryModif
         return_result_from_ensure_ok,
     })
 }
+
+pub(crate) fn make_modifiers_stream(
+    query: &Query,
+    modifiers: &QueryModifiers,
+) -> proc_macro2::TokenStream {
+    let QueryModifiers {
+        // tidy-alphabetical-start
+        anon,
+        arena_cache,
+        cache_on_disk_if,
+        cycle_delay_bug,
+        cycle_fatal,
+        cycle_stash,
+        depth_limit,
+        desc: _,
+        eval_always,
+        feedable,
+        no_hash,
+        return_result_from_ensure_ok,
+        separate_provide_extern,
+        // tidy-alphabetical-end
+    } = modifiers;
+
+    let is_anon = anon.is_some();
+    let is_arena_cache = arena_cache.is_some();
+    let is_cache_on_disk = cache_on_disk_if.is_some();
+
+    let cycle_error_handling = if cycle_delay_bug.is_some() {
+        quote! { DelayBug }
+    } else if cycle_fatal.is_some() {
+        quote! { Fatal }
+    } else if cycle_stash.is_some() {
+        quote! { Stash }
+    } else {
+        quote! { Error }
+    };
+
+    let is_depth_limit = depth_limit.is_some();
+    let is_eval_always = eval_always.is_some();
+    let is_feedable = feedable.is_some();
+    let is_no_hash = no_hash.is_some();
+    let is_return_result_from_ensure_ok = return_result_from_ensure_ok.is_some();
+    let is_separate_provide_extern = separate_provide_extern.is_some();
+
+    // Giving an input span to the modifier names in the modifier list seems
+    // to give slightly more helpful errors when one of the callback macros
+    // fails to parse the modifier list.
+    let query_name_span = query.name.span();
+    quote_spanned! {
+        query_name_span =>
+        // Search for (QMODLIST) to find all occurrences of this query modifier list.
+        // tidy-alphabetical-start
+        anon: #is_anon,
+        arena_cache: #is_arena_cache,
+        cache_on_disk: #is_cache_on_disk,
+        cycle_error_handling: #cycle_error_handling,
+        depth_limit: #is_depth_limit,
+        eval_always: #is_eval_always,
+        feedable: #is_feedable,
+        no_hash: #is_no_hash,
+        return_result_from_ensure_ok: #is_return_result_from_ensure_ok,
+        separate_provide_extern: #is_separate_provide_extern,
+        // tidy-alphabetical-end
+    }
+}

compiler/rustc_middle/src/dep_graph/dep_node.rs

@@ -268,8 +268,10 @@ macro_rules! define_dep_nodes {
         queries {
             $(
                 $(#[$q_attr:meta])*
-                [$($modifiers:tt)*]
-                fn $q_name:ident($K:ty) -> $V:ty,
+                fn $q_name:ident($K:ty) -> $V:ty
+                // Search for (QMODLIST) to find all occurrences of this query modifier list.
+                // Query modifiers are currently not used here, so skip the whole list.
+                { $($modifiers:tt)* }
             )*
         }
         non_queries {

compiler/rustc_middle/src/query/inner.rs

@@ -1,7 +1,6 @@
 //! Helper functions that serve as the immediate implementation of
 //! `tcx.$query(..)` and its variations.
 
-use rustc_data_structures::assert_matches;
 use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span};
 
 use crate::dep_graph;
@@ -71,19 +70,15 @@ pub(crate) fn query_ensure_error_guaranteed<'tcx, C, T>(
     tcx: TyCtxt<'tcx>,
     query: &'tcx QueryVTable<'tcx, C>,
     key: C::Key,
-    // This arg is needed to match the signature of `query_ensure`,
-    // but should always be `EnsureMode::Ok`.
-    ensure_mode: EnsureMode,
 ) -> Result<(), ErrorGuaranteed>
 where
     C: QueryCache<Value = Erased<Result<T, ErrorGuaranteed>>>,
     Result<T, ErrorGuaranteed>: Erasable,
 {
-    assert_matches!(ensure_mode, EnsureMode::Ok);
-
     if let Some(res) = try_get_cached(tcx, &query.cache, &key) {
         erase::restore_val(res).map(drop)
     } else {
+        let ensure_mode = EnsureMode::Ok;
         (query.execute_query_fn)(tcx, DUMMY_SP, key, QueryMode::Ensure { ensure_mode })
             .map(erase::restore_val)
             .map(|res| res.map(drop))