Auto merge of #153326 - Zalathar:query-modifiers, r=<try>

Make `rustc_with_all_queries!` pass query modifiers as named values

Author: bors

compiler/rustc_macros/src/query.rs

@@ -1,14 +1,16 @@
 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;
 use syn::{
-    AttrStyle, Attribute, Block, Error, Expr, Ident, Pat, ReturnType, Token, Type, braced,
-    parenthesized, parse_macro_input, token,
+    AttrStyle, Attribute, Error, Expr, Ident, Pat, ReturnType, Token, Type, braced, parenthesized,
+    parse_macro_input, token,
 };
 
+mod modifiers;
+
 mod kw {
     syn::custom_keyword!(non_query);
     syn::custom_keyword!(query);
@@ -52,7 +54,7 @@ struct Query {
     key_ty: Type,
     return_ty: ReturnType,
 
-    modifiers: QueryModifiers,
+    modifiers: modifiers::QueryModifiers,
 }
 
 /// Declaration of a non-query dep kind.
@@ -102,7 +104,7 @@ impl Parse for QueryEntry {
         // Parse the query modifiers
         let braces_content;
         braced!(braces_content in input);
-        let modifiers = parse_query_modifiers(&braces_content)?;
+        let modifiers = modifiers::parse_query_modifiers(&braces_content)?;
 
         // If there are no doc-comments, give at least some idea of what
         // it does by showing the query description.
@@ -127,151 +129,6 @@ impl<T: Parse> Parse for List<T> {
     }
 }
 
-struct Desc {
-    modifier: Ident,
-    expr_list: Punctuated<Expr, Token![,]>,
-}
-
-struct CacheOnDiskIf {
-    modifier: Ident,
-    block: Block,
-}
-
-struct QueryModifiers {
-    /// The description of the query.
-    desc: Desc,
-
-    /// Use this type for the in-memory cache.
-    arena_cache: Option<Ident>,
-
-    /// Cache the query to disk if the `Block` returns true.
-    cache_on_disk_if: Option<CacheOnDiskIf>,
-
-    /// A cycle error for this query aborting the compilation with a fatal error.
-    cycle_fatal: Option<Ident>,
-
-    /// A cycle error results in a delay_bug call
-    cycle_delay_bug: Option<Ident>,
-
-    /// A cycle error results in a stashed cycle error that can be unstashed and canceled later
-    cycle_stash: Option<Ident>,
-
-    /// Don't hash the result, instead just mark a query red if it runs
-    no_hash: Option<Ident>,
-
-    /// Generate a dep node based on the dependencies of the query
-    anon: Option<Ident>,
-
-    /// Always evaluate the query, ignoring its dependencies
-    eval_always: Option<Ident>,
-
-    /// Whether the query has a call depth limit
-    depth_limit: Option<Ident>,
-
-    /// Use a separate query provider for local and extern crates
-    separate_provide_extern: Option<Ident>,
-
-    /// Generate a `feed` method to set the query's value from another query.
-    feedable: Option<Ident>,
-
-    /// When this query is called via `tcx.ensure_ok()`, it returns
-    /// `Result<(), ErrorGuaranteed>` instead of `()`. If the query needs to
-    /// be executed, and that execution returns an error, the error result is
-    /// returned to the caller.
-    ///
-    /// If execution is skipped, a synthetic `Ok(())` is returned, on the
-    /// assumption that a query with all-green inputs must have succeeded.
-    ///
-    /// Can only be applied to queries with a return value of
-    /// `Result<_, ErrorGuaranteed>`.
-    return_result_from_ensure_ok: Option<Ident>,
-}
-
-fn parse_query_modifiers(input: ParseStream<'_>) -> Result<QueryModifiers> {
-    let mut arena_cache = None;
-    let mut cache_on_disk_if = None;
-    let mut desc = None;
-    let mut cycle_fatal = None;
-    let mut cycle_delay_bug = None;
-    let mut cycle_stash = None;
-    let mut no_hash = None;
-    let mut anon = None;
-    let mut eval_always = None;
-    let mut depth_limit = None;
-    let mut separate_provide_extern = None;
-    let mut feedable = None;
-    let mut return_result_from_ensure_ok = None;
-
-    while !input.is_empty() {
-        let modifier: Ident = input.parse()?;
-
-        macro_rules! try_insert {
-            ($name:ident = $expr:expr) => {
-                if $name.is_some() {
-                    return Err(Error::new(modifier.span(), "duplicate modifier"));
-                }
-                $name = Some($expr);
-            };
-        }
-
-        if modifier == "desc" {
-            // Parse a description modifier like:
-            // `desc { "foo {}", tcx.item_path(key) }`
-            let attr_content;
-            braced!(attr_content in input);
-            let expr_list = attr_content.parse_terminated(Expr::parse, Token![,])?;
-            try_insert!(desc = Desc { modifier, expr_list });
-        } else if modifier == "cache_on_disk_if" {
-            // Parse a cache-on-disk modifier like:
-            // `cache_on_disk_if { tcx.is_typeck_child(key.to_def_id()) }`
-            let block = input.parse()?;
-            try_insert!(cache_on_disk_if = CacheOnDiskIf { modifier, block });
-        } else if modifier == "arena_cache" {
-            try_insert!(arena_cache = modifier);
-        } else if modifier == "cycle_fatal" {
-            try_insert!(cycle_fatal = modifier);
-        } else if modifier == "cycle_delay_bug" {
-            try_insert!(cycle_delay_bug = modifier);
-        } else if modifier == "cycle_stash" {
-            try_insert!(cycle_stash = modifier);
-        } else if modifier == "no_hash" {
-            try_insert!(no_hash = modifier);
-        } else if modifier == "anon" {
-            try_insert!(anon = modifier);
-        } else if modifier == "eval_always" {
-            try_insert!(eval_always = modifier);
-        } else if modifier == "depth_limit" {
-            try_insert!(depth_limit = modifier);
-        } else if modifier == "separate_provide_extern" {
-            try_insert!(separate_provide_extern = modifier);
-        } else if modifier == "feedable" {
-            try_insert!(feedable = modifier);
-        } else if modifier == "return_result_from_ensure_ok" {
-            try_insert!(return_result_from_ensure_ok = modifier);
-        } else {
-            return Err(Error::new(modifier.span(), "unknown query modifier"));
-        }
-    }
-    let Some(desc) = desc else {
-        return Err(input.error("no description provided"));
-    };
-    Ok(QueryModifiers {
-        arena_cache,
-        cache_on_disk_if,
-        desc,
-        cycle_fatal,
-        cycle_delay_bug,
-        cycle_stash,
-        no_hash,
-        anon,
-        eval_always,
-        depth_limit,
-        separate_provide_extern,
-        feedable,
-        return_result_from_ensure_ok,
-    })
-}
-
 fn doc_comment_from_desc(list: &Punctuated<Expr, token::Comma>) -> Result<Attribute> {
     use ::syn::*;
     let mut iter = list.iter();
@@ -318,7 +175,7 @@ fn make_helpers_for_query(query: &Query, streams: &mut HelperTokenStreams) {
     erased_name.set_span(Span::call_site());
 
     // Generate a function to check whether we should cache the query to disk, for some key.
-    if let Some(CacheOnDiskIf { block, .. }) = modifiers.cache_on_disk_if.as_ref() {
+    if let Some(modifiers::CacheOnDiskIf { block, .. }) = modifiers.cache_on_disk_if.as_ref() {
         // `disallowed_pass_by_ref` is needed because some keys are `rustc_pass_by_value`.
         streams.cache_on_disk_if_fns_stream.extend(quote! {
             #[cfg_attr(not(bootstrap), allow(unused_variables, rustc::disallowed_pass_by_ref))]
@@ -329,7 +186,7 @@ fn make_helpers_for_query(query: &Query, streams: &mut HelperTokenStreams) {
         });
     }
 
-    let Desc { expr_list, .. } = &modifiers.desc;
+    let modifiers::Desc { expr_list, .. } = &modifiers.desc;
 
     let desc = quote! {
         #[allow(unused_variables)]
@@ -356,7 +213,7 @@ fn add_to_analyzer_stream(query: &Query, analyzer_stream: &mut proc_macro2::Toke
         crate::query::modifiers::#name;
     });
 
-    if let Some(CacheOnDiskIf { modifier, .. }) = &modifiers.cache_on_disk_if {
+    if let Some(modifiers::CacheOnDiskIf { modifier, .. }) = &modifiers.cache_on_disk_if {
         modifiers_stream.extend(quote! {
             crate::query::modifiers::#modifier;
         });
@@ -458,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 {