Auto merge of #52672 - ljedrz:unstable_sorts, r=<try>

Prefer sort_unstable*() over sort*()

Since `sort_unstable` is considered typically faster than the regular `sort` ([benchmarks](#40601 (comment))), it might be a good idea to check for potential wins in the compiler.

Author: bors

src/librustc/hir/lowering.rs

@@ -4803,6 +4803,6 @@ fn body_ids(bodies: &BTreeMap<hir::BodyId, hir::Body>) -> Vec<hir::BodyId> {
     // Sorting by span ensures that we get things in order within a
     // file, and also puts the files in a sensible order.
     let mut body_ids: Vec<_> = bodies.keys().cloned().collect();
-    body_ids.sort_by_key(|b| bodies[b].value.span);
+    body_ids.sort_unstable_by_key(|b| bodies[b].value.span);
     body_ids
 }

src/librustc/hir/pat_util.rs

@@ -157,7 +157,7 @@ impl hir::Pat {
             }
             true
         });
-        variants.sort();
+        variants.sort_unstable();
         variants.dedup();
         variants
     }

src/librustc/infer/error_reporting/mod.rs

@@ -434,7 +434,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
         };
 
         // sort the errors by span, for better error message stability.
-        errors.sort_by_key(|u| match *u {
+        errors.sort_unstable_by_key(|u| match *u {
             RegionResolutionError::ConcreteFailure(ref sro, _, _) => sro.span(),
             RegionResolutionError::GenericBoundFailure(ref sro, _, _) => sro.span(),
             RegionResolutionError::SubSupConflict(ref rvo, _, _, _, _) => rvo.span(),

src/librustc/infer/lexical_region_resolve/mod.rs

@@ -568,8 +568,8 @@ impl<'cx, 'gcx, 'tcx> LexicalResolver<'cx, 'gcx, 'tcx> {
                 _ => 2,
             }
         }
-        lower_bounds.sort_by_key(region_order_key);
-        upper_bounds.sort_by_key(region_order_key);
+        lower_bounds.sort_unstable_by_key(region_order_key);
+        upper_bounds.sort_unstable_by_key(region_order_key);
 
         for lower_bound in &lower_bounds {
             for upper_bound in &upper_bounds {

src/librustc/middle/resolve_lifetime.rs

@@ -1426,7 +1426,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
             .collect();
 
         // ensure that we issue lints in a repeatable order
-        def_ids.sort_by_key(|&def_id| self.tcx.def_path_hash(def_id));
+        def_ids.sort_unstable_by_key(|&def_id| self.tcx.def_path_hash(def_id));
 
         for def_id in def_ids {
             debug!(

src/librustc/session/code_stats.rs

@@ -100,7 +100,7 @@ impl CodeStats {
 
         // Primary sort: large-to-small.
         // Secondary sort: description (dictionary order)
-        sorted.sort_by(|info1, info2| {
+        sorted.sort_unstable_by(|info1, info2| {
             // (reversing cmp order to get large-to-small ordering)
             match info2.overall_size.cmp(&info1.overall_size) {
                 Ordering::Equal => info1.type_description.cmp(&info2.type_description),
@@ -151,7 +151,7 @@ impl CodeStats {
 
                 // We want to print fields by increasing offset.
                 let mut fields = fields.clone();
-                fields.sort_by_key(|f| f.offset);
+                fields.sort_unstable_by_key(|f| f.offset);
 
                 for field in fields.iter() {
                     let FieldInfo { ref name, offset, size, align } = *field;

src/librustc/session/config.rs

@@ -2401,7 +2401,7 @@ mod dep_tracking {
             impl DepTrackingHash for Vec<$t> {
                 fn hash(&self, hasher: &mut DefaultHasher, error_format: ErrorOutputType) {
                     let mut elems: Vec<&$t> = self.iter().collect();
-                    elems.sort();
+                    elems.sort_unstable();
                     Hash::hash(&elems.len(), hasher);
                     for (index, elem) in elems.iter().enumerate() {
                         Hash::hash(&index, hasher);

src/librustc/ty/layout.rs

@@ -288,15 +288,15 @@ impl<'a, 'tcx> LayoutCx<'tcx, TyCtxt<'a, 'tcx, 'tcx>> {
                 match kind {
                     StructKind::AlwaysSized |
                     StructKind::MaybeUnsized => {
-                        optimizing.sort_by_key(|&x| {
+                        optimizing.sort_unstable_by_key(|&x| {
                             // Place ZSTs first to avoid "interesting offsets",
                             // especially with only one or two non-ZST fields.
                             let f = &fields[x as usize];
                             (!f.is_zst(), cmp::Reverse(field_align(f)))
                         });
                     }
                     StructKind::Prefixed(..) => {
-                        optimizing.sort_by_key(|&x| field_align(&fields[x as usize]));
+                        optimizing.sort_unstable_by_key(|&x| field_align(&fields[x as usize]));
                     }
                 }
             }

src/librustc/util/time_graph.rs

@@ -127,7 +127,7 @@ impl TimeGraph {
         let mut threads: Vec<PerThread> =
             table.values().map(|data| data.clone()).collect();
 
-        threads.sort_by_key(|timeline| timeline.timings[0].start);
+        threads.sort_unstable_by_key(|timeline| timeline.timings[0].start);
 
         let earliest_instant = threads[0].timings[0].start;
         let latest_instant = threads.iter()

src/librustc_codegen_llvm/back/write.rs

@@ -1923,7 +1923,7 @@ fn start_executing_work(tcx: TyCtxt,
         // Regardless of what order these modules completed in, report them to
         // the backend in the same order every time to ensure that we're handing
         // out deterministic results.
-        compiled_modules.sort_by(|a, b| a.name.cmp(&b.name));
+        compiled_modules.sort_unstable_by(|a, b| a.name.cmp(&b.name));
 
         let compiled_metadata_module = compiled_metadata_module
             .expect("Metadata module not compiled?");