use BTreeMap for ty_project::files::Indexed

Author: mtshiba

crates/ty_project/src/db/changes.rs

@@ -52,7 +52,7 @@ impl ProjectDatabase {
             custom_stdlib_changed: false,
         };
         // Paths that were added
-        let mut added_paths = FxHashSet::default();
+        let mut added_paths = BTreeSet::default();
 
         // Deduplicate the `sync` calls. Many file watchers emit multiple events for the same path.
         let mut synced_files = FxHashSet::default();
@@ -317,20 +317,19 @@ impl ProjectDatabase {
             }
         }
 
-        let diagnostics = if let Some(walker) =
-            ProjectFilesWalker::incremental(self, added_paths.unstable_iter())
-        {
-            // Use directory walking to discover newly added files.
-            let (files, diagnostics) = walker.collect_vec(self);
+        let diagnostics =
+            if let Some(walker) = ProjectFilesWalker::incremental(self, added_paths.into_iter()) {
+                // Use directory walking to discover newly added files.
+                let (files, diagnostics) = walker.collect_vec(self);
 
-            for file in files {
-                project.add_file(self, file);
-            }
+                for file in files {
+                    project.add_file(self, file);
+                }
 
-            diagnostics
-        } else {
-            Vec::new()
-        };
+                diagnostics
+            } else {
+                Vec::new()
+            };
 
         // Note: We simply replace all IO related diagnostics here. This isn't ideal, because
         // it removes IO errors that may still be relevant. However, tracking IO errors correctly

crates/ty_project/src/files.rs

@@ -1,9 +1,9 @@
+use std::collections::BTreeSet;
 use std::marker::PhantomData;
 use std::ops::Deref;
 use std::sync::Arc;
 
 use salsa::Setter;
-use ty_python_semantic::FxIndexSet;
 
 use ruff_db::files::File;
 
@@ -127,7 +127,7 @@ impl<'db> LazyFiles<'db> {
     /// Sets the indexed files of a package to `files`.
     pub(super) fn set(
         mut self,
-        files: FxIndexSet<File>,
+        files: BTreeSet<File>,
         diagnostics: Vec<IOErrorDiagnostic>,
     ) -> Indexed<'db> {
         let files = Indexed {
@@ -152,7 +152,7 @@ pub struct Indexed<'db> {
 
 #[derive(Debug, get_size2::GetSize)]
 struct IndexedInner {
-    files: FxIndexSet<File>,
+    files: BTreeSet<File>,
     diagnostics: Vec<IOErrorDiagnostic>,
 }
 
@@ -167,14 +167,14 @@ impl Indexed<'_> {
 }
 
 impl Deref for Indexed<'_> {
-    type Target = FxIndexSet<File>;
+    type Target = BTreeSet<File>;
 
     fn deref(&self) -> &Self::Target {
         &self.inner.files
     }
 }
 
-pub(super) type IndexedIter<'a> = std::iter::Copied<indexmap::set::Iter<'a, File>>;
+pub(super) type IndexedIter<'a> = std::iter::Copied<std::collections::btree_set::Iter<'a, File>>;
 
 impl<'a> IntoIterator for &'a Indexed<'_> {
     type Item = File;
@@ -207,7 +207,7 @@ impl IndexedMut<'_> {
     }
 
     pub(super) fn remove(&mut self, file: File) -> bool {
-        if self.inner_mut().files.swap_remove(&file) {
+        if self.inner_mut().files.remove(&file) {
             self.did_change = true;
             true
         } else {
@@ -251,7 +251,7 @@ impl Drop for IndexedMut<'_> {
 
 #[cfg(test)]
 mod tests {
-    use ty_python_semantic::FxIndexSet;
+    use std::collections::BTreeSet;
 
     use crate::ProjectMetadata;
     use crate::db::Db;
@@ -273,7 +273,7 @@ mod tests {
         let file = system_path_to_file(&db, "test.py").unwrap();
 
         let files = match project.file_set(&db).get() {
-            Index::Lazy(lazy) => lazy.set(FxIndexSet::from_iter([file]), Vec::new()),
+            Index::Lazy(lazy) => lazy.set(BTreeSet::from_iter([file]), Vec::new()),
             Index::Indexed(files) => files,
         };
 

crates/ty_project/src/walk.rs

@@ -4,9 +4,9 @@ use ruff_db::files::{File, system_path_to_file};
 use ruff_db::system::walk_directory::{ErrorKind, WalkDirectoryBuilder, WalkState};
 use ruff_db::system::{SystemPath, SystemPathBuf};
 use ruff_python_ast::PySourceType;
+use std::collections::BTreeSet;
 use std::path::PathBuf;
 use thiserror::Error;
-use ty_python_semantic::FxIndexSet;
 
 /// Filter that decides which files are included in the project.
 ///
@@ -285,7 +285,7 @@ impl<'a> ProjectFilesWalker<'a> {
         )
     }
 
-    pub(crate) fn collect_set(self, db: &dyn Db) -> (FxIndexSet<File>, Vec<IOErrorDiagnostic>) {
+    pub(crate) fn collect_set(self, db: &dyn Db) -> (BTreeSet<File>, Vec<IOErrorDiagnostic>) {
         let (files, diagnostics) = self.collect_vec(db);
         (files.into_iter().collect(), diagnostics)
     }

crates/ty_python_semantic/src/hash.rs

@@ -68,33 +68,35 @@ impl<V: Eq + Hash> FxHashSet<V> {
     #[track_caller]
     #[allow(clippy::iter_without_into_iter)]
     #[deprecated(
-        note = "FxHashSet does not guarantee stable iteration order; use FxIndexSet or unstable_iter() instead"
+        note = "FxHashSet does not guarantee stable iteration order; use BTreeSet or unstable_iter() instead"
     )]
     pub fn iter(&self) -> std::collections::hash_set::Iter<'_, V> {
         panic!(
-            "FxHashSet does not guarantee stable iteration order; use FxIndexSet or unstable_iter() instead"
+            "FxHashSet does not guarantee stable iteration order; use BTreeSet or unstable_iter() instead"
         );
     }
 
     #[track_caller]
     #[allow(clippy::should_implement_trait)]
     #[deprecated(
-        note = "FxHashSet does not guarantee stable iteration order; use FxIndexSet or unstable_into_iter() instead"
+        note = "FxHashSet does not guarantee stable iteration order; use BTreeSet or unstable_into_iter() instead"
     )]
     pub fn into_iter(self) -> std::collections::hash_set::IntoIter<V> {
         panic!(
-            "FxHashSet does not guarantee stable iteration order; use FxIndexSet or unstable_into_iter() instead"
+            "FxHashSet does not guarantee stable iteration order; use BTreeSet or unstable_into_iter() instead"
         );
     }
 }
 
 impl<V: Ord> FxHashSet<V> {
+    /// If you use this often, consider using `BTreeMap` instead of `FxHashMap`.
     pub fn sorted_ref_vec(&self) -> Vec<&V> {
         let mut vec: Vec<&V> = self.0.iter().collect();
         vec.sort();
         vec
     }
 
+    /// If you use this often, consider using `BTreeMap` instead of `FxHashMap`.
     pub fn into_sorted_vec(self) -> Vec<V> {
         let mut vec: Vec<V> = self.0.into_iter().collect();
         vec.sort();
@@ -199,83 +201,113 @@ impl<K: Eq + Hash, V> FxHashMap<K, V> {
     #[track_caller]
     #[allow(clippy::iter_without_into_iter)]
     #[deprecated(
-        note = "FxHashMap does not guarantee stable iteration order; use FxIndexMap or unstable_iter() instead"
+        note = "FxHashMap does not guarantee stable iteration order; use BTreeMap or unstable_iter() instead"
     )]
     pub fn iter(&self) -> std::collections::hash_map::Iter<'_, K, V> {
         panic!(
-            "FxHashMap does not guarantee stable iteration order; use FxIndexMap or unstable_iter() instead"
+            "FxHashMap does not guarantee stable iteration order; use BTreeMap or unstable_iter() instead"
         );
     }
 
     #[track_caller]
     #[deprecated(
-        note = "FxHashMap does not guarantee stable iteration order; use FxIndexMap or unstable_keys() instead"
+        note = "FxHashMap does not guarantee stable iteration order; use BTreeMap or unstable_keys() instead"
     )]
     pub fn keys(&self) -> std::collections::hash_map::Keys<'_, K, V> {
         panic!(
-            "FxHashMap does not guarantee stable iteration order; use FxIndexMap or unstable_keys() instead"
+            "FxHashMap does not guarantee stable iteration order; use BTreeMap or unstable_keys() instead"
         );
     }
 
     #[track_caller]
     #[deprecated(
-        note = "FxHashMap does not guarantee stable iteration order; use FxIndexMap or unstable_values() instead"
+        note = "FxHashMap does not guarantee stable iteration order; use BTreeMap or unstable_values() instead"
     )]
     pub fn values(&self) -> std::collections::hash_map::Values<'_, K, V> {
         panic!(
-            "FxHashMap does not guarantee stable iteration order; use FxIndexMap or unstable_values() instead"
+            "FxHashMap does not guarantee stable iteration order; use BTreeMap or unstable_values() instead"
         );
     }
 
     #[track_caller]
     #[allow(clippy::iter_without_into_iter)]
     #[deprecated(
-        note = "FxHashMap does not guarantee stable iteration order; use FxIndexMap or unstable_iter_mut() instead"
+        note = "FxHashMap does not guarantee stable iteration order; use BTreeMap or unstable_iter_mut() instead"
     )]
     pub fn iter_mut(&mut self) -> std::collections::hash_map::IterMut<'_, K, V> {
         panic!(
-            "FxHashMap does not guarantee stable iteration order; use FxIndexMap or unstable_iter_mut() instead"
+            "FxHashMap does not guarantee stable iteration order; use FxIndexMap/BTreeMap or unstable_iter_mut() instead"
         );
     }
 
     #[track_caller]
     #[deprecated(
-        note = "FxHashMap does not guarantee stable iteration order; use FxIndexMap or unstable_values_mut() instead"
+        note = "FxHashMap does not guarantee stable iteration order; use BTreeMap or unstable_values_mut() instead"
     )]
     pub fn values_mut(&mut self) -> std::collections::hash_map::ValuesMut<'_, K, V> {
         panic!(
-            "FxHashMap does not guarantee stable iteration order; use FxIndexMap or unstable_values_mut() instead"
+            "FxHashMap does not guarantee stable iteration order; use BTreeMap or unstable_values_mut() instead"
         );
     }
 
     #[track_caller]
     #[allow(clippy::should_implement_trait)]
     #[deprecated(
-        note = "FxHashMap does not guarantee stable iteration order; use FxIndexMap or unstable_into_iter() instead"
+        note = "FxHashMap does not guarantee stable iteration order; use BTreeMap or unstable_into_iter() instead"
     )]
     pub fn into_iter(self) -> std::collections::hash_map::IntoIter<K, V> {
         panic!(
-            "FxHashMap does not guarantee stable iteration order; use FxIndexMap or unstable_into_iter() instead"
+            "FxHashMap does not guarantee stable iteration order; use BTreeMap or unstable_into_iter() instead"
         );
     }
 
     #[track_caller]
     #[deprecated(
-        note = "FxHashMap does not guarantee stable iteration order; use FxIndexMap or unstable_into_keys() instead"
+        note = "FxHashMap does not guarantee stable iteration order; use BTreeMap or unstable_into_keys() instead"
     )]
     pub fn into_keys(self) -> std::collections::hash_map::IntoKeys<K, V> {
         panic!(
-            "FxHashMap does not guarantee stable iteration order; use FxIndexMap or unstable_into_keys() instead"
+            "FxHashMap does not guarantee stable iteration order; use BTreeMap or unstable_into_keys() instead"
         );
     }
 
     #[track_caller]
     #[deprecated(
-        note = "FxHashMap does not guarantee stable iteration order; use FxIndexMap or unstable_into_values() instead"
+        note = "FxHashMap does not guarantee stable iteration order; use BTreeMap or unstable_into_values() instead"
     )]
     pub fn into_values(self) -> std::collections::hash_map::IntoValues<K, V> {
         panic!(
-            "FxHashMap does not guarantee stable iteration order; use FxIndexMap or unstable_into_values() instead"
+            "FxHashMap does not guarantee stable iteration order; use BTreeMap or unstable_into_values() instead"
         );
     }
 }
+
+impl<K: Ord, V> FxHashMap<K, V> {
+    /// If you use this often, consider using `BTreeMap` instead of `FxHashMap`.
+    pub fn sorted_key_ref_vec(&self) -> Vec<&K> {
+        let mut vec: Vec<&K> = self.0.keys().collect();
+        vec.sort();
+        vec
+    }
+
+    /// If you use this often, consider using `BTreeMap` instead of `FxHashMap`.
+    pub fn into_sorted_key_vec(self) -> Vec<K> {
+        let mut vec: Vec<K> = self.0.into_keys().collect();
+        vec.sort();
+        vec
+    }
+
+    /// If you use this often, consider using `BTreeMap` instead of `FxHashMap`.
+    pub fn sorted_ref_vec(&self) -> Vec<(&K, &V)> {
+        let mut vec: Vec<(&K, &V)> = self.0.iter().collect();
+        vec.sort_by(|(k1, _), (k2, _)| k1.cmp(k2));
+        vec
+    }
+
+    /// If you use this often, consider using `BTreeMap` instead of `FxHashMap`.
+    pub fn into_sorted_vec(self) -> Vec<(K, V)> {
+        let mut vec: Vec<(K, V)> = self.0.into_iter().collect();
+        vec.sort_by(|(k1, _), (k2, _)| k1.cmp(k2));
+        vec
+    }
+}