move typevar arms around

Author: dcreager

crates/ty_python_semantic/resources/mdtest/generics/legacy/functions.md

@@ -279,7 +279,7 @@ T = TypeVar("T", int, str)
 
 def same_constrained_types(t1: T, t2: T) -> T:
     # TODO: no error
-    # error: [unsupported-operator] "Operator `+` is unsupported between objects of type `T@same_constrained_types` and `T@same_constrained_types`"
+    # error: [invalid-return-type] "Return type does not match returned value: expected `T@same_constrained_types`, found `int | Unknown`"
     return t1 + t2
 ```
 

crates/ty_python_semantic/resources/mdtest/generics/pep695/functions.md

@@ -246,7 +246,7 @@ methods that are compatible with the return type, so the `return` expression is
 ```py
 def same_constrained_types[T: (int, str)](t1: T, t2: T) -> T:
     # TODO: no error
-    # error: [unsupported-operator] "Operator `+` is unsupported between objects of type `T@same_constrained_types` and `T@same_constrained_types`"
+    # error: [invalid-return-type] "Return type does not match returned value: expected `T@same_constrained_types`, found `int | Unknown`"
     return t1 + t2
 ```
 

crates/ty_python_semantic/src/types.rs

@@ -1457,27 +1457,56 @@ impl<'db> Type<'db> {
                 Type::NonInferableTypeVar(rhs_bound_typevar),
             ) if lhs_bound_typevar == rhs_bound_typevar => C::always_satisfiable(db),
 
-            // A fully static typevar is a subtype of its upper bound, and to something similar to
-            // the union of its constraints. An unbound, unconstrained, fully static typevar has an
-            // implicit upper bound of `object` (which is handled above).
-            (Type::NonInferableTypeVar(bound_typevar), _)
-                if bound_typevar.typevar(db).bound_or_constraints(db).is_some() =>
-            {
+            (Type::Union(union), _) => union.elements(db).iter().when_all(db, |&elem_ty| {
+                elem_ty.has_relation_to_impl(db, target, relation, visitor)
+            }),
+
+            (_, Type::Union(union)) => union.elements(db).iter().when_any(db, |&elem_ty| {
+                self.has_relation_to_impl(db, elem_ty, relation, visitor)
+            }),
+
+            // If both sides are intersections we need to handle the right side first
+            // (A & B & C) is a subtype of (A & B) because the left is a subtype of both A and B,
+            // but none of A, B, or C is a subtype of (A & B).
+            (_, Type::Intersection(intersection)) => (intersection.positive(db).iter())
+                .when_all(db, |&pos_ty| {
+                    self.has_relation_to_impl(db, pos_ty, relation, visitor)
+                })
+                .and(db, || {
+                    intersection
+                        .negative(db)
+                        .iter()
+                        .when_all(db, |&neg_ty| self.when_disjoint_from(db, neg_ty))
+                }),
+            (Type::Intersection(intersection), _) => {
+                intersection.positive(db).iter().when_any(db, |&elem_ty| {
+                    elem_ty.has_relation_to_impl(db, target, relation, visitor)
+                })
+            }
+
+            // A non-inferable typevar must satisfy the relation for every possible specialization.
+            (Type::NonInferableTypeVar(bound_typevar), _) => {
                 match bound_typevar.typevar(db).bound_or_constraints(db) {
-                    None => unreachable!(),
                     // Verify that the upper bound satisfies the relation. (If it does, than any
-                    // subtype of the upper bound will too.) Also add a safety constraint that
-                    // ensures that the typevar specializes to a subtype of the upper bound.
+                    // subtype of the upper bound will too.)
+                    None => {
+                        let bound = Type::object(db);
+                        C::constrain_typevar(db, bound_typevar, Type::Never, bound)
+                            .implies(db, || {
+                                bound.has_relation_to_impl(db, target, relation, visitor)
+                            })
+                    }
                     Some(TypeVarBoundOrConstraints::UpperBound(bound)) => {
                         C::constrain_typevar(db, bound_typevar, Type::Never, bound)
                             .implies(db, || {
                                 bound.has_relation_to_impl(db, target, relation, visitor)
                             })
                     }
+                    // Verify that each constraint satisfies the relation. (Note that constrained
+                    // typevars must specialize to _exactly_ one of the constraints, not to a
+                    // _subtype_ of one.)
                     Some(TypeVarBoundOrConstraints::Constraints(constraints)) => {
                         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)
@@ -1487,79 +1516,31 @@ impl<'db> Type<'db> {
                 }
             }
 
-            // If the typevar is constrained, there must be multiple constraints, and the typevar
-            // might be specialized to any one of them. However, the constraints do not have to be
-            // disjoint, which means an lhs type might be a subtype of all of the constraints.
-            (_, Type::NonInferableTypeVar(bound_typevar))
-                if !bound_typevar
-                    .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)
-                                })
-                        })
-                    })
-                    .is_never_satisfied(db) =>
-            {
-                // TODO: The repetition here isn't great, but we really need the fallthrough logic,
-                // where this arm only engages if it returns true (or in the world of constraints,
-                // not false). Once we're using real constraint sets instead of bool, we should be
-                // able to simplify the typevar logic.
-                bound_typevar
-                    .typevar(db)
-                    .constraints(db)
-                    .when_some_and(db, |constraints| {
-                        constraints.iter().when_all(db, |constraint| {
+            (_, Type::NonInferableTypeVar(bound_typevar)) => {
+                match bound_typevar.typevar(db).bound_or_constraints(db) {
+                    // There is no guarantee which type an unconstrained typevar might specialize
+                    // to. Never (which is checked above) is the only type that is a subtype of any
+                    // specialization.
+                    None | Some(TypeVarBoundOrConstraints::UpperBound(_)) => C::unsatisfiable(db),
+
+                    // A constrained typevar, on the other hand, does have a fixed set of types
+                    // that it can specialize to, so we can check them all exhaustively.
+                    Some(TypeVarBoundOrConstraints::Constraints(constraints)) => {
+                        constraints.elements(db).iter().when_all(db, |constraint| {
                             C::constrain_typevar(db, bound_typevar, *constraint, *constraint)
                                 .implies(db, || {
                                     self.has_relation_to_impl(db, *constraint, relation, visitor)
                                 })
                         })
-                    })
+                    }
+                }
             }
 
             // `Never` is the bottom type, the empty set.
             // Other than one unlikely edge case (TypeVars bound to `Never`),
             // no other type is a subtype of or assignable to `Never`.
             (_, Type::Never) => C::unsatisfiable(db),
 
-            (Type::Union(union), _) => union.elements(db).iter().when_all(db, |&elem_ty| {
-                elem_ty.has_relation_to_impl(db, target, relation, visitor)
-            }),
-
-            (_, Type::Union(union)) => union.elements(db).iter().when_any(db, |&elem_ty| {
-                self.has_relation_to_impl(db, elem_ty, relation, visitor)
-            }),
-
-            // If both sides are intersections we need to handle the right side first
-            // (A & B & C) is a subtype of (A & B) because the left is a subtype of both A and B,
-            // but none of A, B, or C is a subtype of (A & B).
-            (_, Type::Intersection(intersection)) => (intersection.positive(db).iter())
-                .when_all(db, |&pos_ty| {
-                    self.has_relation_to_impl(db, pos_ty, relation, visitor)
-                })
-                .and(db, || {
-                    intersection
-                        .negative(db)
-                        .iter()
-                        .when_all(db, |&neg_ty| self.when_disjoint_from(db, neg_ty))
-                }),
-            (Type::Intersection(intersection), _) => {
-                intersection.positive(db).iter().when_any(db, |&elem_ty| {
-                    elem_ty.has_relation_to_impl(db, target, relation, visitor)
-                })
-            }
-
-            // Other than the special cases checked above, no other types are a subtype of a
-            // typevar, since there's no guarantee what type the typevar will be specialized to.
-            // (If the typevar is bounded, it might be specialized to a smaller type than the
-            // bound. This is true even if the bound is a final class, since the typevar can still
-            // be specialized to `Never`.)
-            (_, Type::NonInferableTypeVar(_)) => C::unsatisfiable(db),
-
             // TODO: Infer specializations here
             (Type::TypeVar(_), _) | (_, Type::TypeVar(_)) => C::unsatisfiable(db),
 
@@ -1822,7 +1803,7 @@ impl<'db> Type<'db> {
 
             // Other than the special cases enumerated above, `Instance` types and typevars are
             // never subtypes of any other variants
-            (Type::NominalInstance(_) | Type::NonInferableTypeVar(_), _) => C::unsatisfiable(db),
+            (Type::NominalInstance(_), _) => C::unsatisfiable(db),
         }
     }