Use lots of indexmaps

Author: pierwill

chalk-solve/src/display/state.rs

@@ -36,7 +36,7 @@ impl Display for InvertedBoundVar {
     }
 }
 
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 enum UnifiedId<I: Interner> {
     AdtId(I::InternedAdtId),
     DefId(I::DefId),
@@ -46,21 +46,21 @@ enum UnifiedId<I: Interner> {
 pub struct IdAliasStore<T> {
     /// Map from the DefIds we've encountered to a u32 alias id unique to all ids
     /// the same name.
-    aliases: BTreeMap<T, u32>,
+    aliases: indexmap::IndexMap<T, u32>,
     /// Map from each name to the next unused u32 alias id.
-    next_unused_for_name: BTreeMap<String, u32>,
+    next_unused_for_name: indexmap::IndexMap<String, u32>,
 }
 
-impl<T: Ord> Default for IdAliasStore<T> {
+impl<T: std::cmp::PartialEq + std::cmp::Eq + std::hash::Hash> Default for IdAliasStore<T> {
     fn default() -> Self {
         IdAliasStore {
-            aliases: BTreeMap::default(),
-            next_unused_for_name: BTreeMap::default(),
+            aliases: indexmap::IndexMap::default(),
+            next_unused_for_name: indexmap::IndexMap::default(),
         }
     }
 }
 
-impl<T: Copy + Ord> IdAliasStore<T> {
+impl<T: Copy + std::cmp::PartialEq + std::cmp::Eq + std::hash::Hash> IdAliasStore<T> {
     fn alias_for_id_name(&mut self, id: T, name: String) -> String {
         let next_unused_for_name = &mut self.next_unused_for_name;
         let alias = *self.aliases.entry(id).or_insert_with(|| {

chalk-solve/src/logging_db.rs

@@ -2,8 +2,8 @@
 //! `.chalk` files containing those definitions.
 use std::{
     borrow::Borrow,
-    cmp::{Ord, Ordering},
-    collections::BTreeSet,
+    // cmp::{Ord, Ordering},
+    // collections::BTreeSet,
     fmt::{self, Debug, Display},
     io::Write,
     marker::PhantomData,
@@ -36,7 +36,7 @@ where
     I: Interner,
 {
     ws: WriterState<I, DB, P>,
-    def_ids: Mutex<BTreeSet<RecordedItemId<I>>>,
+    def_ids: Mutex<indexmap::IndexSet<RecordedItemId<I>>>,
     _phantom: PhantomData<DB>,
 }
 
@@ -535,7 +535,7 @@ where
     }
 }
 
-#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, Debug, Hash)]
 pub enum RecordedItemId<I: Interner> {
     Adt(AdtId<I>),
     Trait(TraitId<I>),
@@ -581,37 +581,37 @@ impl<I: Interner> From<GeneratorId<I>> for RecordedItemId<I> {
     }
 }
 
-/// Utility for implementing Ord for RecordedItemId.
-#[derive(PartialEq, Eq, PartialOrd, Ord)]
-enum OrderedItemId<'a, DefId, AdtId> {
-    DefId(&'a DefId),
-    AdtId(&'a AdtId),
-}
-
-impl<I: Interner> RecordedItemId<I> {
-    /// Extract internal identifier. Allows for absolute ordering matching the
-    /// order in which chalk saw things (and thus reproducing that order in
-    /// printed programs)
-    fn ordered_item_id(&self) -> OrderedItemId<'_, I::DefId, I::InternedAdtId> {
-        match self {
-            RecordedItemId::Trait(TraitId(x))
-            | RecordedItemId::Impl(ImplId(x))
-            | RecordedItemId::OpaqueTy(OpaqueTyId(x))
-            | RecordedItemId::Generator(GeneratorId(x))
-            | RecordedItemId::FnDef(FnDefId(x)) => OrderedItemId::DefId(x),
-            RecordedItemId::Adt(AdtId(x)) => OrderedItemId::AdtId(x),
-        }
-    }
-}
-
-impl<I: Interner> PartialOrd for RecordedItemId<I> {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl<I: Interner> Ord for RecordedItemId<I> {
-    fn cmp(&self, other: &Self) -> Ordering {
-        self.ordered_item_id().cmp(&other.ordered_item_id())
-    }
-}
+// /// Utility for implementing Ord for RecordedItemId.
+// #[derive(PartialEq, Eq, PartialOrd, Ord)]
+// enum OrderedItemId<'a, DefId, AdtId> {
+//     DefId(&'a DefId),
+//     AdtId(&'a AdtId),
+// }
+
+// impl<I: Interner> RecordedItemId<I> {
+//     /// Extract internal identifier. Allows for absolute ordering matching the
+//     /// order in which chalk saw things (and thus reproducing that order in
+//     /// printed programs)
+//     fn ordered_item_id(&self) -> indexmap::IndexMap<I::DefId, I::InternedAdtId> {
+//         match self {
+//             RecordedItemId::Trait(TraitId(x))
+//             | RecordedItemId::Impl(ImplId(x))
+//             | RecordedItemId::OpaqueTy(OpaqueTyId(x))
+//             | RecordedItemId::Generator(GeneratorId(x))
+//             | RecordedItemId::FnDef(FnDefId(x)) => OrderedItemId::DefId(x),
+//             RecordedItemId::Adt(AdtId(x)) => OrderedItemId::AdtId(x),
+//         }
+//     }
+// }
+
+// impl<I: Interner> PartialOrd for RecordedItemId<I> {
+//     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+//         Some(self.cmp(other))
+//     }
+// }
+
+// impl<I: Interner> Ord for RecordedItemId<I> {
+//     fn cmp(&self, other: &Self) -> Ordering {
+//         self.ordered_item_id().cmp(&other.ordered_item_id())
+//     }
+// }

chalk-solve/src/logging_db/id_collector.rs

@@ -6,7 +6,7 @@ use chalk_ir::{
     visit::{SuperVisit, Visit},
     AliasTy, DebruijnIndex, TyKind, WhereClause,
 };
-use std::collections::BTreeSet;
+// use std::collections::BTreeSet;
 use std::ops::ControlFlow;
 
 /// Collects the identifiers needed to resolve all the names for a given
@@ -34,11 +34,11 @@ use std::ops::ControlFlow;
 /// resolution is successful.
 pub fn collect_unrecorded_ids<'i, I: Interner, DB: RustIrDatabase<I>>(
     db: &'i DB,
-    identifiers: &'_ BTreeSet<RecordedItemId<I>>,
-) -> BTreeSet<RecordedItemId<I>> {
+    identifiers: &'_ indexmap::IndexSet<RecordedItemId<I>>,
+) -> indexmap::IndexSet<RecordedItemId<I>> {
     let mut collector = IdCollector {
         db,
-        found_identifiers: BTreeSet::new(),
+        found_identifiers: indexmap::IndexSet::new(),
     };
     for id in identifiers {
         match *id {
@@ -96,7 +96,7 @@ pub fn collect_unrecorded_ids<'i, I: Interner, DB: RustIrDatabase<I>>(
 
 struct IdCollector<'i, I: Interner, DB: RustIrDatabase<I>> {
     db: &'i DB,
-    found_identifiers: BTreeSet<RecordedItemId<I>>,
+    found_identifiers: indexmap::IndexSet<RecordedItemId<I>>,
 }
 
 impl<'i, I: Interner, DB: RustIrDatabase<I>> IdCollector<'i, I, DB> {