it works!

Author: dcreager

crates/ty_python_semantic/src/types/constraints.rs

@@ -409,6 +409,10 @@ impl<'db> ConstraintSet<'db> {
         Self { node }
     }
 
+    pub(crate) fn for_each_path(self, db: &'db dyn Db, f: impl FnMut(&PathAssignments<'db>)) {
+        self.node.for_each_path(db, f);
+    }
+
     pub(crate) fn range(
         db: &'db dyn Db,
         lower: Type<'db>,
@@ -448,9 +452,9 @@ impl<'db> BoundTypeVarInstance<'db> {
 /// lower and upper bound.
 #[salsa::interned(debug, heap_size=ruff_memory_usage::heap_size)]
 pub(crate) struct ConstrainedTypeVar<'db> {
-    typevar: BoundTypeVarInstance<'db>,
-    lower: Type<'db>,
-    upper: Type<'db>,
+    pub(crate) typevar: BoundTypeVarInstance<'db>,
+    pub(crate) lower: Type<'db>,
+    pub(crate) upper: Type<'db>,
 }
 
 // The Salsa heap is tracked separately.
@@ -659,7 +663,7 @@ impl<'db> ConstrainedTypeVar<'db> {
         Some(Self::new(db, self.typevar(db), lower, upper))
     }
 
-    fn display(self, db: &'db dyn Db) -> impl Display {
+    pub(crate) fn display(self, db: &'db dyn Db) -> impl Display {
         self.display_inner(db, false)
     }
 
@@ -825,6 +829,40 @@ impl<'db> Node<'db> {
         }
     }
 
+    fn for_each_path(self, db: &'db dyn Db, mut f: impl FnMut(&PathAssignments<'db>)) {
+        match self {
+            Node::AlwaysTrue => {}
+            Node::AlwaysFalse => {}
+            Node::Interior(interior) => {
+                let map = interior.sequent_map(db);
+                let mut path = PathAssignments::default();
+                self.for_each_path_inner(db, &mut f, map, &mut path);
+            }
+        }
+    }
+
+    fn for_each_path_inner(
+        self,
+        db: &'db dyn Db,
+        f: &mut dyn FnMut(&PathAssignments<'db>),
+        map: &SequentMap<'db>,
+        path: &mut PathAssignments<'db>,
+    ) {
+        match self {
+            Node::AlwaysTrue => f(path),
+            Node::AlwaysFalse => {}
+            Node::Interior(interior) => {
+                let constraint = interior.constraint(db);
+                path.walk_edge(map, constraint.when_true(), |path, _| {
+                    interior.if_true(db).for_each_path_inner(db, f, map, path);
+                });
+                path.walk_edge(map, constraint.when_false(), |path, _| {
+                    interior.if_false(db).for_each_path_inner(db, f, map, path);
+                });
+            }
+        }
+    }
+
     /// Returns whether this BDD represent the constant function `true`.
     fn is_always_satisfied(self, db: &'db dyn Db) -> bool {
         match self {
@@ -2147,7 +2185,7 @@ fn sequent_map_cycle_initial<'db>(
 /// An assignment of one BDD variable to either `true` or `false`. (When evaluating a BDD, we
 /// must provide an assignment for each variable present in the BDD.)
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
-enum ConstraintAssignment<'db> {
+pub(crate) enum ConstraintAssignment<'db> {
     Positive(ConstrainedTypeVar<'db>),
     Negative(ConstrainedTypeVar<'db>),
 }
@@ -2227,7 +2265,7 @@ impl<'db> ConstraintAssignment<'db> {
     // Keep this for future debugging needs, even though it's not currently used when rendering
     // constraint sets.
     #[expect(dead_code)]
-    fn display(self, db: &'db dyn Db) -> impl Display {
+    pub(crate) fn display(self, db: &'db dyn Db) -> impl Display {
         struct DisplayConstraintAssignment<'db> {
             constraint: ConstraintAssignment<'db>,
             db: &'db dyn Db,
@@ -2694,7 +2732,7 @@ impl<'db> SequentMap<'db> {
 /// The collection of constraints that we know to be true or false at a certain point when
 /// traversing a BDD.
 #[derive(Debug, Default)]
-struct PathAssignments<'db> {
+pub(crate) struct PathAssignments<'db> {
     assignments: FxOrderSet<ConstraintAssignment<'db>>,
 }
 
@@ -2753,6 +2791,17 @@ impl<'db> PathAssignments<'db> {
         result
     }
 
+    pub(crate) fn positive_constraints(
+        &self,
+    ) -> impl Iterator<Item = ConstrainedTypeVar<'db>> + '_ {
+        self.assignments
+            .iter()
+            .filter_map(|assignment| match assignment {
+                ConstraintAssignment::Positive(constraint) => Some(*constraint),
+                ConstraintAssignment::Negative(_) => None,
+            })
+    }
+
     fn assignment_holds(&self, assignment: ConstraintAssignment<'db>) -> bool {
         self.assignments.contains(&assignment)
     }

crates/ty_python_semantic/src/types/generics.rs

@@ -1390,7 +1390,7 @@ impl<'db> SpecializationBuilder<'db> {
             .map(|(identity, _)| self.types.get(identity).copied());
 
         // TODO Infer the tuple spec for a tuple type
-        generic_context.specialize_partial(self.db, types)
+        generic_context.specialize_recursive(self.db, types)
     }
 
     fn add_type_mapping(
@@ -1682,20 +1682,24 @@ impl<'db> SpecializationBuilder<'db> {
                     actual_signature,
                     self.inferable,
                 );
-                for formal_signature in &formal_callable.signatures(self.db).overloads {
-                    for actual_signature in &actual_callable.signatures(self.db).overloads {
-                        if let Some(formal_return_ty) = formal_signature.return_ty
-                            && let Some(actual_return_ty) = actual_signature.return_ty
-                        {
-                            self.infer_map_impl(
-                                formal_return_ty,
-                                actual_return_ty,
+                when.for_each_path(self.db, |path| {
+                    for constraint in path.positive_constraints() {
+                        let typevar = constraint.typevar(self.db);
+                        let lower = constraint.lower(self.db);
+                        let upper = constraint.upper(self.db);
+                        if !upper.is_object() {
+                            self.add_type_mapping(typevar, upper, polarity, &mut f);
+                        }
+                        if let Type::TypeVar(lower_bound_typevar) = lower {
+                            self.add_type_mapping(
+                                lower_bound_typevar,
+                                Type::TypeVar(typevar),
                                 polarity,
                                 &mut f,
-                            )?;
+                            );
                         }
                     }
-                }
+                });
             }
 
             // TODO: Add more forms that we can structurally induct into: type[C], callables

crates/ty_python_semantic/src/types/signatures.rs

@@ -965,7 +965,13 @@ impl<'db> Signature<'db> {
         // If either of the parameter lists is gradual (`...`), then it is assignable to and from
         // any other parameter list, but not a subtype or supertype of any other parameter list.
         if self.parameters.is_gradual() || other.parameters.is_gradual() {
-            return ConstraintSet::from(relation.is_assignability());
+            result.intersect(
+                db,
+                ConstraintSet::from(
+                    relation.is_assignability() || relation.is_constraint_set_assignability(),
+                ),
+            );
+            return result;
         }
 
         let mut parameters = ParametersZip {