Remove {get,force}_query_impl.

Author: cjgillot

compiler/rustc_query_system/src/query/plumbing.rs

@@ -14,6 +14,7 @@ use rustc_data_structures::cold_path;
 use rustc_data_structures::fingerprint::Fingerprint;
 use rustc_data_structures::fx::{FxHashMap, FxHasher};
 use rustc_data_structures::sharded::Sharded;
+use rustc_data_structures::stable_hasher::HashStable;
 use rustc_data_structures::sync::{Lock, LockGuard};
 use rustc_data_structures::thin_vec::ThinVec;
 use rustc_errors::{Diagnostic, FatalError};
@@ -157,7 +158,7 @@ where
 
 impl<'tcx, D, Q, C> JobOwner<'tcx, D, Q, C>
 where
-    D: Copy + Clone + Eq + Hash,
+    D: Copy + Clone + Eq + Hash + DepKind,
     Q: Clone,
     C: QueryCache,
 {
@@ -179,7 +180,8 @@ where
         query: &QueryVtable<CTX, C::Key, C::Value>,
     ) -> TryGetJob<'b, CTX::DepKind, CTX::Query, C>
     where
-        CTX: QueryContext,
+        CTX: QueryContext<DepKind = D, Query = Q>,
+        Q: HashStable<CTX::StableHashingContext>,
     {
         let lock = &mut *lookup.lock;
 
@@ -622,31 +624,6 @@ where
     (result, dep_node_index)
 }
 
-#[inline(never)]
-fn get_query_impl<CTX, C>(
-    tcx: CTX,
-    state: &QueryState<CTX::DepKind, CTX::Query, C>,
-    span: Span,
-    key: C::Key,
-    query: &QueryVtable<CTX, C::Key, C::Value>,
-) -> C::Stored
-where
-    CTX: QueryContext,
-    C: QueryCache,
-    C::Key: crate::dep_graph::DepNodeParams<CTX>,
-{
-    try_get_cached(
-        tcx,
-        state,
-        key,
-        |value, index| {
-            tcx.dep_graph().read_index(index);
-            value.clone()
-        },
-        |key, lookup| try_execute_query(tcx, state, span, key, lookup, query),
-    )
-}
-
 /// Ensure that either this query has all green inputs or been executed.
 /// Executing `query::ensure(D)` is considered a read of the dep-node `D`.
 ///
@@ -686,43 +663,6 @@ where
     }
 }
 
-#[inline(never)]
-fn force_query_impl<CTX, C>(
-    tcx: CTX,
-    state: &QueryState<CTX::DepKind, CTX::Query, C>,
-    key: C::Key,
-    span: Span,
-    dep_node: DepNode<CTX::DepKind>,
-    query: &QueryVtable<CTX, C::Key, C::Value>,
-) where
-    C: QueryCache,
-    C::Key: crate::dep_graph::DepNodeParams<CTX>,
-    CTX: QueryContext,
-{
-    // We may be concurrently trying both execute and force a query.
-    // Ensure that only one of them runs the query.
-
-    try_get_cached(
-        tcx,
-        state,
-        key,
-        |_, _| {
-            // Cache hit, do nothing
-        },
-        |key, lookup| {
-            let job = match JobOwner::<'_, CTX::DepKind, CTX::Query, C>::try_start(
-                tcx, state, span, &key, lookup, query,
-            ) {
-                TryGetJob::NotYetStarted(job) => job,
-                TryGetJob::Cycle(_) => return,
-                #[cfg(parallel_compiler)]
-                TryGetJob::JobCompleted(_) => return,
-            };
-            force_query_with_job(tcx, key, job, dep_node, query);
-        },
-    );
-}
-
 pub enum QueryCaller<DK> {
     Ensure,
     Get,
@@ -744,23 +684,58 @@ where
     C::Stored: Clone,
     CTX: QueryContext,
 {
-    match caller {
-        QueryCaller::Ensure => {
-            if ensure_query_impl(tcx, &key, query) {
-                return None;
-            }
-            let _ = get_query_impl(tcx, state, span, key, query);
-            None
-        }
-        QueryCaller::Get => {
-            let ret = get_query_impl(tcx, state, span, key, query);
-            Some(ret)
-        }
-        QueryCaller::Force(dep_node) => {
-            force_query_impl(tcx, state, key, span, dep_node, query);
-            None
+    if let QueryCaller::Ensure = caller {
+        if ensure_query_impl(tcx, &key, query) {
+            return None;
         }
     }
+
+    try_get_cached(
+        tcx,
+        state,
+        key,
+        |value, index| {
+            match &caller {
+                QueryCaller::Ensure => {
+                    tcx.dep_graph().read_index(index);
+                    None
+                }
+                QueryCaller::Get => {
+                    tcx.dep_graph().read_index(index);
+                    Some(value.clone())
+                }
+                QueryCaller::Force(_) => {
+                    // Cache hit, do nothing
+                    None
+                }
+            }
+        },
+        |key, lookup| {
+            match &caller {
+                QueryCaller::Ensure => {
+                    try_execute_query(tcx, state, span, key, lookup, query);
+                    None
+                }
+                QueryCaller::Get => {
+                    let value = try_execute_query(tcx, state, span, key, lookup, query);
+                    Some(value)
+                }
+                QueryCaller::Force(dep_node) => {
+                    // We may be concurrently trying both execute and force a query.
+                    // Ensure that only one of them runs the query.
+
+                    let job = match JobOwner::try_start(tcx, state, span, &key, lookup, query) {
+                        TryGetJob::NotYetStarted(job) => job,
+                        TryGetJob::Cycle(_) => return None,
+                        #[cfg(parallel_compiler)]
+                        TryGetJob::JobCompleted(_) => return None,
+                    };
+                    force_query_with_job(tcx, key, job, *dep_node, query);
+                    None
+                }
+            }
+        },
+    )
 }
 
 #[inline(always)]