Extract the query_feed collision case to a separate function

Author: Zalathar

compiler/rustc_middle/src/query/inner.rs

@@ -109,40 +109,12 @@ pub(crate) fn query_feed<'tcx, C>(
     C: QueryCache,
     C::Key: DepNodeKey<'tcx>,
 {
-    let format_value = query.format_value;
-
     // Check whether the in-memory cache already has a value for this key.
     match try_get_cached(tcx, &query.cache, key) {
         Some(old) => {
-            // The query already has a cached value for this key.
-            // That's OK if both values are the same, i.e. they have the same hash,
-            // so now we check their hashes.
-            if let Some(hash_value_fn) = query.hash_value_fn {
-                let (old_hash, value_hash) = tcx.with_stable_hashing_context(|ref mut hcx| {
-                    (hash_value_fn(hcx, &old), hash_value_fn(hcx, &value))
-                });
-                if old_hash != value_hash {
-                    // We have an inconsistency. This can happen if one of the two
-                    // results is tainted by errors. In this case, delay a bug to
-                    // ensure compilation is doomed, and keep the `old` value.
-                    tcx.dcx().delayed_bug(format!(
-                        "Trying to feed an already recorded value for query {query:?} key={key:?}:\n\
-                        old value: {old}\nnew value: {value}",
-                        old = format_value(&old),
-                        value = format_value(&value),
-                    ));
-                }
-            } else {
-                // The query is `no_hash`, so we have no way to perform a sanity check.
-                // If feeding the same value multiple times needs to be supported,
-                // the query should not be marked `no_hash`.
-                bug!(
-                    "Trying to feed an already recorded value for query {query:?} key={key:?}:\n\
-                    old value: {old}\nnew value: {value}",
-                    old = format_value(&old),
-                    value = format_value(&value),
-                )
-            }
+            // There was already a cached value for this key.
+            // Check whether the collision is fine or a compiler bug.
+            on_query_feed_collision(tcx, query, key, old, value);
         }
         None => {
             // There is no cached value for this key, so feed the query by
@@ -159,3 +131,47 @@ pub(crate) fn query_feed<'tcx, C>(
         }
     }
 }
+
+/// Called when a query is fed with a key/value pair, but there is already a value
+/// for that key in the query's in-memory cache.
+///
+/// Depending on the circumstances, this might be fine, or it might be a compiler bug.
+fn on_query_feed_collision<'tcx, C: QueryCache>(
+    tcx: TyCtxt<'tcx>,
+    query: &'tcx QueryVTable<'tcx, C>,
+    key: C::Key,
+    old: C::Value,
+    value: C::Value,
+) {
+    let format_value = query.format_value;
+
+    // The query already has a cached value for this key.
+    // That's OK if both values are the same, i.e. they have the same hash,
+    // so now we check their hashes.
+    if let Some(hash_value_fn) = query.hash_value_fn {
+        let (old_hash, value_hash) = tcx.with_stable_hashing_context(|ref mut hcx| {
+            (hash_value_fn(hcx, &old), hash_value_fn(hcx, &value))
+        });
+        if old_hash != value_hash {
+            // We have an inconsistency. This can happen if one of the two
+            // results is tainted by errors. In this case, delay a bug to
+            // ensure compilation is doomed, and keep the `old` value.
+            tcx.dcx().delayed_bug(format!(
+                "Trying to feed an already recorded value for query {query:?} key={key:?}:\n\
+                old value: {old}\nnew value: {value}",
+                old = format_value(&old),
+                value = format_value(&value),
+            ));
+        }
+    } else {
+        // The query is `no_hash`, so we have no way to perform a sanity check.
+        // If feeding the same value multiple times needs to be supported,
+        // the query should not be marked `no_hash`.
+        bug!(
+            "Trying to feed an already recorded value for query {query:?} key={key:?}:\n\
+            old value: {old}\nnew value: {value}",
+            old = format_value(&old),
+            value = format_value(&value),
+        )
+    }
+}