revert using FxIndexSet for unstable iteration parts

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 = BTreeSet::default();
+        let mut added_paths = FxHashSet::default();
 
         // Deduplicate the `sync` calls. Many file watchers emit multiple events for the same path.
         let mut synced_files = FxHashSet::default();
@@ -317,19 +317,20 @@ impl ProjectDatabase {
             }
         }
 
-        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);
+        let diagnostics = if let Some(walker) =
+            ProjectFilesWalker::incremental(self, added_paths.unstable_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

@@ -182,7 +182,7 @@ pub(super) type IndexedIter<'a> = std::iter::Copied<std::collections::hash_set::
 
 /// A Mutable view of a project's indexed files.
 ///
-/// Allows in-place mutation of the files without deep cloning the index set.
+/// Allows in-place mutation of the files without deep cloning the hash set.
 /// The changes are written back when the mutable view is dropped or by calling [`Self::set`] manually.
 pub(super) struct IndexedMut<'db> {
     db: Option<&'db mut dyn Db>,

crates/ty_project/src/lib.rs

@@ -21,6 +21,7 @@ use ruff_db::system::{SystemPath, SystemPathBuf};
 use salsa::Durability;
 use salsa::Setter;
 use std::backtrace::BacktraceStatus;
+use std::collections::hash_set;
 use std::iter::FusedIterator;
 use std::panic::{AssertUnwindSafe, UnwindSafe};
 use std::sync::Arc;
@@ -621,7 +622,7 @@ impl<'a> ProjectFiles<'a> {
 }
 
 enum ProjectFilesIter<'db> {
-    OpenFiles(std::collections::hash_set::Iter<'db, File>),
+    OpenFiles(hash_set::Iter<'db, File>),
     Indexed(files::IndexedIter<'db>),
 }
 

crates/ty_python_semantic/src/hash.rs

@@ -2,6 +2,10 @@ use rustc_hash::FxBuildHasher;
 use std::borrow::Borrow;
 use std::hash::Hash;
 
+pub(crate) type Union<'a, V> = std::collections::hash_set::Union<'a, V, FxBuildHasher>;
+pub(crate) type Intersection<'a, V> =
+    std::collections::hash_set::Intersection<'a, V, FxBuildHasher>;
+
 /// 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 depends on salsa's non-deterministic IDs or execution order.
 /// Only use `unstable_iter()`, etc. if you are sure the iterator is safe to use despite that.
@@ -99,6 +103,14 @@ impl<V: Eq + Hash> FxHashSet<V> {
     {
         self.0.contains(value)
     }
+
+    pub fn union<'a>(&'a self, other: &'a FxHashSet<V>) -> Union<'a, V> {
+        self.0.union(&other.0)
+    }
+
+    pub fn intersection<'a>(&'a self, other: &'a FxHashSet<V>) -> Intersection<'a, V> {
+        self.0.intersection(&other.0)
+    }
 }
 
 impl<V: Ord> FxHashSet<V> {

crates/ty_python_semantic/src/lib.rs

@@ -60,10 +60,10 @@ mod diagnostic;
 #[cfg(feature = "testing")]
 pub mod pull_types;
 
-pub type FxOrderMap<K, V> = ordermap::map::OrderMap<K, V, BuildHasherDefault<FxHasher>>;
-pub type FxOrderSet<V> = ordermap::set::OrderSet<V, BuildHasherDefault<FxHasher>>;
-pub type FxIndexMap<K, V> = indexmap::IndexMap<K, V, BuildHasherDefault<FxHasher>>;
-pub type FxIndexSet<V> = indexmap::IndexSet<V, BuildHasherDefault<FxHasher>>;
+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/semantic_model.rs

@@ -163,7 +163,7 @@ impl<'db> SemanticModel<'db> {
         let builtin = module.is_known(self.db, KnownModule::Builtins);
 
         let mut completions = vec![];
-        for Member { name, ty } in all_members(self.db, ty) {
+        for Member { name, ty } in all_members(self.db, ty).unstable_into_iter() {
             completions.push(Completion {
                 name,
                 ty: Some(ty),
@@ -197,7 +197,7 @@ impl<'db> SemanticModel<'db> {
     pub fn attribute_completions(&self, node: &ast::ExprAttribute) -> Vec<Completion<'db>> {
         let ty = node.value.inferred_type(self);
         all_members(self.db, ty)
-            .into_iter()
+            .unstable_into_iter()
             .map(|member| Completion {
                 name: member.name,
                 ty: Some(member.ty),

crates/ty_python_semantic/src/types/call/bind.rs

@@ -39,7 +39,7 @@ use crate::types::{
     TrackedConstraintSet, TypeAliasType, TypeContext, TypeVarVariance, UnionBuilder, UnionType,
     WrapperDescriptorKind, enums, ide_support, todo_type,
 };
-use crate::{FxHashMap, FxIndexSet, Program};
+use crate::{FxHashMap, FxHashSet, Program};
 use ruff_db::diagnostic::{Annotation, Diagnostic, SubDiagnostic, SubDiagnosticSeverity};
 use ruff_python_ast::{self as ast, ArgOrKeyword, PythonVersion};
 
@@ -887,7 +887,7 @@ impl<'db> Bindings<'db> {
                                 overload.set_return_type(Type::heterogeneous_tuple(
                                     db,
                                     ide_support::all_members(db, *ty)
-                                        .into_iter()
+                                        .unstable_into_iter()
                                         .sorted()
                                         .map(|member| Type::string_literal(db, &member.name)),
                                 ));
@@ -1247,7 +1247,7 @@ impl<'db> Bindings<'db> {
                         let extract_inferable = |instance: &NominalInstanceType<'db>| {
                             if instance.has_known_class(db, KnownClass::NoneType) {
                                 // Caller explicitly passed None, so no typevars are inferable.
-                                return Some(FxIndexSet::default());
+                                return Some(FxHashSet::default());
                             }
                             instance
                                 .tuple_spec(db)?
@@ -1261,7 +1261,7 @@ impl<'db> Bindings<'db> {
 
                         let inferable = match overload.parameter_types() {
                             // Caller did not provide argument, so no typevars are inferable.
-                            [None] => FxIndexSet::default(),
+                            [None] => FxHashSet::default(),
                             [Some(Type::NominalInstance(instance))] => {
                                 match extract_inferable(instance) {
                                     Some(inferable) => inferable,

crates/ty_python_semantic/src/types/constraints.rs

@@ -67,7 +67,7 @@ use crate::types::{
     BoundTypeVarIdentity, BoundTypeVarInstance, IntersectionType, Type, TypeRelation,
     TypeVarBoundOrConstraints, UnionType, walk_bound_type_var_type,
 };
-use crate::{Db, FxHashMap, FxHashSet, FxIndexSet, FxOrderSet};
+use crate::{Db, FxHashMap, FxHashSet, FxOrderSet};
 
 /// An extension trait for building constraint sets from [`Option`] values.
 pub(crate) trait OptionConstraintsExtension<T> {
@@ -1036,8 +1036,7 @@ impl<'db> Node<'db> {
             Node::Interior(_) => {}
         }
 
-        // We should use `FxIndexSet` here since `BoundTypeVarInstance::{valid, required}_specializations` is query-dependent.
-        let mut typevars = FxIndexSet::default();
+        let mut typevars = FxHashSet::default();
         self.for_each_constraint(db, &mut |constraint| {
             typevars.insert(constraint.typevar(db));
         });
@@ -1056,7 +1055,7 @@ impl<'db> Node<'db> {
                 .is_always_satisfied(db)
         };
 
-        for typevar in typevars {
+        for typevar in typevars.unstable_iter() {
             if typevar.is_inferable(db, inferable) {
                 // If the typevar is in inferable position, we need to verify that some valid
                 // specialization satisfies the constraint set.
@@ -1848,11 +1847,11 @@ impl<'db> InteriorNode<'db> {
         // Seed the seen set with all of the constraints that are present in the input BDD, and the
         // visit queue with all pairs of those constraints. (We use "combinations" because we don't
         // need to compare a constraint against itself, and because ordering doesn't matter.)
-        let mut seen_constraints = FxIndexSet::default();
+        let mut seen_constraints = FxHashSet::default();
         Node::Interior(self).for_each_constraint(db, &mut |constraint| {
             seen_constraints.insert(constraint);
         });
-        let mut to_visit: Vec<(_, _)> = (seen_constraints.iter().copied())
+        let mut to_visit: Vec<(_, _)> = (seen_constraints.unstable_iter().copied())
             .tuple_combinations()
             .collect();
 
@@ -2011,7 +2010,7 @@ impl<'db> InteriorNode<'db> {
                     // seen set and (if we haven't already seen it) to the to-visit queue.
                     if seen_constraints.insert(intersection_constraint) {
                         to_visit.extend(
-                            (seen_constraints.iter().copied())
+                            (seen_constraints.unstable_iter().copied())
                                 .filter(|seen| *seen != intersection_constraint)
                                 .map(|seen| (seen, intersection_constraint)),
                         );

crates/ty_python_semantic/src/types/diagnostic.rs

@@ -2236,7 +2236,7 @@ impl TypeCheckDiagnostics {
     pub(super) fn extend(&mut self, other: &TypeCheckDiagnostics) {
         self.diagnostics.extend_from_slice(&other.diagnostics);
         self.used_suppressions
-            .extend(other.used_suppressions.unstable_iter().copied());
+            .extend(other.used_suppressions.unstable_iter());
     }
 
     pub(super) fn extend_diagnostics(&mut self, diagnostics: impl IntoIterator<Item = Diagnostic>) {

crates/ty_python_semantic/src/types/function.rs

@@ -1463,7 +1463,9 @@ impl KnownFunction {
                 };
                 let ty_members = all_members(db, *ty);
                 overload.set_return_type(Type::BooleanLiteral(
-                    ty_members.iter().any(|m| m.name == member.value(db)),
+                    ty_members
+                        .unstable_iter()
+                        .any(|m| m.name == member.value(db)),
                 ));
             }