Get rid of OnHit by switching on QueryMode instead of unconditionally returning Option

I think `copy` may have added some overhead? unclear what's causing the perf impact.

Author: jyn514

compiler/rustc_middle/src/ty/query.rs

@@ -102,12 +102,6 @@ impl<'tcx> TyCtxt<'tcx> {
     }
 }
 
-/// Helper to ensure that queries only return `Copy` types.
-#[inline(always)]
-fn copy<T: Copy>(x: &T) -> T {
-    *x
-}
-
 fn evaluate_query<'tcx, Cache>(
     tcx: TyCtxt<'tcx>,
     execute_query: fn(
@@ -126,11 +120,9 @@ where
     Cache::Stored: Copy,
     Cache: QueryCache,
 {
-    let cached = try_get_cached(tcx, query_cache, &key, copy);
-
-    match cached {
-        Ok(value) => return value,
-        Err(()) => (),
+    match try_get_cached(tcx, query_cache, &key, mode) {
+        Ok(value) => value,
+        Err(()) => execute_query(tcx.queries, tcx, span, key, mode),
     }
 }
 

compiler/rustc_query_system/src/query/plumbing.rs

@@ -303,24 +303,23 @@ where
 /// which will be used if the query is not in the cache and we need
 /// to compute it.
 #[inline]
-pub fn try_get_cached<'a, CTX, C, R, OnHit>(
+pub fn try_get_cached<'a, CTX, C>(
     tcx: CTX,
     cache: &'a C,
     key: &C::Key,
-    // `on_hit` can be called while holding a lock to the query cache
-    on_hit: OnHit,
-) -> Result<R, ()>
+    mode: QueryMode,
+) -> Result<Option<C::Stored>, ()>
 where
     C: QueryCache,
+    C::Stored: Copy,
     CTX: DepContext,
-    OnHit: FnOnce(&C::Stored) -> R,
 {
     cache.lookup(&key, |value, index| {
         if std::intrinsics::unlikely(tcx.profiler().enabled()) {
             tcx.profiler().query_cache_hit(index.into());
         }
         tcx.dep_graph().read_index(index);
-        on_hit(value)
+        if matches!(mode, QueryMode::Ensure) { None } else { Some(*value) }
     })
 }
 
@@ -676,7 +675,7 @@ where
     }
 }
 
-#[derive(Debug)]
+#[derive(Copy, Clone, Debug)]
 pub enum QueryMode {
     Get,
     Ensure,