XXX debug

Author: dcreager

crates/ty_python_semantic/src/types.rs

@@ -1475,14 +1475,31 @@ impl<'db> Type<'db> {
                             })
                     }
                     Some(TypeVarBoundOrConstraints::Constraints(constraints)) => {
-                        constraints.elements(db).iter().when_all(db, |constraint| {
+                        let x = constraints.elements(db).iter().when_all(db, |constraint| {
                             // Note that constrained typevars must specialize to _exactly_ one of the
                             // constraints, not to a _subtype_ of one.
-                            C::constrain_typevar(db, bound_typevar, *constraint, *constraint)
-                                .implies(db, || {
-                                    constraint.has_relation_to_impl(db, target, relation, visitor)
-                                })
-                        })
+                            let x =
+                                C::constrain_typevar(db, bound_typevar, *constraint, *constraint)
+                                    .implies(db, || {
+                                        constraint
+                                            .has_relation_to_impl(db, target, relation, visitor)
+                                    });
+                            eprintln!(
+                                "==> constraint {}[{}] {} => {}",
+                                self.display(db),
+                                constraint.display(db),
+                                target.display(db),
+                                x.display(db)
+                            );
+                            x
+                        });
+                        eprintln!(
+                            "==> constraint {}[OVERALL] {} => {}",
+                            self.display(db),
+                            target.display(db),
+                            x.display(db),
+                        );
+                        x
                     }
                 }
             }
@@ -1495,12 +1512,33 @@ impl<'db> Type<'db> {
                     .typevar(db)
                     .constraints(db)
                     .when_some_and(db, |constraints| {
-                        constraints.iter().when_all(db, |constraint| {
-                            C::constrain_typevar(db, bound_typevar, *constraint, *constraint)
-                                .implies(db, || {
-                                    self.has_relation_to_impl(db, *constraint, relation, visitor)
-                                })
-                        })
+                        let x = constraints.iter().when_all(db, |constraint| {
+                            let x =
+                                C::constrain_typevar(db, bound_typevar, *constraint, *constraint)
+                                    .implies(db, || {
+                                        self.has_relation_to_impl(
+                                            db,
+                                            *constraint,
+                                            relation,
+                                            visitor,
+                                        )
+                                    });
+                            eprintln!(
+                                "==> constraint {} {}[{}] => {}",
+                                self.display(db),
+                                target.display(db),
+                                constraint.display(db),
+                                x.display(db)
+                            );
+                            x
+                        });
+                        eprintln!(
+                            "==> constraint {} {}[OVERALL] => {}",
+                            self.display(db),
+                            target.display(db),
+                            x.display(db)
+                        );
+                        x
                     })
                     .is_never_satisfied(db) =>
             {

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

@@ -589,6 +589,8 @@ impl<'db> Bindings<'db> {
 
                         Some(KnownFunction::IsSubtypeOf) => {
                             if let [Some(ty_a), Some(ty_b)] = overload.parameter_types() {
+                                let x = ty_a.when_subtype_of::<ConstraintSet>(db, *ty_b);
+                                eprintln!("==> {}", x.display(db));
                                 overload.set_return_type(Type::BooleanLiteral(
                                     ty_a.is_subtype_of(db, *ty_b),
                                 ));

crates/ty_python_semantic/src/types/constraints.rs

@@ -366,6 +366,23 @@ impl<'db> Constraints<'db> for ConstraintSet<'db> {
         result
     }
 
+    // XXX
+    fn implies(self, db: &'db dyn Db, other: impl FnOnce() -> Self) -> Self {
+        let p = self.clone();
+        let q = other();
+        let result = self
+            .clone()
+            .negate(db)
+            .or(db, || self.and(db, || q.clone()));
+        eprintln!(
+            "==> {} → {} = {}",
+            p.display(db),
+            q.display(db),
+            result.display(db)
+        );
+        result
+    }
+
     fn display(&self, db: &'db dyn Db) -> impl Display {
         self.display(db)
     }
@@ -491,6 +508,13 @@ impl<'db> ConstraintClause<'db> {
 
     /// Returns the union of this clause and another.
     fn union_clause(self, db: &'db dyn Db, other: Self) -> Simplified<Self> {
+        if false {
+            eprintln!(
+                "==> union_clause {} {}",
+                self.display(db),
+                other.display(db)
+            );
+        }
         if self.is_always() || other.is_always() {
             return Simplified::One(Self::always());
         }
@@ -501,6 +525,9 @@ impl<'db> ConstraintClause<'db> {
             return Simplified::One(self);
         }
         if let Some(simplified) = self.simplifies_via_union(db, &other) {
+            if false {
+                eprintln!(" -> simplified {}", simplified.display(db));
+            }
             if simplified.is_always() {
                 return Simplified::Always;
             }