XXX debug messages

Author: dcreager

crates/ty_python_semantic/src/types.rs

@@ -731,7 +731,9 @@ impl<'db> Type<'db> {
     }
 
     pub(crate) fn object(db: &'db dyn Db) -> Self {
-        KnownClass::Object.to_instance(db)
+        let x = KnownClass::Object.to_instance(db);
+        eprintln!("==> Type::object is {} {:?}", x.display(db), db as *const _);
+        x
     }
 
     pub const fn is_unknown(&self) -> bool {
@@ -1316,9 +1318,11 @@ impl<'db> Type<'db> {
     }
 
     fn when_subtype_of<C: Constraints<'db>>(self, db: &'db dyn Db, target: Type<'db>) -> C {
-        self.has_relation_to::<C>(db, target, TypeRelation::Subtyping)
-            .and(db, || self.premises(db))
-            .and(db, || target.premises(db))
+        let premises = self.premises::<C>(db).and(db, || target.premises(db));
+        premises.equivalent_to(
+            db,
+            self.has_relation_to::<C>(db, target, TypeRelation::Subtyping),
+        )
     }
 
     /// Return true if this type is [assignable to] type `target`.
@@ -1331,9 +1335,10 @@ impl<'db> Type<'db> {
 
     fn when_assignable_to<C: Constraints<'db>>(self, db: &'db dyn Db, target: Type<'db>) -> C {
         let premises = self.premises::<C>(db).and(db, || target.premises(db));
-        premises.implies(db, || {
-            self.has_relation_to::<C>(db, target, TypeRelation::Assignability)
-        })
+        premises.equivalent_to(
+            db,
+            self.has_relation_to::<C>(db, target, TypeRelation::Assignability),
+        )
     }
 
     fn has_relation_to<C: Constraints<'db>>(

crates/ty_python_semantic/src/types/class.rs

@@ -4335,6 +4335,7 @@ impl KnownClass {
     pub(crate) fn to_class_literal(self, db: &dyn Db) -> Type<'_> {
         self.try_to_class_literal(db)
             .map(Type::ClassLiteral)
+            .inspect(|_| eprintln!("==> a {:?}", self))
             .unwrap_or_else(Type::unknown)
     }
 

crates/ty_python_semantic/src/types/constraints.rs

@@ -150,6 +150,12 @@ pub(crate) trait Constraints<'db>: Clone + Sized {
         self.clone().negate(db).or(db, || self.and(db, other))
     }
 
+    fn equivalent_to(self, db: &'db dyn Db, other: Self) -> Self {
+        self.clone()
+            .and(db, || other.clone())
+            .or(db, || self.negate(db).and(db, || other.negate(db)))
+    }
+
     /// Returns the intersection of this constraint set and another. The other constraint set is
     /// provided as a thunk, to implement short-circuiting: the thunk is not forced if the
     /// constraint set is already saturated.
@@ -398,12 +404,6 @@ impl<'db> Constraints<'db> for ConstraintSet<'db> {
     ) -> Self {
         let lower = lower.bottom_materialization(db);
         let upper = upper.top_materialization(db);
-        eprintln!(
-            "==> constraint {} <: {} <: {}",
-            lower.display(db),
-            typevar.display(db),
-            upper.display(db)
-        );
         match Constraint::range(db, lower, upper) {
             Satisfiable::Never => Self::never(),
             Satisfiable::Always => Self::always(),
@@ -1039,6 +1039,23 @@ impl<'db> Constraint<'db> {
     ///
     /// Panics if `lower` and `upper` are not both fully static.
     fn range(db: &'db dyn Db, lower: Type<'db>, upper: Type<'db>) -> Satisfiable<Constraint<'db>> {
+        eprintln!(
+            "==> range {}/{} .. {}/{}",
+            lower.display(db),
+            lower.bottom_materialization(db).display(db),
+            upper.display(db),
+            upper.top_materialization(db).display(db),
+        );
+        debug_assert!(
+            !matches!(lower, Type::Dynamic(_)),
+            "{} is not fully static",
+            lower.display(db)
+        );
+        debug_assert!(
+            !matches!(upper, Type::Dynamic(_)),
+            "{} is not fully static",
+            upper.display(db)
+        );
         debug_assert_eq!(
             lower,
             lower.bottom_materialization(db),
@@ -1177,6 +1194,15 @@ impl<'db> RangeConstraint<'db> {
         typevar: BoundTypeVarInstance<'db>,
         set: &mut ConstraintSet<'db>,
     ) {
+        /*
+        eprintln!(
+            "==> ¬({} ≤ {} ≤ {})",
+            self.lower.display(db),
+            typevar.display(db),
+            self.upper.display(db)
+        );
+        */
+
         // Lower bound:
         // ¬(s ≤ α) = ((α ≤ s) ∧ α ≠ s) ∨ (a ≁ s)
         set.union_clause(
@@ -1196,6 +1222,8 @@ impl<'db> RangeConstraint<'db> {
 
         // Upper bound:
         // ¬(α ≤ t) = ((t ≤ α) ∧ α ≠ t) ∨ (a ≁ t)
+        eprintln!("==> what {}", self.upper.display(db));
+        eprintln!("==> what {}", Type::object(db).display(db));
         set.union_clause(
             db,
             ConstraintClause::from_constraints(