Remove DefId's Partial/Ord impls

compiler/rustc_hir_analysis/src/outlives/utils.rs

@@ -1,14 +1,14 @@
+use rustc_data_structures::fx::FxIndexMap;
 use rustc_infer::infer::outlives::components::{push_outlives_components, Component};
 use rustc_middle::ty::{self, Region, Ty, TyCtxt};
 use rustc_middle::ty::{GenericArg, GenericArgKind};
 use rustc_span::Span;
 use smallvec::smallvec;
-use std::collections::BTreeMap;
 
 /// Tracks the `T: 'a` or `'a: 'a` predicates that we have inferred
 /// must be added to the struct header.
 pub(crate) type RequiredPredicates<'tcx> =
- BTreeMap<ty::OutlivesPredicate<GenericArg<'tcx>, ty::Region<'tcx>>, Span>;
+ FxIndexMap<ty::OutlivesPredicate<GenericArg<'tcx>, ty::Region<'tcx>>, Span>;
 
 /// Given a requirement `T: 'a` or `'b: 'a`, deduce the
 /// outlives_component and add it to `required_predicates`

compiler/rustc_hir_typeck/src/method/mod.rs

@@ -81,7 +81,7 @@ pub struct NoMatchData<'tcx> {
 
 // A pared down enum describing just the places from which a method
 // candidate can arise. Used for error reporting only.
-#[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+#[derive(Copy, Clone, Debug, Eq, PartialEq)]
 pub enum CandidateSource {
  Impl(DefId),
  Trait(DefId /* trait id */),

compiler/rustc_hir_typeck/src/method/suggest.rs

@@ -49,7 +49,6 @@ use std::borrow::Cow;
 use super::probe::{AutorefOrPtrAdjustment, IsSuggestion, Mode, ProbeScope};
 use super::{CandidateSource, MethodError, NoMatchData};
 use rustc_hir::intravisit::Visitor;
-use std::cmp::{self, Ordering};
 use std::iter;
 
 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
@@ -1186,7 +1185,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  })
  .collect::<Vec<_>>();
  if !inherent_impls_candidate.is_empty() {
- inherent_impls_candidate.sort();
+ inherent_impls_candidate.sort_by_key(|id| self.tcx.def_path_str(id));
  inherent_impls_candidate.dedup();
 
  // number of types to show at most
@@ -1567,7 +1566,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  sources: &mut Vec<CandidateSource>,
  sugg_span: Option<Span>,
  ) {
- sources.sort();
+ sources.sort_by_key(|source| match source {
+ CandidateSource::Trait(id) => (0, self.tcx.def_path_str(id)),
+ CandidateSource::Impl(id) => (1, self.tcx.def_path_str(id)),
+ });
  sources.dedup();
  // Dynamic limit to avoid hiding just one candidate, which is silly.
  let limit = if sources.len() == 5 { 5 } else { 4 };
@@ -2549,7 +2551,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  _ => None,
  })
  .collect();
- preds.sort_by_key(|pred| (pred.def_id(), pred.self_ty()));
+ preds.sort_by_key(|pred| pred.trait_ref.to_string());
  let def_ids = preds
  .iter()
  .filter_map(|pred| match pred.self_ty().kind() {
@@ -2663,7 +2665,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  traits.push(trait_pred.def_id());
  }
  }
- traits.sort();
+ traits.sort_by_key(|id| self.tcx.def_path_str(id));
  traits.dedup();
 
  let len = traits.len();
@@ -2886,7 +2888,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  ) -> bool {
  if !valid_out_of_scope_traits.is_empty() {
  let mut candidates = valid_out_of_scope_traits;
- candidates.sort();
+ candidates.sort_by_key(|id| self.tcx.def_path_str(id));
  candidates.dedup();
 
  // `TryFrom` and `FromIterator` have no methods
@@ -3212,8 +3214,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  }
 
  if !candidates.is_empty() {
- // Sort from most relevant to least relevant.
- candidates.sort_by_key(|&info| cmp::Reverse(info));
+ // Sort local crate results before others
+ candidates
+ .sort_by_key(|&info| (!info.def_id.is_local(), self.tcx.def_path_str(info.def_id)));
  candidates.dedup();
 
  let param_type = match rcvr_ty.kind() {
@@ -3561,33 +3564,11 @@ pub enum SelfSource<'a> {
  MethodCall(&'a hir::Expr<'a> /* rcvr */),
 }
 
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, PartialEq, Eq)]
 pub struct TraitInfo {
  pub def_id: DefId,
 }
 
-impl PartialEq for TraitInfo {
- fn eq(&self, other: &TraitInfo) -> bool {
- self.cmp(other) == Ordering::Equal
- }
-}
-impl Eq for TraitInfo {}
-impl PartialOrd for TraitInfo {
- fn partial_cmp(&self, other: &TraitInfo) -> Option<Ordering> {
- Some(self.cmp(other))
- }
-}
-impl Ord for TraitInfo {
- fn cmp(&self, other: &TraitInfo) -> Ordering {
- // Local crates are more important than remote ones (local:
- // `cnum == 0`), and otherwise we throw in the defid for totality.
-
- let lhs = (other.def_id.krate, other.def_id);
- let rhs = (self.def_id.krate, self.def_id);
- lhs.cmp(&rhs)
- }
-}
-
 /// Retrieves all traits in this crate and any dependent crates,
 /// and wraps them into `TraitInfo` for custom sorting.
 pub fn all_traits(tcx: TyCtxt<'_>) -> Vec<TraitInfo> {

compiler/rustc_infer/src/infer/error_reporting/mod.rs

@@ -1074,7 +1074,8 @@ impl<'tcx> TypeErrCtxt<'_, 'tcx> {
  let (sig, reg) = ty::print::FmtPrinter::new(self.tcx, Namespace::TypeNS)
  .name_all_regions(sig)
  .unwrap();
- let lts: Vec<String> = reg.into_values().map(|kind| kind.to_string()).collect();
+ let lts: Vec<String> =
+ reg.into_items().map(|(_, kind)| kind.to_string()).into_sorted_stable_ord();
  (if lts.is_empty() { String::new() } else { format!("for<{}> ", lts.join(", ")) }, sig)
  };
 

compiler/rustc_middle/src/thir.rs

@@ -1018,7 +1018,7 @@ impl<'tcx> PatRangeBoundary<'tcx> {
  (Finite(mir::Const::Ty(a)), Finite(mir::Const::Ty(b)))
  if matches!(ty.kind(), ty::Uint(_) | ty::Char) =>
  {
- return Some(a.kind().cmp(&b.kind()));
+ return Some(a.to_valtree().cmp(&b.to_valtree()));
  }
  (
  Finite(mir::Const::Val(mir::ConstValue::Scalar(Scalar::Int(a)), _)),

compiler/rustc_middle/src/ty/adt.rs

@@ -18,7 +18,6 @@ use rustc_span::symbol::sym;
 use rustc_target::abi::{ReprOptions, VariantIdx, FIRST_VARIANT};
 
 use std::cell::RefCell;
-use std::cmp::Ordering;
 use std::hash::{Hash, Hasher};
 use std::ops::Range;
 use std::str;
@@ -102,20 +101,6 @@ pub struct AdtDefData {
  repr: ReprOptions,
 }
 
-impl PartialOrd for AdtDefData {
- fn partial_cmp(&self, other: &AdtDefData) -> Option<Ordering> {
- Some(self.cmp(other))
- }
-}
-
-/// There should be only one AdtDef for each `did`, therefore
-/// it is fine to implement `Ord` only based on `did`.
-impl Ord for AdtDefData {
- fn cmp(&self, other: &AdtDefData) -> Ordering {
- self.did.cmp(&other.did)
- }
-}
-
 impl PartialEq for AdtDefData {
  #[inline]
  fn eq(&self, other: &Self) -> bool {
@@ -180,7 +165,7 @@ impl<'a> HashStable<StableHashingContext<'a>> for AdtDefData {
  }
 }
 
-#[derive(Copy, Clone, PartialEq, Eq, Hash, Ord, PartialOrd, HashStable)]
+#[derive(Copy, Clone, PartialEq, Eq, Hash, HashStable)]
 #[rustc_pass_by_value]
 pub struct AdtDef<'tcx>(pub Interned<'tcx, AdtDefData>);
 

compiler/rustc_middle/src/ty/consts.rs

@@ -23,7 +23,7 @@ pub use valtree::*;
 pub type ConstKind<'tcx> = IrConstKind<TyCtxt<'tcx>>;
 
 /// Use this rather than `ConstData`, whenever possible.
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, HashStable)]
+#[derive(Copy, Clone, PartialEq, Eq, Hash, HashStable)]
 #[rustc_pass_by_value]
 pub struct Const<'tcx>(pub(super) Interned<'tcx, WithCachedTypeInfo<ConstData<'tcx>>>);
 
@@ -52,7 +52,7 @@ impl<'tcx> ConstTy<TyCtxt<'tcx>> for Const<'tcx> {
 }
 
 /// Typed constant value.
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Copy, Clone, PartialEq, Eq, Hash)]
 #[derive(HashStable, TyEncodable, TyDecodable)]
 pub struct ConstData<'tcx> {
  pub ty: Ty<'tcx>,

compiler/rustc_middle/src/ty/consts/kind.rs

@@ -7,7 +7,7 @@ use rustc_hir::def_id::DefId;
 use rustc_macros::HashStable;
 
 /// An unevaluated (potentially generic) constant used in the type-system.
-#[derive(Copy, Clone, Eq, PartialEq, PartialOrd, Ord, TyEncodable, TyDecodable)]
+#[derive(Copy, Clone, Eq, PartialEq, TyEncodable, TyDecodable)]
 #[derive(Hash, HashStable, TypeFoldable, TypeVisitable)]
 pub struct UnevaluatedConst<'tcx> {
  pub def: DefId,
@@ -62,7 +62,7 @@ impl<'tcx> UnevaluatedConst<'tcx> {
  }
 }
 
-#[derive(Copy, Clone, Eq, PartialEq, PartialOrd, Ord, Hash)]
+#[derive(Copy, Clone, Eq, PartialEq, Hash)]
 #[derive(HashStable, TyEncodable, TyDecodable, TypeVisitable, TypeFoldable)]
 pub enum Expr<'tcx> {
  Binop(mir::BinOp, Const<'tcx>, Const<'tcx>),

compiler/rustc_middle/src/ty/fold.rs

@@ -2,8 +2,6 @@ use crate::ty::{self, Binder, BoundTy, Ty, TyCtxt, TypeVisitableExt};
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_hir::def_id::DefId;
 
-use std::collections::BTreeMap;
-
 pub use rustc_type_ir::fold::{FallibleTypeFolder, TypeFoldable, TypeFolder, TypeSuperFoldable};
 
 ///////////////////////////////////////////////////////////////////////////
@@ -254,12 +252,12 @@ impl<'tcx> TyCtxt<'tcx> {
  self,
  value: Binder<'tcx, T>,
  mut fld_r: F,
- ) -> (T, BTreeMap<ty::BoundRegion, ty::Region<'tcx>>)
+ ) -> (T, FxIndexMap<ty::BoundRegion, ty::Region<'tcx>>)
  where
  F: FnMut(ty::BoundRegion) -> ty::Region<'tcx>,
  T: TypeFoldable<TyCtxt<'tcx>>,
  {
- let mut region_map = BTreeMap::new();
+ let mut region_map = FxIndexMap::default();
  let real_fld_r = |br: ty::BoundRegion| *region_map.entry(br).or_insert_with(|| fld_r(br));
  let value = self.instantiate_bound_regions_uncached(value, real_fld_r);
  (value, region_map)

compiler/rustc_middle/src/ty/generic_args.rs

@@ -17,7 +17,6 @@ use rustc_type_ir::WithCachedTypeInfo;
 use smallvec::SmallVec;
 
 use core::intrinsics;
-use std::cmp::Ordering;
 use std::marker::PhantomData;
 use std::mem;
 use std::num::NonZero;
@@ -68,7 +67,7 @@ const TYPE_TAG: usize = 0b00;
 const REGION_TAG: usize = 0b01;
 const CONST_TAG: usize = 0b10;
 
-#[derive(Debug, TyEncodable, TyDecodable, PartialEq, Eq, PartialOrd, Ord, HashStable)]
+#[derive(Debug, TyEncodable, TyDecodable, PartialEq, Eq, HashStable)]
 pub enum GenericArgKind<'tcx> {
  Lifetime(ty::Region<'tcx>),
  Type(Ty<'tcx>),
@@ -100,18 +99,6 @@ impl<'tcx> GenericArgKind<'tcx> {
  }
 }
 
-impl<'tcx> Ord for GenericArg<'tcx> {
- fn cmp(&self, other: &GenericArg<'tcx>) -> Ordering {
- self.unpack().cmp(&other.unpack())
- }
-}
-
-impl<'tcx> PartialOrd for GenericArg<'tcx> {
- fn partial_cmp(&self, other: &GenericArg<'tcx>) -> Option<Ordering> {
- Some(self.cmp(other))
- }
-}
-
 impl<'tcx> From<ty::Region<'tcx>> for GenericArg<'tcx> {
  #[inline]
  fn from(r: ty::Region<'tcx>) -> GenericArg<'tcx> {

compiler/rustc_middle/src/ty/mod.rs

@@ -517,7 +517,7 @@ pub struct CReaderCacheKey {
 }
 
 /// Use this rather than `TyKind`, whenever possible.
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, HashStable)]
+#[derive(Copy, Clone, PartialEq, Eq, Hash, HashStable)]
 #[rustc_diagnostic_item = "Ty"]
 #[rustc_pass_by_value]
 pub struct Ty<'tcx>(Interned<'tcx, WithCachedTypeInfo<TyKind<'tcx>>>);
@@ -702,7 +702,7 @@ const TAG_MASK: usize = 0b11;
 const TYPE_TAG: usize = 0b00;
 const CONST_TAG: usize = 0b01;
 
-#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, TyEncodable, TyDecodable)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, TyEncodable, TyDecodable)]
 #[derive(HashStable, TypeFoldable, TypeVisitable)]
 pub enum TermKind<'tcx> {
  Ty(Ty<'tcx>),
@@ -980,7 +980,7 @@ impl PlaceholderLike for PlaceholderType {
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, HashStable)]
-#[derive(TyEncodable, TyDecodable, PartialOrd, Ord)]
+#[derive(TyEncodable, TyDecodable)]
 pub struct BoundConst<'tcx> {
  pub var: BoundVar,
  pub ty: Ty<'tcx>,

compiler/rustc_middle/src/ty/predicate.rs

@@ -192,7 +192,7 @@ impl<'tcx> Clause<'tcx> {
  }
 }
 
-#[derive(Debug, Copy, Clone, PartialEq, PartialOrd, Ord, Eq, Hash, TyEncodable, TyDecodable)]
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, TyEncodable, TyDecodable)]
 #[derive(HashStable, TypeFoldable, TypeVisitable, Lift)]
 pub enum ExistentialPredicate<'tcx> {
  /// E.g., `Iterator`.
@@ -336,7 +336,7 @@ impl<'tcx> ty::List<ty::PolyExistentialPredicate<'tcx>> {
 ///
 /// Trait references also appear in object types like `Foo<U>`, but in
 /// that case the `Self` parameter is absent from the generic parameters.
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, TyEncodable, TyDecodable)]
+#[derive(Copy, Clone, PartialEq, Eq, Hash, TyEncodable, TyDecodable)]
 #[derive(HashStable, TypeFoldable, TypeVisitable, Lift)]
 pub struct TraitRef<'tcx> {
  pub def_id: DefId,
@@ -420,7 +420,7 @@ impl<'tcx> IntoDiagArg for TraitRef<'tcx> {
 /// ```
 /// The generic parameters don't include the erased `Self`, only trait
 /// type and lifetime parameters (`[X, Y]` and `['a, 'b]` above).
-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, TyEncodable, TyDecodable)]
+#[derive(Copy, Clone, PartialEq, Eq, Hash, TyEncodable, TyDecodable)]
 #[derive(HashStable, TypeFoldable, TypeVisitable, Lift)]
 pub struct ExistentialTraitRef<'tcx> {
  pub def_id: DefId,
@@ -476,7 +476,7 @@ impl<'tcx> PolyExistentialTraitRef<'tcx> {
 }
 
 /// A `ProjectionPredicate` for an `ExistentialTraitRef`.
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, TyEncodable, TyDecodable)]
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, TyEncodable, TyDecodable)]
 #[derive(HashStable, TypeFoldable, TypeVisitable, Lift)]
 pub struct ExistentialProjection<'tcx> {
  pub def_id: DefId,

compiler/rustc_middle/src/ty/print/pretty.rs

@@ -10,6 +10,7 @@ use crate::ty::{
 use rustc_apfloat::ieee::{Double, Single};
 use rustc_apfloat::Float;
 use rustc_data_structures::fx::{FxHashMap, FxIndexMap};
+use rustc_data_structures::unord::UnordMap;
 use rustc_hir as hir;
 use rustc_hir::def::{self, CtorKind, DefKind, Namespace};
 use rustc_hir::def_id::{DefIdMap, DefIdSet, ModDefId, CRATE_DEF_ID, LOCAL_CRATE};
@@ -24,7 +25,6 @@ use rustc_target::spec::abi::Abi;
 use smallvec::SmallVec;
 
 use std::cell::Cell;
-use std::collections::BTreeMap;
 use std::fmt::{self, Write as _};
 use std::iter;
 use std::ops::{Deref, DerefMut};
@@ -2537,7 +2537,7 @@ impl<'tcx> FmtPrinter<'_, 'tcx> {
 struct RegionFolder<'a, 'tcx> {
  tcx: TyCtxt<'tcx>,
  current_index: ty::DebruijnIndex,
- region_map: BTreeMap<ty::BoundRegion, ty::Region<'tcx>>,
+ region_map: UnordMap<ty::BoundRegion, ty::Region<'tcx>>,
  name: &'a mut (
  dyn FnMut(
  Option<ty::DebruijnIndex>, // Debruijn index of the folded late-bound region
@@ -2614,7 +2614,7 @@ impl<'tcx> FmtPrinter<'_, 'tcx> {
  pub fn name_all_regions<T>(
  &mut self,
  value: &ty::Binder<'tcx, T>,
- ) -> Result<(T, BTreeMap<ty::BoundRegion, ty::Region<'tcx>>), fmt::Error>
+ ) -> Result<(T, UnordMap<ty::BoundRegion, ty::Region<'tcx>>), fmt::Error>
  where
  T: Print<'tcx, Self> + TypeFoldable<TyCtxt<'tcx>>,
  {
@@ -2691,7 +2691,7 @@ impl<'tcx> FmtPrinter<'_, 'tcx> {
  write!(self, "{var:?}")?;
  }
  start_or_continue(self, "", "> ");
- (value.clone().skip_binder(), BTreeMap::default())
+ (value.clone().skip_binder(), UnordMap::default())
  } else {
  let tcx = self.tcx;
 
@@ -2763,7 +2763,7 @@ impl<'tcx> FmtPrinter<'_, 'tcx> {
  tcx,
  current_index: ty::INNERMOST,
  name: &mut name,
- region_map: BTreeMap::new(),
+ region_map: UnordMap::default(),
  };
  let new_value = value.clone().skip_binder().fold_with(&mut folder);
  let region_map = folder.region_map;