switch from IndexMap to OrderMap everywhere

Author: oconnor663

Cargo.lock

@@ -88,7 +88,7 @@ etcetera = { version = "0.11.0" }
 fern = { version = "0.7.0" }
 filetime = { version = "0.2.23" }
 getrandom = { version = "0.3.1" }
-get-size2 = { version = "0.7.0", features = [
+get-size2 = { version = "0.7.3", features = [
     "derive",
     "smallvec",
     "hashbrown",
@@ -129,7 +129,7 @@ memchr = { version = "2.7.1" }
 mimalloc = { version = "0.1.39" }
 natord = { version = "1.0.9" }
 notify = { version = "8.0.0" }
-ordermap = { version = "0.5.0" }
+ordermap = { version = "1.0.0" }
 path-absolutize = { version = "3.1.1" }
 path-slash = { version = "0.2.1" }
 pathdiff = { version = "0.2.1" }
@@ -146,7 +146,7 @@ regex-automata = { version = "0.4.9" }
 rustc-hash = { version = "2.0.0" }
 rustc-stable-hash = { version = "0.1.2" }
 # When updating salsa, make sure to also update the revision in `fuzz/Cargo.toml`
-salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "59aa1075e837f5deb0d6ffb24b68fedc0f4bc5e0", default-features = false, features = [
+salsa = { git = "https://github.com/salsa-rs/salsa.git", rev = "55e5e7d32fa3fc189276f35bb04c9438f9aedbd1", default-features = false, features = [
     "compact_str",
     "macros",
     "salsa_unstable",

Cargo.toml

@@ -33,11 +33,10 @@ camino = { workspace = true }
 colored = { workspace = true }
 compact_str = { workspace = true }
 drop_bomb = { workspace = true }
-get-size2 = { workspace = true, features = ["indexmap"]}
-indexmap = { workspace = true }
+get-size2 = { workspace = true, features = ["ordermap"] }
 itertools = { workspace = true }
 ordermap = { workspace = true }
-salsa = { workspace = true, features = ["compact_str"] }
+salsa = { workspace = true, features = ["compact_str", "ordermap"] }
 thiserror = { workspace = true }
 tracing = { workspace = true }
 rustc-hash = { workspace = true }

crates/ty_python_semantic/Cargo.toml

@@ -60,8 +60,6 @@ pub mod pull_types;
 
 type FxOrderMap<K, V> = ordermap::map::OrderMap<K, V, BuildHasherDefault<FxHasher>>;
 type FxOrderSet<V> = ordermap::set::OrderSet<V, BuildHasherDefault<FxHasher>>;
-type FxIndexMap<K, V> = indexmap::IndexMap<K, V, BuildHasherDefault<FxHasher>>;
-type FxIndexSet<V> = indexmap::IndexSet<V, BuildHasherDefault<FxHasher>>;
 
 /// Returns the default registry with all known semantic lints.
 pub fn default_lint_registry() -> &'static LintRegistry {

crates/ty_python_semantic/src/lib.rs

@@ -549,7 +549,7 @@ impl SearchPaths {
         // (Paths may, however, *overlap* -- e.g. you could have both `src/`
         // and `src/foo` as module resolution paths simultaneously.)
         //
-        // This code doesn't use an `IndexSet` because the key is the system
+        // This code doesn't use an `OrdersetSet` because the key is the system
         // path and not the search root.
         //
         // [`sys.path` at runtime]: https://docs.python.org/3/library/site.html#module-site

crates/ty_python_semantic/src/module_resolver/resolver.rs

@@ -480,13 +480,13 @@ pub(crate) fn place_from_declarations<'db>(
 
 type DeclaredTypeAndConflictingTypes<'db> = (
     TypeAndQualifiers<'db>,
-    Option<Box<indexmap::set::Slice<Type<'db>>>>,
+    Option<Box<ordermap::set::Slice<Type<'db>>>>,
 );
 
 /// The result of looking up a declared type from declarations; see [`place_from_declarations`].
 pub(crate) struct PlaceFromDeclarationsResult<'db> {
     place_and_quals: PlaceAndQualifiers<'db>,
-    conflicting_types: Option<Box<indexmap::set::Slice<Type<'db>>>>,
+    conflicting_types: Option<Box<ordermap::set::Slice<Type<'db>>>>,
     /// Contains the first reachable declaration for this place, if any.
     /// This field is used for backreferences in diagnostics.
     pub(crate) first_declaration: Option<Definition<'db>>,
@@ -495,7 +495,7 @@ pub(crate) struct PlaceFromDeclarationsResult<'db> {
 impl<'db> PlaceFromDeclarationsResult<'db> {
     fn conflict(
         place_and_quals: PlaceAndQualifiers<'db>,
-        conflicting_types: Box<indexmap::set::Slice<Type<'db>>>,
+        conflicting_types: Box<ordermap::set::Slice<Type<'db>>>,
         first_declaration: Option<Definition<'db>>,
     ) -> Self {
         PlaceFromDeclarationsResult {
@@ -513,7 +513,7 @@ impl<'db> PlaceFromDeclarationsResult<'db> {
         self,
     ) -> (
         PlaceAndQualifiers<'db>,
-        Option<Box<indexmap::set::Slice<Type<'db>>>>,
+        Option<Box<ordermap::set::Slice<Type<'db>>>>,
     ) {
         (self.place_and_quals, self.conflicting_types)
     }

crates/ty_python_semantic/src/place.rs

@@ -16,7 +16,7 @@ use std::{fmt, sync::Arc};
 
 use crate::{PythonVersionFileSource, PythonVersionSource, PythonVersionWithSource};
 use camino::Utf8Component;
-use indexmap::IndexSet;
+use ordermap::OrderSet;
 use ruff_annotate_snippets::{Level, Renderer, Snippet};
 use ruff_db::system::{System, SystemPath, SystemPathBuf};
 use ruff_python_ast::PythonVersion;
@@ -39,15 +39,15 @@ type StdlibDiscoveryResult<T> = Result<T, StdlibDiscoveryError>;
 /// (which could be another virtual environment or a system installation,
 /// and which could itself have multiple `site-packages` directories).
 ///
-/// We use an `IndexSet` here to guard against the (very remote)
+/// We use an `OrderSet` here to guard against the (very remote)
 /// possibility that an environment might somehow be marked as being
 /// both a `--system-site-packages` virtual environment *and* an
 /// ephemeral environment that extends the system environment. If this
 /// were the case, the system environment's `site-packages` directory
 /// *might* be added to the `SitePackagesPaths` twice, but we wouldn't
 /// want duplicates to appear in this set.
 #[derive(Debug, PartialEq, Eq, Default)]
-pub struct SitePackagesPaths(IndexSet<SystemPathBuf>);
+pub struct SitePackagesPaths(OrderSet<SystemPathBuf>);
 
 impl SitePackagesPaths {
     fn is_empty(&self) -> bool {
@@ -128,13 +128,13 @@ impl fmt::Display for SitePackagesPaths {
 
 impl<const N: usize> From<[SystemPathBuf; N]> for SitePackagesPaths {
     fn from(paths: [SystemPathBuf; N]) -> Self {
-        Self(IndexSet::from(paths))
+        Self(OrderSet::from(paths))
     }
 }
 
 impl IntoIterator for SitePackagesPaths {
     type Item = SystemPathBuf;
-    type IntoIter = indexmap::set::IntoIter<SystemPathBuf>;
+    type IntoIter = ordermap::set::IntoIter<SystemPathBuf>;
 
     fn into_iter(self) -> Self::IntoIter {
         self.0.into_iter()

crates/ty_python_semantic/src/site_packages.rs

@@ -41,7 +41,7 @@ use crate::types::{
     determine_upper_bound,
 };
 use crate::{
-    Db, FxIndexMap, FxIndexSet, FxOrderSet, Program,
+    Db, FxOrderMap, FxOrderSet, Program,
     module_resolver::file_to_module,
     place::{
         Definedness, LookupError, LookupResult, Place, PlaceAndQualifiers, known_module_symbol,
@@ -59,8 +59,8 @@ use crate::{
         definition_expression_type,
     },
 };
-use indexmap::IndexSet;
 use itertools::Itertools as _;
+use ordermap::OrderSet;
 use ruff_db::diagnostic::Span;
 use ruff_db::files::File;
 use ruff_db::parsed::{ParsedModuleRef, parsed_module};
@@ -158,8 +158,8 @@ fn fields_cycle_initial<'db>(
     _self: ClassLiteral<'db>,
     _specialization: Option<Specialization<'db>>,
     _field_policy: CodeGeneratorKind<'db>,
-) -> FxIndexMap<Name, Field<'db>> {
-    FxIndexMap::default()
+) -> FxOrderMap<Name, Field<'db>> {
+    FxOrderMap::default()
 }
 
 /// A category of classes with code generation capabilities (with synthesized methods).
@@ -875,8 +875,8 @@ impl<'db> ClassType<'db> {
                 specialization
                     .and_then(|spec| spec.tuple(db))
                     .map(|tuple| {
-                        let mut element_type_to_indices: FxIndexMap<Type<'db>, Vec<i64>> =
-                            FxIndexMap::default();
+                        let mut element_type_to_indices: FxOrderMap<Type<'db>, Vec<i64>> =
+                            FxOrderMap::default();
 
                         match tuple {
                             // E.g. for `tuple[int, str]`, we will generate the following overloads:
@@ -1578,10 +1578,10 @@ impl<'db> ClassLiteral<'db> {
     pub(crate) fn typevars_referenced_in_definition(
         self,
         db: &'db dyn Db,
-    ) -> FxIndexSet<BoundTypeVarInstance<'db>> {
+    ) -> FxOrderSet<BoundTypeVarInstance<'db>> {
         #[derive(Default)]
         struct CollectTypeVars<'db> {
-            typevars: RefCell<FxIndexSet<BoundTypeVarInstance<'db>>>,
+            typevars: RefCell<FxOrderSet<BoundTypeVarInstance<'db>>>,
             recursion_guard: TypeCollector<'db>,
         }
 
@@ -3004,7 +3004,7 @@ impl<'db> ClassLiteral<'db> {
         db: &'db dyn Db,
         specialization: Option<Specialization<'db>>,
         field_policy: CodeGeneratorKind<'db>,
-    ) -> FxIndexMap<Name, Field<'db>> {
+    ) -> FxOrderMap<Name, Field<'db>> {
         if field_policy == CodeGeneratorKind::NamedTuple {
             // NamedTuples do not allow multiple inheritance, so it is sufficient to enumerate the
             // fields of this class only.
@@ -3052,8 +3052,8 @@ impl<'db> ClassLiteral<'db> {
         db: &'db dyn Db,
         specialization: Option<Specialization<'db>>,
         field_policy: CodeGeneratorKind,
-    ) -> FxIndexMap<Name, Field<'db>> {
-        let mut attributes = FxIndexMap::default();
+    ) -> FxOrderMap<Name, Field<'db>> {
+        let mut attributes = FxOrderMap::default();
 
         let class_body_scope = self.body_scope(db);
         let table = place_table(db, class_body_scope);
@@ -3748,8 +3748,8 @@ impl<'db> ClassLiteral<'db> {
         fn is_cyclically_defined_recursive<'db>(
             db: &'db dyn Db,
             class: ClassLiteral<'db>,
-            classes_on_stack: &mut IndexSet<ClassLiteral<'db>>,
-            visited_classes: &mut IndexSet<ClassLiteral<'db>>,
+            classes_on_stack: &mut OrderSet<ClassLiteral<'db>>,
+            visited_classes: &mut OrderSet<ClassLiteral<'db>>,
         ) -> bool {
             let mut result = false;
             for explicit_base in class.explicit_bases(db) {
@@ -3778,8 +3778,8 @@ impl<'db> ClassLiteral<'db> {
 
         tracing::trace!("Class::inheritance_cycle: {}", self.name(db));
 
-        let visited_classes = &mut IndexSet::new();
-        if !is_cyclically_defined_recursive(db, self, &mut IndexSet::new(), visited_classes) {
+        let visited_classes = &mut OrderSet::new();
+        if !is_cyclically_defined_recursive(db, self, &mut OrderSet::new(), visited_classes) {
             None
         } else if visited_classes.contains(&self) {
             Some(InheritanceCycle::Participant)

crates/ty_python_semantic/src/types/class.rs

@@ -26,7 +26,7 @@ use std::marker::PhantomData;
 
 use rustc_hash::FxHashMap;
 
-use crate::FxIndexSet;
+use crate::FxOrderSet;
 use crate::types::Type;
 
 pub(crate) type TypeTransformer<'db, Tag> = CycleDetector<Tag, Type<'db>, Type<'db>>;
@@ -48,7 +48,7 @@ pub struct CycleDetector<Tag, T, R> {
     /// If the type we're visiting is present in `seen`, it indicates that we've hit a cycle (due
     /// to a recursive type); we need to immediately short circuit the whole operation and return
     /// the fallback value. That's why we pop items off the end of `seen` after we've visited them.
-    seen: RefCell<FxIndexSet<T>>,
+    seen: RefCell<FxOrderSet<T>>,
 
     /// Unlike `seen`, this field is a pure performance optimisation (and an essential one). If the
     /// type we're trying to normalize is present in `cache`, it doesn't necessarily mean we've hit
@@ -66,7 +66,7 @@ pub struct CycleDetector<Tag, T, R> {
 impl<Tag, T: Hash + Eq + Clone, R: Clone> CycleDetector<Tag, T, R> {
     pub fn new(fallback: R) -> Self {
         CycleDetector {
-            seen: RefCell::new(FxIndexSet::default()),
+            seen: RefCell::new(FxOrderSet::default()),
             cache: RefCell::new(FxHashMap::default()),
             fallback,
             _tag: PhantomData,