Revert "constraint implication"

This reverts commit 943a7b3.

Author: dcreager

crates/ty_python_semantic/src/types.rs

@@ -198,7 +198,7 @@ pub(crate) type ApplyTypeMappingVisitor<'db> = TypeTransformer<'db, TypeMapping<
 
 /// A [`PairVisitor`] that is used in `has_relation_to` methods.
 pub(crate) type HasRelationToVisitor<'db> =
-    CycleDetector<TypeRelation<'db>, (Type<'db>, Type<'db>, TypeRelation<'db>), ConstraintSet<'db>>;
+    CycleDetector<TypeRelation, (Type<'db>, Type<'db>, TypeRelation), ConstraintSet<'db>>;
 
 impl Default for HasRelationToVisitor<'_> {
     fn default() -> Self {
@@ -1593,7 +1593,7 @@ impl<'db> Type<'db> {
         db: &'db dyn Db,
         target: Type<'db>,
         inferable: InferableTypeVars<'_, 'db>,
-        relation: TypeRelation<'db>,
+        relation: TypeRelation,
     ) -> ConstraintSet<'db> {
         self.has_relation_to_impl(
             db,
@@ -1610,7 +1610,7 @@ impl<'db> Type<'db> {
         db: &'db dyn Db,
         target: Type<'db>,
         inferable: InferableTypeVars<'_, 'db>,
-        relation: TypeRelation<'db>,
+        relation: TypeRelation,
         relation_visitor: &HasRelationToVisitor<'db>,
         disjointness_visitor: &IsDisjointVisitor<'db>,
     ) -> ConstraintSet<'db> {
@@ -1703,9 +1703,6 @@ impl<'db> Type<'db> {
                     Type::Union(union) => union.elements(db).iter().any(Type::is_dynamic),
                     _ => false,
                 },
-                TypeRelation::ConstraintImplication(_) => {
-                    panic!("constraints should not contain dynamic types")
-                }
             }),
             (_, Type::Dynamic(_)) => ConstraintSet::from(match relation {
                 TypeRelation::Subtyping => false,
@@ -1717,9 +1714,6 @@ impl<'db> Type<'db> {
                     }
                     _ => false,
                 },
-                TypeRelation::ConstraintImplication(_) => {
-                    panic!("constraints should not contain dynamic types")
-                }
             }),
 
             // In general, a TypeVar `T` is not a subtype of a type `S` unless one of the two conditions is satisfied:
@@ -1904,16 +1898,12 @@ impl<'db> Type<'db> {
                     // to non-transitivity (highly undesirable); and pragmatically, a full implementation
                     // of redundancy may not generally lead to simpler types in many situations.
                     let self_ty = match relation {
-                        TypeRelation::Subtyping
-                        | TypeRelation::Redundancy
-                        | TypeRelation::ConstraintImplication(_) => self,
+                        TypeRelation::Subtyping | TypeRelation::Redundancy => self,
                         TypeRelation::Assignability => self.bottom_materialization(db),
                     };
                     intersection.negative(db).iter().when_all(db, |&neg_ty| {
                         let neg_ty = match relation {
-                            TypeRelation::Subtyping
-                            | TypeRelation::Redundancy
-                            | TypeRelation::ConstraintImplication(_) => neg_ty,
+                            TypeRelation::Subtyping | TypeRelation::Redundancy => neg_ty,
                             TypeRelation::Assignability => neg_ty.bottom_materialization(db),
                         };
                         self_ty.is_disjoint_from_impl(
@@ -9779,7 +9769,7 @@ impl<'db> ConstructorCallError<'db> {
 
 /// A non-exhaustive enumeration of relations that can exist between types.
 #[derive(Debug, Copy, Clone, Hash, PartialEq, Eq)]
-pub(crate) enum TypeRelation<'db> {
+pub(crate) enum TypeRelation {
     /// The "subtyping" relation.
     ///
     /// A [fully static] type `B` is a subtype of a fully static type `A` if and only if
@@ -9899,45 +9889,9 @@ pub(crate) enum TypeRelation<'db> {
     /// [fully static]: https://typing.python.org/en/latest/spec/glossary.html#term-fully-static-type
     /// [materializations]: https://typing.python.org/en/latest/spec/glossary.html#term-materialize
     Redundancy,
-
-    /// The "constraint implication" relation.
-    ///
-    /// This is used when solving a [`ConstraintSet`], which expresses the conditions under which
-    /// one of the other relationships hold. There are three cases to consider: dynamic types,
-    /// concrete types, and typevars.
-    ///
-    /// The first case is easy; we can ignore it! The upper and lower bounds of a constraint are
-    /// guaranteed to be fully static, so we don't have to define constraint implication for
-    /// dynamic types.
-    ///
-    /// For concrete types, all of the typing relationships (including this one) produce the same
-    /// result. (A concrete type is any fully static type that is not a typevar. It can _contain_ a
-    /// typevar, though — `list[T]` is considered concrete.)
-    ///
-    /// The interesting case is typevars. The other typing relationships (TODO: will) all "punt" on
-    /// the question when considering a typevar, by translating the desired relationship into a
-    /// constraint set. That is, we say that `T` is assignable to `int` when `T ≤ int`. (There are
-    /// interesting nuances when comparing a typevar with a dynamic type, but they all end up
-    /// translating the types into a constraint in some way.)
-    ///
-    /// At some point, though, we need to resolve a constraint set; at that point, we can no longer
-    /// punt on the question, and have to determine whether a runtime instance being a member of
-    /// `T` implies that it is also a member of `int`. This will depend on the final constraint set
-    /// that we produced, which might incorporate tighter constraints from other parts of a larger
-    /// type. For instance, `S` implies `int` under each of the following constraint sets:
-    ///
-    ///   - `S ≤ bool`
-    ///   - `S ≤ int`
-    ///   - `S ≤ T ∧ T ≤ int`
-    ///
-    /// Whereas `S` does not imply `int` under the following:
-    ///
-    ///   - `S ≤ str`
-    ///   - `S ≤ T`
-    ConstraintImplication(ConstraintSet<'db>),
 }
 
-impl TypeRelation<'_> {
+impl TypeRelation {
     pub(crate) const fn is_assignability(self) -> bool {
         matches!(self, TypeRelation::Assignability)
     }
@@ -10113,7 +10067,7 @@ impl<'db> BoundMethodType<'db> {
         db: &'db dyn Db,
         other: Self,
         inferable: InferableTypeVars<'_, 'db>,
-        relation: TypeRelation<'db>,
+        relation: TypeRelation,
         relation_visitor: &HasRelationToVisitor<'db>,
         disjointness_visitor: &IsDisjointVisitor<'db>,
     ) -> ConstraintSet<'db> {
@@ -10280,7 +10234,7 @@ impl<'db> CallableType<'db> {
         db: &'db dyn Db,
         other: Self,
         inferable: InferableTypeVars<'_, 'db>,
-        relation: TypeRelation<'db>,
+        relation: TypeRelation,
         relation_visitor: &HasRelationToVisitor<'db>,
         disjointness_visitor: &IsDisjointVisitor<'db>,
     ) -> ConstraintSet<'db> {
@@ -10375,7 +10329,7 @@ impl<'db> KnownBoundMethodType<'db> {
         db: &'db dyn Db,
         other: Self,
         inferable: InferableTypeVars<'_, 'db>,
-        relation: TypeRelation<'db>,
+        relation: TypeRelation,
         relation_visitor: &HasRelationToVisitor<'db>,
         disjointness_visitor: &IsDisjointVisitor<'db>,
     ) -> ConstraintSet<'db> {

crates/ty_python_semantic/src/types/class.rs

@@ -597,16 +597,14 @@ impl<'db> ClassType<'db> {
         db: &'db dyn Db,
         other: Self,
         inferable: InferableTypeVars<'_, 'db>,
-        relation: TypeRelation<'db>,
+        relation: TypeRelation,
         relation_visitor: &HasRelationToVisitor<'db>,
         disjointness_visitor: &IsDisjointVisitor<'db>,
     ) -> ConstraintSet<'db> {
         self.iter_mro(db).when_any(db, |base| {
             match base {
                 ClassBase::Dynamic(_) => match relation {
-                    TypeRelation::Subtyping
-                    | TypeRelation::Redundancy
-                    | TypeRelation::ConstraintImplication(_) => {
+                    TypeRelation::Subtyping | TypeRelation::Redundancy => {
                         ConstraintSet::from(other.is_object(db))
                     }
                     TypeRelation::Assignability => ConstraintSet::from(!other.is_final(db)),