Don't require test::Coverage to implement Ord

This derive was an artifact of test-only method `Cache::all` wanting to
automatically sort its output to hide HashMap iteration order.

We can achieve an equivalent result by requiring the caller to provide a
projection function that returns results that _are_ sortable.

Author: Zalathar

src/bootstrap/src/core/build_steps/test.rs

@@ -1582,7 +1582,7 @@ test!(AssemblyLlvm {
 
 /// Runs the coverage test suite at `tests/coverage` in some or all of the
 /// coverage test modes.
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Coverage {
     pub compiler: Compiler,
     pub target: TargetSelection,

src/bootstrap/src/core/builder/tests.rs

@@ -345,8 +345,7 @@ fn test_test_coverage() {
         let config = configure_with_args(cmd, &[], &[TEST_TRIPLE_1]);
         let mut cache = run_build(&config.paths.clone(), config);
 
-        let modes =
-            cache.all::<test::Coverage>().iter().map(|(step, ())| step.mode).collect::<Vec<_>>();
+        let modes = cache.inspect_all_steps_of_type::<test::Coverage, _>(|step, ()| step.mode);
         assert_eq!(modes, expected);
     }
 }

src/bootstrap/src/utils/cache.rs

@@ -270,16 +270,18 @@ impl Cache {
 
 #[cfg(test)]
 impl Cache {
-    pub fn all<S: Ord + Step>(&mut self) -> Vec<(S, S::Output)> {
-        let cache = self.cache.get_mut();
-        let type_id = TypeId::of::<S>();
-        let mut v = cache
-            .remove(&type_id)
-            .map(|b| b.downcast::<HashMap<S, S::Output>>().expect("correct type"))
-            .map(|m| m.into_iter().collect::<Vec<_>>())
+    pub(crate) fn inspect_all_steps_of_type<S: Step, T: Ord>(
+        &self,
+        map_fn: impl Fn(&S, &S::Output) -> T,
+    ) -> Vec<T> {
+        let cache = self.cache.borrow();
+        let mut values = cache
+            .get(&TypeId::of::<S>())
+            .map(|any| any.downcast_ref::<HashMap<S, S::Output>>().expect("correct type"))
+            .map(|m| m.iter().map(|(step, output)| map_fn(step, output)).collect::<Vec<_>>())
             .unwrap_or_default();
-        v.sort_by_key(|(s, _)| s.clone());
-        v
+        values.sort();
+        values
     }
 
     pub fn contains<S: Step>(&self) -> bool {