Tidy up on_query_feed_collisions

Author: Zalathar

compiler/rustc_middle/src/query/inner.rs

@@ -143,35 +143,35 @@ fn on_query_feed_collision<'tcx, C: QueryCache>(
     old: C::Value,
     value: C::Value,
 ) {
-    let format_value = query.format_value;
+    // Shared message for both failure paths, as a closure since we might not need it.
+    let bug_message = || {
+        format!(
+            "Trying to feed an already recorded value for query {query:?} key={key:?}:\n\
+                old value: {old}\n\
+                new value: {value}",
+            old = (query.format_value)(&old),
+            value = (query.format_value)(&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.
+    // The query already has a cached value for this key. That's OK as long as
+    // the values are the same, or the difference could be explained by errors.
+    // So now we compare hashes to see if the values are the same.
     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),
-            ));
+            // We have an inconsistency. This could be a bug, but it can also
+            // occur if one of the two values is tainted by errors.
+            // Therefore, issue a delayed bug to ensure that compilation is
+            // doomed, keep the old value, and discard the new value.
+            tcx.dcx().delayed_bug(bug_message());
         }
     } else {
-        // The query is `no_hash`, so we have no way to perform a sanity check.
+        // The query is `no_hash`, so we have no way to check consistency.
         // 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),
-        )
+        bug!("{}", bug_message());
     }
 }