import indexmap

chalk-solve/src/coherence.rs

@@ -7,6 +7,8 @@ use chalk_ir::{self, ImplId, TraitId};
 use std::fmt;
 use std::sync::Arc;
 
+use indexmap::IndexMap;
+
 pub mod orphan;
 mod solve;
 
@@ -41,13 +43,13 @@ impl<I: Interner> std::error::Error for CoherenceError<I> {}
 /// This basically encodes which impls specialize one another.
 #[derive(Clone, Debug, Default, PartialEq, Eq)]
 pub struct SpecializationPriorities<I: Interner> {
-    map: indexmap::IndexMap<ImplId<I>, SpecializationPriority>,
+    map: IndexMap<ImplId<I>, SpecializationPriority>,
 }
 
 impl<I: Interner> SpecializationPriorities<I> {
     pub fn new() -> Self {
         Self {
-            map: indexmap::IndexMap::new(),
+            map: IndexMap::new(),
         }
     }
 

chalk-solve/src/display/state.rs

@@ -1,4 +1,3 @@
-//! Persistent state passed down between writers.
 //!
 //! This is essentially `InternalWriterState` and other things supporting that.
 use std::{
@@ -12,6 +11,7 @@ use std::{
 
 use crate::RustIrDatabase;
 use chalk_ir::{interner::Interner, *};
+use indexmap::IndexMap;
 use itertools::Itertools;
 
 /// Like a BoundVar, but with the debrujin index inverted so as to create a
@@ -46,15 +46,15 @@ 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: indexmap::IndexMap<T, u32>,
+    aliases: IndexMap<T, u32>,
     /// Map from each name to the next unused u32 alias id.
     next_unused_for_name: BTreeMap<String, u32>,
 }
 
 impl<T> Default for IdAliasStore<T> {
     fn default() -> Self {
         IdAliasStore {
-            aliases: indexmap::IndexMap::default(),
+            aliases: IndexMap::default(),
             next_unused_for_name: BTreeMap::default(),
         }
     }

chalk-solve/src/logging_db.rs

@@ -16,6 +16,8 @@ use crate::{
 };
 use chalk_ir::{interner::Interner, *};
 
+use indexmap::IndexSet;
+
 mod id_collector;
 
 /// Wraps another `RustIrDatabase` (`DB`) and records which definitions are
@@ -34,7 +36,7 @@ where
     I: Interner,
 {
     ws: WriterState<I, DB, P>,
-    def_ids: Mutex<indexmap::IndexSet<RecordedItemId<I>>>,
+    def_ids: Mutex<IndexSet<RecordedItemId<I>>>,
     _phantom: PhantomData<DB>,
 }
 

chalk-solve/src/logging_db/id_collector.rs

@@ -8,6 +8,8 @@ use chalk_ir::{
 };
 use std::ops::ControlFlow;
 
+use indexmap::IndexSet;
+
 /// Collects the identifiers needed to resolve all the names for a given
 /// set of identifers, excluding identifiers we already have.
 ///
@@ -33,11 +35,11 @@ use std::ops::ControlFlow;
 /// resolution is successful.
 pub fn collect_unrecorded_ids<'i, I: Interner, DB: RustIrDatabase<I>>(
     db: &'i DB,
-    identifiers: &'_ indexmap::IndexSet<RecordedItemId<I>>,
-) -> indexmap::IndexSet<RecordedItemId<I>> {
+    identifiers: &'_ IndexSet<RecordedItemId<I>>,
+) -> IndexSet<RecordedItemId<I>> {
     let mut collector = IdCollector {
         db,
-        found_identifiers: indexmap::IndexSet::new(),
+        found_identifiers: IndexSet::new(),
     };
     for id in identifiers {
         match *id {
@@ -95,7 +97,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: indexmap::IndexSet<RecordedItemId<I>>,
+    found_identifiers: IndexSet<RecordedItemId<I>>,
 }
 
 impl<'i, I: Interner, DB: RustIrDatabase<I>> IdCollector<'i, I, DB> {