Pass QueryVTable to two functions instead of two fn pointers.

Specifically, `DepGraph::with_feed_task` and `incremental_verify_ich`
This makes some things shorter, at the cost of making module `dep_graph`
depend directly on module `query`. (It already depends indirectly via
module `verify_ich`.)

Author: nnethercote

compiler/rustc_middle/src/dep_graph/graph.rs

@@ -27,6 +27,7 @@ use super::serialized::{GraphEncoder, SerializedDepGraph, SerializedDepNodeIndex
 use super::{DepKind, DepNode, WorkProductId, read_deps, with_deps};
 use crate::dep_graph::edges::EdgesVec;
 use crate::ich::StableHashingContext;
+use crate::query::{QueryCache, QueryVTable};
 use crate::ty::TyCtxt;
 use crate::verify_ich::incremental_verify_ich;
 
@@ -572,13 +573,12 @@ impl DepGraph {
     /// FIXME: If the code is changed enough for this node to be marked before requiring the
     /// caller's node, we suppose that those changes will be enough to mark this node red and
     /// force a recomputation using the "normal" way.
-    pub fn with_feed_task<'tcx, R>(
+    pub fn with_feed_task<'tcx, C: QueryCache>(
         &self,
-        node: DepNode,
         tcx: TyCtxt<'tcx>,
-        result: &R,
-        hash_result: Option<fn(&mut StableHashingContext<'_>, &R) -> Fingerprint>,
-        format_value_fn: fn(&R) -> String,
+        query: &'tcx QueryVTable<'tcx, C>,
+        node: DepNode,
+        value: &C::Value,
     ) -> DepNodeIndex {
         if let Some(data) = self.data.as_ref() {
             // The caller query has more dependencies than the node we are creating. We may
@@ -590,17 +590,10 @@ impl DepGraph {
             if let Some(prev_index) = data.previous.node_to_index_opt(&node) {
                 let dep_node_index = data.colors.current(prev_index);
                 if let Some(dep_node_index) = dep_node_index {
-                    incremental_verify_ich(
-                        tcx,
-                        data,
-                        result,
-                        prev_index,
-                        hash_result,
-                        format_value_fn,
-                    );
+                    incremental_verify_ich(tcx, data, query, value, prev_index);
 
                     #[cfg(debug_assertions)]
-                    if hash_result.is_some() {
+                    if query.hash_value_fn.is_some() {
                         data.current.record_edge(
                             dep_node_index,
                             node,
@@ -624,7 +617,7 @@ impl DepGraph {
                 }
             });
 
-            data.hash_result_and_alloc_node(tcx, node, edges, result, hash_result)
+            data.hash_result_and_alloc_node(tcx, node, edges, value, query.hash_value_fn)
         } else {
             // Incremental compilation is turned off. We just execute the task
             // without tracking. We still provide a dep-node index that uniquely

compiler/rustc_middle/src/query/inner.rs

@@ -158,13 +158,7 @@ pub(crate) fn query_feed<'tcx, C>(
             // There is no cached value for this key, so feed the query by
             // adding the provided value to the cache.
             let dep_node = dep_graph::DepNode::construct(tcx, query.dep_kind, &key);
-            let dep_node_index = tcx.dep_graph.with_feed_task(
-                dep_node,
-                tcx,
-                &value,
-                query.hash_value_fn,
-                query.format_value,
-            );
+            let dep_node_index = tcx.dep_graph.with_feed_task(tcx, query, dep_node, &value);
             query.cache.complete(key, value, dep_node_index);
         }
     }

compiler/rustc_middle/src/verify_ich.rs

@@ -4,31 +4,30 @@ use rustc_data_structures::fingerprint::Fingerprint;
 use tracing::instrument;
 
 use crate::dep_graph::{DepGraphData, SerializedDepNodeIndex};
-use crate::ich::StableHashingContext;
+use crate::query::{QueryCache, QueryVTable};
 use crate::ty::TyCtxt;
 
 #[inline]
-#[instrument(skip(tcx, dep_graph_data, result, hash_result, format_value), level = "debug")]
-pub fn incremental_verify_ich<'tcx, V>(
+#[instrument(skip(tcx, query, dep_graph_data, result), level = "debug")]
+pub fn incremental_verify_ich<'tcx, C: QueryCache>(
     tcx: TyCtxt<'tcx>,
     dep_graph_data: &DepGraphData,
-    result: &V,
+    query: &'tcx QueryVTable<'tcx, C>,
+    result: &C::Value,
     prev_index: SerializedDepNodeIndex,
-    hash_result: Option<fn(&mut StableHashingContext<'_>, &V) -> Fingerprint>,
-    format_value: fn(&V) -> String,
 ) {
     if !dep_graph_data.is_index_green(prev_index) {
         incremental_verify_ich_not_green(tcx, prev_index)
     }
 
-    let new_hash = hash_result.map_or(Fingerprint::ZERO, |f| {
+    let new_hash = query.hash_value_fn.map_or(Fingerprint::ZERO, |f| {
         tcx.with_stable_hashing_context(|mut hcx| f(&mut hcx, result))
     });
 
     let old_hash = dep_graph_data.prev_value_fingerprint_of(prev_index);
 
     if new_hash != old_hash {
-        incremental_verify_ich_failed(tcx, prev_index, &|| format_value(result));
+        incremental_verify_ich_failed(tcx, prev_index, &|| (query.format_value)(result));
     }
 }
 

compiler/rustc_query_impl/src/execution.rs

@@ -475,14 +475,7 @@ fn execute_job_incr<'tcx, C: QueryCache>(
             //
             // See issue #82920 for an example of a miscompilation that would get turned into an
             // ICE by this check.
-            incremental_verify_ich(
-                tcx,
-                dep_graph_data,
-                &value,
-                prev_index,
-                query.hash_value_fn,
-                query.format_value,
-            );
+            incremental_verify_ich(tcx, dep_graph_data, query, &value, prev_index);
         }
 
         (value, dep_node_index)