add StableKey

Author: mtshiba

Cargo.lock

@@ -325,7 +325,7 @@ impl<'ast> MembersInScope<'ast> {
         let model = SemanticModel::new(db, file);
         let map = model
             .members_in_scope_at(node)
-            .unstable_into_iter()
+            .stable_into_iter()
             .map(|(name, memberdef)| {
                 let Some(def) = memberdef.definition else {
                     return (name, MemberInScope::other(memberdef.ty));

crates/ty_ide/src/importer.rs

@@ -318,7 +318,7 @@ impl ProjectDatabase {
         }
 
         let diagnostics = if let Some(walker) =
-            ProjectFilesWalker::incremental(self, added_paths.unstable_iter())
+            ProjectFilesWalker::incremental(self, added_paths.stable_iter())
         {
             // Use directory walking to discover newly added files.
             let (files, diagnostics) = walker.collect_vec(self);

crates/ty_project/src/db/changes.rs

@@ -52,6 +52,7 @@ memchr = { workspace = true }
 strum = { workspace = true }
 strum_macros = { workspace = true }
 strsim = "0.11.1"
+url = { workspace = true }
 
 [dev-dependencies]
 ruff_db = { workspace = true, features = ["testing", "os"] }

crates/ty_python_semantic/Cargo.toml

@@ -102,7 +102,7 @@ impl<'db> DunderAllNamesCollector<'db> {
                     return false;
                 };
                 self.names
-                    .extend(module_dunder_all_names.unstable_iter().cloned());
+                    .extend(module_dunder_all_names.stable_iter().cloned());
                 true
             }
 
@@ -239,7 +239,7 @@ impl<'db> StatementVisitor<'db> for DunderAllNamesCollector<'db> {
 
                         if all_names.contains(&Name::new_static("__all__")) {
                             self.update_origin(DunderAllOrigin::StarImport);
-                            self.names.extend(all_names.unstable_iter().cloned());
+                            self.names.extend(all_names.stable_iter().cloned());
                         }
                     } else {
                         // `from module import __all__`
@@ -269,7 +269,7 @@ impl<'db> StatementVisitor<'db> for DunderAllNamesCollector<'db> {
                         };
 
                         self.update_origin(DunderAllOrigin::ExternalModule);
-                        self.names.extend(all_names.unstable_iter().cloned());
+                        self.names.extend(all_names.stable_iter().cloned());
                     }
                 }
             }

crates/ty_python_semantic/src/dunder_all.rs

@@ -61,6 +61,16 @@ 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>>;
 
+/// Types that implement this trait are stable as keys of `FxHash{Map, Set}`, and maps and sets can be safely used as iterators.
+pub trait StableKey {}
+
+impl StableKey for String {}
+impl StableKey for &str {}
+impl StableKey for &ruff_python_ast::name::Name {}
+impl StableKey for ruff_python_ast::name::Name {}
+impl StableKey for ruff_db::system::SystemPathBuf {}
+impl StableKey for url::Url {}
+
 /// Always use this instead of [`rustc_hash::FxHashSet`].
 /// This struct intentionally does not implement `(Into)Iterator` because the iterator's output order will be unstable if the set's values depend on salsa's non-deterministic IDs.
 /// Only use `unstable_iter()`, etc. if you are sure the iterator is safe to use despite that.
@@ -108,6 +118,16 @@ impl<V> std::ops::DerefMut for FxHashSet<V> {
     }
 }
 
+impl<V: Eq + Hash + StableKey> FxHashSet<V> {
+    pub fn stable_iter(&self) -> std::collections::hash_set::Iter<'_, V> {
+        self.0.iter()
+    }
+
+    pub fn stable_into_iter(self) -> std::collections::hash_set::IntoIter<V> {
+        self.0.into_iter()
+    }
+}
+
 impl<V: Eq + Hash> FxHashSet<V> {
     pub fn with_capacity_and_hasher(capacity: usize, hasher: FxBuildHasher) -> Self {
         Self(rustc_hash::FxHashSet::with_capacity_and_hasher(
@@ -207,6 +227,40 @@ impl<K, V> std::ops::DerefMut for FxHashMap<K, V> {
     }
 }
 
+impl<K: Eq + Hash + StableKey, V> FxHashMap<K, V> {
+    pub fn stable_iter(&self) -> std::collections::hash_map::Iter<'_, K, V> {
+        self.0.iter()
+    }
+
+    pub fn stable_keys(&self) -> std::collections::hash_map::Keys<'_, K, V> {
+        self.0.keys()
+    }
+
+    pub fn stable_values(&self) -> std::collections::hash_map::Values<'_, K, V> {
+        self.0.values()
+    }
+
+    pub fn stable_iter_mut(&mut self) -> std::collections::hash_map::IterMut<'_, K, V> {
+        self.0.iter_mut()
+    }
+
+    pub fn stable_values_mut(&mut self) -> std::collections::hash_map::ValuesMut<'_, K, V> {
+        self.0.values_mut()
+    }
+
+    pub fn stable_into_iter(self) -> std::collections::hash_map::IntoIter<K, V> {
+        self.0.into_iter()
+    }
+
+    pub fn stable_into_keys(self) -> std::collections::hash_map::IntoKeys<K, V> {
+        self.0.into_keys()
+    }
+
+    pub fn stable_into_values(self) -> std::collections::hash_map::IntoValues<K, V> {
+        self.0.into_values()
+    }
+}
+
 impl<K: Eq + Hash, V> FxHashMap<K, V> {
     pub fn with_capacity_and_hasher(capacity: usize, hasher: FxBuildHasher) -> Self {
         Self(rustc_hash::FxHashMap::with_capacity_and_hasher(

crates/ty_python_semantic/src/lib.rs

@@ -276,6 +276,8 @@ pub struct LintId {
     definition: &'static LintMetadata,
 }
 
+impl crate::StableKey for LintId {}
+
 impl LintId {
     pub const fn of(definition: &'static LintMetadata) -> Self {
         LintId { definition }
@@ -389,7 +391,7 @@ impl LintRegistry {
                     }
                 }
 
-                let suggestion = did_you_mean(self.by_name.unstable_keys(), code);
+                let suggestion = did_you_mean(self.by_name.stable_keys(), code);
 
                 Err(GetLintError::Unknown {
                     code: code.to_string(),
@@ -408,7 +410,7 @@ impl LintRegistry {
     ///
     /// This iterator includes aliases that point to removed lints.
     pub fn aliases(&self) -> impl Iterator<Item = (LintName, LintId)> + '_ {
-        self.by_name.unstable_iter().filter_map(|(key, value)| {
+        self.by_name.stable_iter().filter_map(|(key, value)| {
             if let LintEntry::Alias(alias) = value {
                 Some((LintName::of(key), *alias))
             } else {
@@ -419,7 +421,7 @@ impl LintRegistry {
 
     /// Iterates over all removed lints.
     pub fn removed(&self) -> impl Iterator<Item = LintId> + '_ {
-        self.by_name.unstable_iter().filter_map(|(_, value)| {
+        self.by_name.stable_iter().filter_map(|(_, value)| {
             if let LintEntry::Removed(metadata) = value {
                 Some(*metadata)
             } else {
@@ -538,13 +540,13 @@ impl RuleSelection {
 
     /// Returns an iterator over all enabled lints.
     pub fn enabled(&self) -> impl Iterator<Item = LintId> + '_ {
-        self.lints.unstable_keys().copied()
+        self.lints.stable_keys().copied()
     }
 
     /// Returns an iterator over all enabled lints and their severity.
     pub fn iter(&self) -> impl ExactSizeIterator<Item = (LintId, Severity)> + '_ {
         self.lints
-            .unstable_iter()
+            .stable_iter()
             .map(|(&lint, &(severity, _))| (lint, severity))
     }
 
@@ -581,7 +583,7 @@ impl fmt::Debug for RuleSelection {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         let lints = self
             .lints
-            .unstable_iter()
+            .stable_iter()
             .sorted_by_key(|(lint, _)| lint.name);
 
         if f.alternate() {

crates/ty_python_semantic/src/lint.rs

@@ -16,6 +16,8 @@ use crate::{db::Db, module_resolver::file_to_module};
 #[derive(Clone, Debug, Eq, PartialEq, Hash, PartialOrd, Ord, get_size2::GetSize)]
 pub struct ModuleName(compact_str::CompactString);
 
+impl crate::StableKey for ModuleName {}
+
 impl ModuleName {
     /// Creates a new module name for `name`. Returns `Some` if `name` is a valid, absolute
     /// module name and `None` otherwise.

crates/ty_python_semantic/src/module_name.rs

@@ -222,7 +222,7 @@ impl FromStr for TypeshedVersions {
 
 impl fmt::Display for TypeshedVersions {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let sorted_items: BTreeMap<&ModuleName, &PyVersionRange> = self.0.unstable_iter().collect();
+        let sorted_items: BTreeMap<&ModuleName, &PyVersionRange> = self.0.stable_iter().collect();
         for (module_name, range) in sorted_items {
             writeln!(f, "{module_name}: {range}")?;
         }

crates/ty_python_semantic/src/module_resolver/typeshed.rs

@@ -6,6 +6,8 @@ use crate::ast_node_ref::AstNodeRef;
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash, get_size2::GetSize)]
 pub(super) struct NodeKey(NodeIndex);
 
+impl crate::StableKey for NodeKey {}
+
 impl NodeKey {
     pub(super) fn from_node<N>(node: N) -> Self
     where