Remove Ord from chalk_ir::interner::DefId

chalk-integration/Cargo.toml

@@ -20,3 +20,4 @@ chalk-solve = { version = "0.76.0-dev.0", path = "../chalk-solve" }
 chalk-recursive = { version = "0.76.0-dev.0", path = "../chalk-recursive" }
 chalk-engine = { version = "0.76.0-dev.0", path = "../chalk-engine" }
 chalk-parse = { version = "0.76.0-dev.0", path = "../chalk-parse" }
+indexmap = "1.7.0"

chalk-integration/src/interner.rs

@@ -52,7 +52,7 @@ impl Debug for ChalkFnAbi {
 
 /// The default "interner" and the only interner used by chalk
 /// itself. In this interner, no interning actually occurs.
-#[derive(Debug, Copy, Clone, Hash, PartialOrd, Ord, PartialEq, Eq)]
+#[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
 pub struct ChalkIr;
 
 impl Interner for ChalkIr {

chalk-integration/src/lowering.rs

@@ -8,8 +8,8 @@ use chalk_ir::{
 };
 use chalk_parse::ast::*;
 use chalk_solve::rust_ir::{self, IntoWhereClauses};
+use indexmap::{indexset, IndexMap, IndexSet};
 use program_lowerer::ProgramLowerer;
-use std::collections::BTreeMap;
 use string_cache::DefaultAtom as Atom;
 use tracing::debug;
 
@@ -53,7 +53,7 @@ impl Lower for Program {
 trait LowerParameterMap {
     fn synthetic_parameters(&self) -> Option<chalk_ir::WithKind<ChalkIr, Ident>>;
     fn declared_parameters(&self) -> &[VariableKind];
-    fn all_parameters(&self) -> Vec<chalk_ir::WithKind<ChalkIr, Ident>> {
+    fn all_parameters(&self) -> indexmap::IndexSet<chalk_ir::WithKind<ChalkIr, Ident>> {
         self.synthetic_parameters()
             .into_iter()
             .chain(self.declared_parameters().iter().map(|id| id.lower()))
@@ -136,7 +136,7 @@ impl Lower for VariableKind {
 }
 
 impl LowerWithEnv for [QuantifiedWhereClause] {
-    type Lowered = Vec<chalk_ir::QuantifiedWhereClause<ChalkIr>>;
+    type Lowered = IndexSet<chalk_ir::QuantifiedWhereClause<ChalkIr>>;
 
     fn lower(&self, env: &Env) -> LowerResult<Self::Lowered> {
         self.iter()
@@ -149,7 +149,7 @@ impl LowerWithEnv for [QuantifiedWhereClause] {
 }
 
 impl LowerWithEnv for WhereClause {
-    type Lowered = Vec<chalk_ir::WhereClause<ChalkIr>>;
+    type Lowered = IndexSet<chalk_ir::WhereClause<ChalkIr>>;
 
     /// Lower from an AST `where` clause to an internal IR.
     /// Some AST `where` clauses can lower to multiple ones, this is why we return a `Vec`.
@@ -158,37 +158,39 @@ impl LowerWithEnv for WhereClause {
     fn lower(&self, env: &Env) -> LowerResult<Self::Lowered> {
         Ok(match self {
             WhereClause::Implemented { trait_ref } => {
-                vec![chalk_ir::WhereClause::Implemented(trait_ref.lower(env)?)]
+                indexset! { chalk_ir::WhereClause::Implemented(trait_ref.lower(env)?)}
+            }
+            WhereClause::ProjectionEq { projection, ty } => {
+                indexset! {
+                    chalk_ir::WhereClause::AliasEq(chalk_ir::AliasEq {
+                        alias: chalk_ir::AliasTy::Projection(projection.lower(env)?),
+                        ty: ty.lower(env)?}),
+                chalk_ir::WhereClause::Implemented(
+                    projection.trait_ref.lower(env)?),
+                }
             }
-            WhereClause::ProjectionEq { projection, ty } => vec![
-                chalk_ir::WhereClause::AliasEq(chalk_ir::AliasEq {
-                    alias: chalk_ir::AliasTy::Projection(projection.lower(env)?),
-                    ty: ty.lower(env)?,
-                }),
-                chalk_ir::WhereClause::Implemented(projection.trait_ref.lower(env)?),
-            ],
             WhereClause::LifetimeOutlives { a, b } => {
-                vec![chalk_ir::WhereClause::LifetimeOutlives(
+                indexset! {chalk_ir::WhereClause::LifetimeOutlives(
                     chalk_ir::LifetimeOutlives {
                         a: a.lower(env)?,
                         b: b.lower(env)?,
                     },
-                )]
+                )}
             }
             WhereClause::TypeOutlives { ty, lifetime } => {
-                vec![chalk_ir::WhereClause::TypeOutlives(
+                indexset! {chalk_ir::WhereClause::TypeOutlives(
                     chalk_ir::TypeOutlives {
                         ty: ty.lower(env)?,
                         lifetime: lifetime.lower(env)?,
                     },
-                )]
+                )}
             }
         })
     }
 }
 
 impl LowerWithEnv for QuantifiedWhereClause {
-    type Lowered = Vec<chalk_ir::QuantifiedWhereClause<ChalkIr>>;
+    type Lowered = IndexSet<chalk_ir::QuantifiedWhereClause<ChalkIr>>;
 
     /// Lower from an AST `where` clause to an internal IR.
     /// Some AST `where` clauses can lower to multiple ones, this is why we return a `Vec`.
@@ -298,7 +300,11 @@ impl LowerWithEnv for (&AdtDefn, chalk_ir::AdtId<ChalkIr>) {
                         Ok(rust_ir::AdtVariantDatum { fields: fields? })
                     })
                     .collect::<LowerResult<_>>()?,
-                where_clauses: adt_defn.where_clauses.lower(env)?,
+                where_clauses: adt_defn
+                    .where_clauses
+                    .lower(env)?
+                    .into_iter()
+                    .collect::<Vec<_>>(),
             })
         })?;
 
@@ -340,7 +346,11 @@ impl LowerWithEnv for (&FnDefn, chalk_ir::FnDefId<ChalkIr>) {
         let (fn_defn, fn_def_id) = self;
 
         let binders = env.in_binders(fn_defn.all_parameters(), |env| {
-            let where_clauses = fn_defn.where_clauses.lower(env)?;
+            let where_clauses = fn_defn
+                .where_clauses
+                .lower(env)?
+                .into_iter()
+                .collect::<Vec<_>>();
 
             let inputs_and_output = env.in_binders(vec![], |env| {
                 let args: LowerResult<_> = fn_defn
@@ -537,12 +547,14 @@ impl LowerWithEnv for QuantifiedInlineBound {
 
     fn lower(&self, env: &Env) -> LowerResult<Self::Lowered> {
         let variable_kinds = self.variable_kinds.iter().map(|k| k.lower());
-        env.in_binders(variable_kinds, |env| self.bound.lower(env))
+        let x = env.in_binders(variable_kinds, |env| self.bound.lower(env))?;
+        //
+        Ok(rust_ir::QuantifiedInlineBound(x))
     }
 }
 
 impl LowerWithEnv for [QuantifiedInlineBound] {
-    type Lowered = Vec<rust_ir::QuantifiedInlineBound<ChalkIr>>;
+    type Lowered = IndexSet<rust_ir::QuantifiedInlineBound<ChalkIr>>;
 
     fn lower(&self, env: &Env) -> LowerResult<Self::Lowered> {
         fn trait_identifier(bound: &InlineBound) -> &Identifier {
@@ -552,20 +564,18 @@ impl LowerWithEnv for [QuantifiedInlineBound] {
             }
         }
 
-        let mut regular_traits = Vec::new();
-        let mut auto_traits = Vec::new();
+        let mut regular_traits = IndexSet::new();
+        let mut auto_traits = IndexSet::new();
 
         for b in self {
             let id = env.lookup_trait(trait_identifier(&b.bound))?;
             if env.auto_trait(id) {
-                auto_traits.push((b, id))
+                auto_traits.insert((b, id));
             } else {
-                regular_traits.push((b, id))
+                regular_traits.insert((b, id));
             }
         }
 
-        auto_traits.sort_by_key(|b| b.1);
-
         regular_traits
             .iter()
             .chain(auto_traits.iter())
@@ -901,7 +911,11 @@ impl LowerWithEnv for (&Impl, ImplId<ChalkIr>, &AssociatedTyValueIds) {
                 ))?;
             }
 
-            let where_clauses = impl_.where_clauses.lower(&env)?;
+            let where_clauses = impl_
+                .where_clauses
+                .lower(&env)?
+                .into_iter()
+                .collect::<Vec<_>>();
             debug!(where_clauses = ?trait_ref);
             Ok(rust_ir::ImplDatumBound {
                 trait_ref,
@@ -988,7 +1002,11 @@ impl LowerWithEnv for (&TraitDefn, chalk_ir::TraitId<ChalkIr>) {
             }
 
             Ok(rust_ir::TraitDatumBound {
-                where_clauses: trait_defn.where_clauses.lower(env)?,
+                where_clauses: trait_defn
+                    .where_clauses
+                    .lower(env)?
+                    .into_iter()
+                    .collect::<Vec<_>>(),
             })
         })?;
 
@@ -1014,7 +1032,7 @@ impl LowerWithEnv for (&TraitDefn, chalk_ir::TraitId<ChalkIr>) {
 
 pub fn lower_goal(goal: &Goal, program: &LoweredProgram) -> LowerResult<chalk_ir::Goal<ChalkIr>> {
     let interner = ChalkIr;
-    let associated_ty_lookups: BTreeMap<_, _> = program
+    let associated_ty_lookups: IndexMap<_, _> = program
         .associated_ty_data
         .iter()
         .map(|(&associated_ty_id, datum)| {
@@ -1052,7 +1070,7 @@ pub fn lower_goal(goal: &Goal, program: &LoweredProgram) -> LowerResult<chalk_ir
         opaque_ty_kinds: &program.opaque_ty_kinds,
         associated_ty_lookups: &associated_ty_lookups,
         foreign_ty_ids: &program.foreign_ty_ids,
-        parameter_map: BTreeMap::new(),
+        parameter_map: IndexMap::new(),
         auto_traits: &auto_traits,
     };
 

chalk-integration/src/lowering/env.rs

@@ -6,31 +6,31 @@ use chalk_ir::{
 use chalk_ir::{cast::Cast, ForeignDefId, WithKind};
 use chalk_parse::ast::*;
 use chalk_solve::rust_ir::AssociatedTyValueId;
-use std::collections::BTreeMap;
+use indexmap::IndexMap;
 
 use crate::error::RustIrError;
 use crate::interner::ChalkIr;
 use crate::{Identifier as Ident, TypeKind};
 
-pub type AdtIds = BTreeMap<Ident, chalk_ir::AdtId<ChalkIr>>;
-pub type FnDefIds = BTreeMap<Ident, chalk_ir::FnDefId<ChalkIr>>;
-pub type ClosureIds = BTreeMap<Ident, chalk_ir::ClosureId<ChalkIr>>;
-pub type TraitIds = BTreeMap<Ident, chalk_ir::TraitId<ChalkIr>>;
-pub type GeneratorIds = BTreeMap<Ident, chalk_ir::GeneratorId<ChalkIr>>;
-pub type OpaqueTyIds = BTreeMap<Ident, chalk_ir::OpaqueTyId<ChalkIr>>;
-pub type AdtKinds = BTreeMap<chalk_ir::AdtId<ChalkIr>, TypeKind>;
-pub type FnDefKinds = BTreeMap<chalk_ir::FnDefId<ChalkIr>, TypeKind>;
-pub type ClosureKinds = BTreeMap<chalk_ir::ClosureId<ChalkIr>, TypeKind>;
-pub type TraitKinds = BTreeMap<chalk_ir::TraitId<ChalkIr>, TypeKind>;
-pub type AutoTraits = BTreeMap<chalk_ir::TraitId<ChalkIr>, bool>;
-pub type OpaqueTyVariableKinds = BTreeMap<chalk_ir::OpaqueTyId<ChalkIr>, TypeKind>;
-pub type GeneratorKinds = BTreeMap<chalk_ir::GeneratorId<ChalkIr>, TypeKind>;
-pub type AssociatedTyLookups = BTreeMap<(chalk_ir::TraitId<ChalkIr>, Ident), AssociatedTyLookup>;
+pub type AdtIds = IndexMap<Ident, chalk_ir::AdtId<ChalkIr>>;
+pub type FnDefIds = IndexMap<Ident, chalk_ir::FnDefId<ChalkIr>>;
+pub type ClosureIds = IndexMap<Ident, chalk_ir::ClosureId<ChalkIr>>;
+pub type TraitIds = IndexMap<Ident, chalk_ir::TraitId<ChalkIr>>;
+pub type GeneratorIds = IndexMap<Ident, chalk_ir::GeneratorId<ChalkIr>>;
+pub type OpaqueTyIds = IndexMap<Ident, chalk_ir::OpaqueTyId<ChalkIr>>;
+pub type AdtKinds = IndexMap<chalk_ir::AdtId<ChalkIr>, TypeKind>;
+pub type FnDefKinds = IndexMap<chalk_ir::FnDefId<ChalkIr>, TypeKind>;
+pub type ClosureKinds = IndexMap<chalk_ir::ClosureId<ChalkIr>, TypeKind>;
+pub type TraitKinds = IndexMap<chalk_ir::TraitId<ChalkIr>, TypeKind>;
+pub type AutoTraits = IndexMap<chalk_ir::TraitId<ChalkIr>, bool>;
+pub type OpaqueTyVariableKinds = IndexMap<chalk_ir::OpaqueTyId<ChalkIr>, TypeKind>;
+pub type GeneratorKinds = IndexMap<chalk_ir::GeneratorId<ChalkIr>, TypeKind>;
+pub type AssociatedTyLookups = IndexMap<(chalk_ir::TraitId<ChalkIr>, Ident), AssociatedTyLookup>;
 pub type AssociatedTyValueIds =
-    BTreeMap<(chalk_ir::ImplId<ChalkIr>, Ident), AssociatedTyValueId<ChalkIr>>;
-pub type ForeignIds = BTreeMap<Ident, chalk_ir::ForeignDefId<ChalkIr>>;
+    IndexMap<(chalk_ir::ImplId<ChalkIr>, Ident), AssociatedTyValueId<ChalkIr>>;
+pub type ForeignIds = IndexMap<Ident, chalk_ir::ForeignDefId<ChalkIr>>;
 
-pub type ParameterMap = BTreeMap<Ident, chalk_ir::WithKind<ChalkIr, BoundVar>>;
+pub type ParameterMap = IndexMap<Ident, chalk_ir::WithKind<ChalkIr, BoundVar>>;
 
 pub type LowerResult<T> = Result<T, RustIrError>;