Remove the _cache_on_disk_if_fns module.

One of the modules generated by `rustc_queries` looks like this:
```
mod _cache_on_disk_if_fns {
    ...

    #[inline]
    pub fn const_param_default<'tcx>(
	_: TyCtxt<'tcx>,
	param: &crate::queries::const_param_default::Key<'tcx>
    ) -> bool {
	param.is_local()
    }

    ...
```
Members of this module are used to initialize multiple `QueryVTable`
fields.

This commit removes the `_cache_on_disk_if_fns` module entirely. For
each cacheable query we generate a check closure which is passed as
`(cache_on_disk_if { $check_closure }` in the modifiers list. This is
similar to how `desc` modifiers are handled.

Author: nnethercote

Cargo.lock

@@ -4492,6 +4492,7 @@ version = "0.0.0"
 dependencies = [
  "measureme",
  "rustc_abi",
+ "rustc_ast",
  "rustc_data_structures",
  "rustc_errors",
  "rustc_hir",

compiler/rustc_macros/src/query.rs

@@ -273,38 +273,6 @@ fn doc_comment_from_desc(list: &Punctuated<Expr, token::Comma>) -> Result<Attrib
     Ok(parse_quote! { #[doc = #doc_string] })
 }
 
-/// Contains token streams that are used to accumulate per-query helper
-/// functions, to be used by the final output of `rustc_queries!`.
-///
-/// Helper items typically have the same name as the query they relate to,
-/// and expect to be interpolated into a dedicated module.
-#[derive(Default)]
-struct HelperTokenStreams {
-    cache_on_disk_if_fns_stream: proc_macro2::TokenStream,
-}
-
-fn make_helpers_for_query(query: &Query, streams: &mut HelperTokenStreams) {
-    let Query { name, key_pat, key_ty, modifiers, .. } = &query;
-
-    // Replace span for `name` to make rust-analyzer ignore it.
-    let mut erased_name = name.clone();
-    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() {
-        // `pass_by_value`: some keys are marked with `rustc_pass_by_value`, but we take keys by
-        // reference here.
-        // FIXME: `pass_by_value` is badly named; `allow(rustc::pass_by_value)` actually means
-        // "allow pass by reference of `rustc_pass_by_value` types".
-        streams.cache_on_disk_if_fns_stream.extend(quote! {
-            #[allow(unused_variables, rustc::pass_by_value)]
-            #[inline]
-            pub fn #erased_name<'tcx>(tcx: TyCtxt<'tcx>, #key_pat: &#key_ty) -> bool
-            #block
-        });
-    }
-}
-
 /// Add hints for rust-analyzer
 fn add_to_analyzer_stream(query: &Query, analyzer_stream: &mut proc_macro2::TokenStream) {
     // Add links to relevant modifiers
@@ -384,7 +352,6 @@ pub(super) fn rustc_queries(input: TokenStream) -> TokenStream {
     let queries = parse_macro_input!(input as List<Query>);
 
     let mut query_stream = quote! {};
-    let mut helpers = HelperTokenStreams::default();
     let mut analyzer_stream = quote! {};
     let mut errors = quote! {};
 
@@ -435,11 +402,23 @@ pub(super) fn rustc_queries(input: TokenStream) -> TokenStream {
             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) });
+        // If there was a `cache_on_disk_if` modifier, put a closure inside it:
+        // `(cache_on_disk { <closure > }`.
+        if let Some(CacheOnDiskIf { block, .. }) = &modifiers.cache_on_disk_if {
+            modifiers_out.push(quote! {
+                (cache_on_disk_if { 
+                    // `pass_by_value`: some keys are marked with `rustc_pass_by_value`, but we
+                    // take keys by reference here.
+                    // FIXME: `pass_by_value` is badly named; `allow(rustc::pass_by_value)`
+                    // actually means "allow pass by reference of `rustc_pass_by_value` types".
+                    //
+                    // The type annotations are required to avoid compile errors, which is annoying
+                    // because it necessitates extra `use` items in the file using
+                    // `rustc_with_all_queries!`.
+                    #[allow(rustc::pass_by_value)]
+                    |tcx: TyCtxt<'_>, #key_pat: &#key_ty| #block
+                })
+            });
         }
 
         // This uses the span of the query definition for the commas,
@@ -472,11 +451,8 @@ pub(super) fn rustc_queries(input: TokenStream) -> TokenStream {
         }
 
         add_to_analyzer_stream(&query, &mut analyzer_stream);
-        make_helpers_for_query(&query, &mut helpers);
     }
 
-    let HelperTokenStreams { cache_on_disk_if_fns_stream } = helpers;
-
     TokenStream::from(quote! {
         /// Higher-order macro that invokes the specified macro with a prepared
         /// list of all query signatures (including modifiers).
@@ -506,14 +482,6 @@ pub(super) fn rustc_queries(input: TokenStream) -> TokenStream {
             #analyzer_stream
         }
 
-        // FIXME(Zalathar): Instead of declaring these functions directly, can
-        // we put them in a macro and then expand that macro downstream in
-        // `rustc_query_impl`, where the functions are actually used?
-        pub mod _cache_on_disk_if_fns {
-            use super::*;
-            #cache_on_disk_if_fns_stream
-        }
-
         #errors
     })
 }

compiler/rustc_middle/src/queries.rs

@@ -96,7 +96,6 @@ use rustc_session::cstore::{
     CrateDepKind, CrateSource, ExternCrate, ForeignModule, LinkagePreference, NativeLib,
 };
 use rustc_session::lint::LintExpectationId;
-use rustc_span::def_id::LOCAL_CRATE;
 use rustc_span::source_map::Spanned;
 use rustc_span::{DUMMY_SP, LocalExpnId, Span, Symbol};
 use rustc_target::spec::PanicStrategy;

compiler/rustc_middle/src/query/plumbing.rs

@@ -139,8 +139,10 @@ pub struct QueryVTable<'tcx, C: QueryCache> {
         prev_index: SerializedDepNodeIndex,
         index: DepNodeIndex,
     ) -> Option<C::Value>,
+
     pub is_loadable_from_disk_fn:
         fn(tcx: TyCtxt<'tcx>, key: &C::Key, index: SerializedDepNodeIndex) -> bool,
+
     pub hash_result: HashResult<C::Value>,
     pub value_from_cycle_error:
         fn(tcx: TyCtxt<'tcx>, cycle_error: &CycleError, guar: ErrorGuaranteed) -> C::Value,

compiler/rustc_query_impl/Cargo.toml

@@ -7,6 +7,7 @@ edition = "2024"
 # tidy-alphabetical-start
 measureme = "12.0.1"
 rustc_abi = { path = "../rustc_abi" }
+rustc_ast = { path = "../rustc_ast" }
 rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_errors = { path = "../rustc_errors" }
 rustc_hir = { path = "../rustc_hir" }

compiler/rustc_query_impl/src/lib.rs

@@ -5,22 +5,27 @@
 #![feature(core_intrinsics)]
 #![feature(min_specialization)]
 #![feature(rustc_attrs)]
+#![feature(stmt_expr_attributes)]
 #![feature(try_blocks)]
 // tidy-alphabetical-end
 
+use rustc_ast::tokenstream::TokenStream;
 use rustc_data_structures::sync::AtomicU64;
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::LOCAL_CRATE;
 use rustc_middle::dep_graph;
+use rustc_middle::mir::interpret::GlobalId;
+use rustc_middle::mir::mono::CollectionMode;
 use rustc_middle::queries::{self, ExternProviders, Providers};
 use rustc_middle::query::on_disk_cache::{CacheEncoder, EncodedDepNodeIndex, OnDiskCache};
 use rustc_middle::query::plumbing::{QuerySystem, QuerySystemFns, QueryVTable};
 use rustc_middle::query::{
     AsLocalKey, QueryCache, QueryMode, describe_as_module,
 };
 use rustc_middle::ty::print::PrintTraitRefExt;
-use rustc_middle::ty::{self, TyCtxt};
-use rustc_span::Span;
+use rustc_middle::ty::{self, PseudoCanonicalInput, TyCtxt};
+use rustc_span::def_id::{CrateNum, DefId, LocalDefId, LocalModDefId};
+use rustc_span::{LocalExpnId, Span};
 
 pub use crate::dep_kind_vtables::make_dep_kind_vtables;
 pub use crate::job::{QueryJobMap, break_query_cycles, print_query_stack};

compiler/rustc_query_impl/src/plumbing.rs

@@ -242,29 +242,42 @@ macro_rules! call_provider {
 
 /// Expands to one of two token trees, depending on whether the current query
 /// has the `cache_on_disk_if` modifier.
-macro_rules! if_cache_on_disk {
+macro_rules! if_cache_on_disk_if {
     ([] $yes:tt $no:tt) => {
         $no
     };
-    // The `cache_on_disk_if` modifier generates a synthetic `(cache_on_disk)`,
-    // modifier, for use by this macro and similar macros.
-    ([(cache_on_disk) $($rest:tt)*] $yes:tt $no:tt) => {
+    // Ignore the closure.
+    ([(cache_on_disk_if { $_:expr }) $($rest:tt)*] $yes:tt $no:tt) => {
         $yes
     };
     ([$other:tt $($modifiers:tt)*] $yes:tt $no:tt) => {
-        if_cache_on_disk!([$($modifiers)*] $yes $no)
+        if_cache_on_disk_if!([$($modifiers)*] $yes $no)
+    };
+}
+
+/// Extract the closure from the `cache_on_disk_if` modifier if present, otherwise generate a
+/// trivial failing closure.
+macro_rules! cache_on_disk_if_fn {
+    ([] $($item:tt)*) => {
+        |_tcx, _key| false
+    };
+    ([(cache_on_disk_if { $cache_closure:expr }) $($rest:tt)*]) => {
+        $cache_closure
+    };
+    ([$other:tt $($modifiers:tt)*]) => {
+        cache_on_disk_if_fn! { [$($modifiers)*] }
     };
 }
 
 /// Conditionally expands to some token trees, if the current query has the
 /// `cache_on_disk_if` modifier.
-macro_rules! item_if_cache_on_disk {
+macro_rules! item_if_cache_on_disk_if {
     ([] $($item:tt)*) => {};
-    ([(cache_on_disk) $($rest:tt)*] $($item:tt)*) => {
+    ([(cache_on_disk_if { $_:expr }) $($rest:tt)*] $($item:tt)*) => {
         $($item)*
     };
     ([$other:tt $($modifiers:tt)*] $($item:tt)*) => {
-        item_if_cache_on_disk! { [$($modifiers)*] $($item)* }
+        item_if_cache_on_disk_if! { [$($modifiers)*] $($item)* }
     };
 }
 
@@ -568,21 +581,18 @@ macro_rules! define_queries {
                     cycle_error_handling: cycle_error_handling!([$($modifiers)*]),
                     state: Default::default(),
                     cache: Default::default(),
-                    will_cache_on_disk_for_key_fn: if_cache_on_disk!([$($modifiers)*] {
-                        rustc_middle::queries::_cache_on_disk_if_fns::$name
-                    } {
-                        |_tcx, _key| false
-                    }),
+                    will_cache_on_disk_for_key_fn: cache_on_disk_if_fn!([$($modifiers)*]),
                     call_query_method_fn: |tcx, key| {
                         // Call the query method for its side-effect of loading a value
                         // from disk-cache; the caller doesn't need the value.
                         let _ = tcx.$name(key);
                     },
                     invoke_provider_fn: self::invoke_provider_fn::__rust_begin_short_backtrace,
-                    try_load_from_disk_fn: if_cache_on_disk!([$($modifiers)*] {
+                    try_load_from_disk_fn: if_cache_on_disk_if!([$($modifiers)*] {
                         |tcx, key, prev_index, index| {
                             // Check the `cache_on_disk_if` condition for this key.
-                            if !::rustc_middle::queries::_cache_on_disk_if_fns::$name(tcx, &key) {
+                            let cache_on_disk_if_fn = cache_on_disk_if_fn!([$($modifiers)*]);
+                            if !cache_on_disk_if_fn(tcx, key) {
                                 return None;
                             }
 
@@ -595,9 +605,10 @@ macro_rules! define_queries {
                     } {
                         |_tcx, _key, _prev_index, _index| None
                     }),
-                    is_loadable_from_disk_fn: if_cache_on_disk!([$($modifiers)*] {
+                    is_loadable_from_disk_fn: if_cache_on_disk_if!([$($modifiers)*] {
                         |tcx, key, index| -> bool {
-                            ::rustc_middle::queries::_cache_on_disk_if_fns::$name(tcx, &key) &&
+                            let cache_on_disk_if_fn = cache_on_disk_if_fn!([$($modifiers)*]);
+                            cache_on_disk_if_fn(tcx, key) &&
                                 $crate::plumbing::loadable_from_disk(tcx, index)
                         }
                     } {
@@ -678,7 +689,7 @@ macro_rules! define_queries {
                 )
             }
 
-            item_if_cache_on_disk! { [$($modifiers)*]
+            item_if_cache_on_disk_if! { [$($modifiers)*]
                 pub(crate) fn encode_query_results<'tcx>(
                     tcx: TyCtxt<'tcx>,
                     encoder: &mut CacheEncoder<'_, 'tcx>,
@@ -739,7 +750,7 @@ macro_rules! define_queries {
             >
         ] = &[
             $(
-                if_cache_on_disk!([$($modifiers)*] {
+                if_cache_on_disk_if!([$($modifiers)*] {
                     Some(query_impl::$name::encode_query_results)
                 } {
                     None