XXX debug

Author: dcreager

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

@@ -339,6 +339,17 @@ impl<'db> Constraints<'db> for ConstraintSet<'db> {
         }
         result
     }
+
+    // XXX
+    fn implies(self, db: &'db dyn Db, other: impl FnOnce() -> Self) -> Self {
+        let q = other();
+        eprintln!("==> {} implies {}", self.display(db), q.display(db));
+        eprintln!(
+            "==> p ∧ q {}",
+            self.clone().and(db, || q.clone()).display(db)
+        );
+        self.clone().negate(db).or(db, || self.and(db, || q))
+    }
 }
 
 /// The intersection of a list of atomic constraints.
@@ -688,6 +699,7 @@ impl<'db> AtomicConstraint<'db> {
     /// `self` and `other` is `self`.
     fn subsumes(self, db: &'db dyn Db, other: Self) -> bool {
         debug_assert!(self.typevar == other.typevar);
+        eprintln!("==> subsumes? {} {}", self.display(db), other.display(db));
         self.intersect(db, other) == Simplified::One(self)
     }