[ty] Add and test when constraint sets are satisfied by their typevars

crates/ty_python_semantic/resources/mdtest/type_properties/implies_subtype_of.md

@@ -180,16 +180,12 @@ This might require propagating constraints from other typevars.
 def mutually_constrained[T, U]():
     # If [T = U ∧ U ≤ int], then [T ≤ int] must be true as well.
     given_int = ConstraintSet.range(U, T, U) & ConstraintSet.range(Never, U, int)
-    # TODO: no static-assert-error
-    # error: [static-assert-error]
     static_assert(given_int.implies_subtype_of(T, int))
     static_assert(not given_int.implies_subtype_of(T, bool))
     static_assert(not given_int.implies_subtype_of(T, str))
 
     # If [T ≤ U ∧ U ≤ int], then [T ≤ int] must be true as well.
     given_int = ConstraintSet.range(Never, T, U) & ConstraintSet.range(Never, U, int)
-    # TODO: no static-assert-error
-    # error: [static-assert-error]
     static_assert(given_int.implies_subtype_of(T, int))
     static_assert(not given_int.implies_subtype_of(T, bool))
     static_assert(not given_int.implies_subtype_of(T, str))

crates/ty_python_semantic/resources/mdtest/type_properties/satisfied_by_all_typevars.md

@@ -0,0 +1,158 @@
+# Constraint set satisfaction
+
+```toml
+[environment]
+python-version = "3.12"
+```
+
+Constraint sets exist to help us check assignability and subtyping of types in the presence of
+typevars. We construct a constraint set describing the conditions under which assignability holds
+between the two types. Then we check whether that constraint set is satisfied for the valid
+specializations of the relevant typevars. This file tests that final step: ensuring that a
+constraint set is satisfied given a list of inferable and non-inferable typevars.
+
+(Note that in this file, for ease of reproducibility, we explicitly list the typevars that are
+inferable in each `satisfied_by_all_typevars` call; any typevar not listed is assumed to be
+non-inferable.)
+
+## Inferable typevars
+
+When a typevar is in an inferable position, the constraint set only needs to be satisfied for _some_
+valid specialization. The most common inferable position occurs when invoking a generic function:
+all of the function's typevars are inferable, because we want to use the argument types to infer
+which specialization is being invoked.
+
+```py
+from typing import final, Never
+from ty_extensions import ConstraintSet, static_assert
+
+class Super: ...
+class Base(Super): ...
+class Sub(Base): ...
+
+@final
+class Unrelated: ...
+```
+
+If a typevar has no bound or constraints, then it can specialize to any type. For an inferable
+typevar, that means we just need a single type (any type at all!) that satisfies the constraint set.
+
+```py
+def unbounded[T]():
+    static_assert(ConstraintSet.always().satisfied_by_all_typevars(T))
+    static_assert(not ConstraintSet.never().satisfied_by_all_typevars(T))
+    static_assert(ConstraintSet.range(Never, T, Unrelated).satisfied_by_all_typevars(T))
+    static_assert(ConstraintSet.range(Never, T, Super).satisfied_by_all_typevars(T))
+    static_assert(ConstraintSet.range(Never, T, Base).satisfied_by_all_typevars(T))
+    static_assert(ConstraintSet.range(Never, T, Sub).satisfied_by_all_typevars(T))
+```
+
+If a typevar has an upper bound, then it must specialize to a type that is a subtype of that bound.
+For an inferable typevar, that means we need a single type that satisfies both the constraint set
+and the upper bound.
+
+```py
+def bounded[T: Base]():
+    static_assert(ConstraintSet.always().satisfied_by_all_typevars(T))
+    static_assert(not ConstraintSet.never().satisfied_by_all_typevars(T))
+    static_assert(ConstraintSet.range(Never, T, Super).satisfied_by_all_typevars(T))
+    static_assert(ConstraintSet.range(Never, T, Base).satisfied_by_all_typevars(T))
+    static_assert(ConstraintSet.range(Never, T, Sub).satisfied_by_all_typevars(T))
+
+    # This succeeds because T can specialize to Never
+    constraints = ConstraintSet.range(Never, T, Unrelated)
+    static_assert(constraints.satisfied_by_all_typevars(T))
+
+    # If we explicitly disallow Never, then it fails
+    constraints = constraints & ~ConstraintSet.range(Never, T, Never)
+    static_assert(not constraints.satisfied_by_all_typevars(T))
+```
+
+If a typevar has constraints, then it must specialize to one of those specific types. (Not to a
+subtype of one of those types!) For an inferable typevar, that means we need the constraint set to
+be satisfied by any one of the constraints.
+
+```py
+def constrained[T: (Base, Unrelated)]():
+    static_assert(ConstraintSet.always().satisfied_by_all_typevars(T))
+    static_assert(not ConstraintSet.never().satisfied_by_all_typevars(T))
+    static_assert(ConstraintSet.range(Never, T, Unrelated).satisfied_by_all_typevars(T))
+    static_assert(ConstraintSet.range(Never, T, Super).satisfied_by_all_typevars(T))
+    static_assert(ConstraintSet.range(Never, T, Base).satisfied_by_all_typevars(T))
+    # Sub is not Base! Constraints must be exact, not subtypes
+    static_assert(not ConstraintSet.range(Never, T, Sub).satisfied_by_all_typevars(T))
+```
+
+## Non-inferable typevars
+
+When a typevar is in a non-inferable position, the constraint set must be satisfied for _every_
+valid specialization. The most common non-inferable position occurs in the body of a generic
+function or class: here we don't know in advance what type the typevar will be specialized to, and
+so we have to ensure that the body is valid for all possible specializations.
+
+```py
+from typing import final, Never
+from ty_extensions import ConstraintSet, static_assert
+
+class Super: ...
+class Base(Super): ...
+class Sub(Base): ...
+
+@final
+class Unrelated: ...
+```
+
+If a typevar has no bound or constraints, then it can specialize to any type. For a non-inferable
+typevar, that means the constraint set must be satisfied for every possible type.
+
+```py
+def unbounded[T]():
+    static_assert(ConstraintSet.always().satisfied_by_all_typevars())
+    static_assert(not ConstraintSet.never().satisfied_by_all_typevars())
+    static_assert(not ConstraintSet.range(Never, T, Unrelated).satisfied_by_all_typevars())
+    static_assert(not ConstraintSet.range(Never, T, Super).satisfied_by_all_typevars())
+    static_assert(not ConstraintSet.range(Never, T, Base).satisfied_by_all_typevars())
+    static_assert(not ConstraintSet.range(Never, T, Sub).satisfied_by_all_typevars())
+```
+
+If a typevar has an upper bound, then it must specialize to a type that is a subtype of that bound.
+For a non-inferable typevar, that means the constraint set must be satisfied for every type that
+satisfies the upper bound.
+
+```py
+def bounded[T: Base]():
+    static_assert(ConstraintSet.always().satisfied_by_all_typevars())
+    static_assert(not ConstraintSet.never().satisfied_by_all_typevars())
+    static_assert(not ConstraintSet.range(Never, T, Unrelated).satisfied_by_all_typevars())
+    static_assert(ConstraintSet.range(Never, T, Super).satisfied_by_all_typevars())
+    static_assert(ConstraintSet.range(Never, T, Base).satisfied_by_all_typevars())
+    static_assert(not ConstraintSet.range(Never, T, Sub).satisfied_by_all_typevars())
+```
+
+If a typevar has constraints, then it must specialize to one of those specific types. (Not to a
+subtype of one of those types!) For a non-inferable typevar, that means we need the constraint set
+to be satisfied by all of those constraints.
+
+```py
+def constrained[T: (Base, Unrelated)]():
+    static_assert(ConstraintSet.always().satisfied_by_all_typevars())
+    static_assert(not ConstraintSet.never().satisfied_by_all_typevars())
+    static_assert(not ConstraintSet.range(Never, T, Unrelated).satisfied_by_all_typevars())
+    static_assert(not ConstraintSet.range(Never, T, Super).satisfied_by_all_typevars())
+    static_assert(not ConstraintSet.range(Never, T, Base).satisfied_by_all_typevars())
+    static_assert(not ConstraintSet.range(Never, T, Sub).satisfied_by_all_typevars())
+
+    constraints = ConstraintSet.range(Never, T, Super) | ConstraintSet.range(Never, T, Unrelated)
+    static_assert(constraints.satisfied_by_all_typevars())
+    constraints = ConstraintSet.range(Never, T, Base) | ConstraintSet.range(Never, T, Unrelated)
+    static_assert(constraints.satisfied_by_all_typevars())
+    constraints = ConstraintSet.range(Never, T, Sub) | ConstraintSet.range(Never, T, Unrelated)
+    static_assert(not constraints.satisfied_by_all_typevars())
+
+    constraints = ConstraintSet.range(Super, T, Super) | ConstraintSet.range(Unrelated, T, Unrelated)
+    static_assert(not constraints.satisfied_by_all_typevars())
+    constraints = ConstraintSet.range(Base, T, Base) | ConstraintSet.range(Unrelated, T, Unrelated)
+    static_assert(constraints.satisfied_by_all_typevars())
+    constraints = ConstraintSet.range(Sub, T, Sub) | ConstraintSet.range(Unrelated, T, Unrelated)
+    static_assert(not constraints.satisfied_by_all_typevars())
+```

crates/ty_python_semantic/src/types.rs

@@ -4151,6 +4151,14 @@ impl<'db> Type<'db> {
                 ))
                 .into()
             }
+            Type::KnownInstance(KnownInstanceType::ConstraintSet(tracked))
+                if name == "satisfied_by_all_typevars" =>
+            {
+                Place::bound(Type::KnownBoundMethod(
+                    KnownBoundMethodType::ConstraintSetSatisfiedByAllTypeVars(tracked),
+                ))
+                .into()
+            }
 
             Type::ClassLiteral(class)
                 if name == "__get__" && class.is_known(db, KnownClass::FunctionType) =>
@@ -6913,6 +6921,7 @@ impl<'db> Type<'db> {
                 | KnownBoundMethodType::ConstraintSetAlways
                 | KnownBoundMethodType::ConstraintSetNever
                 | KnownBoundMethodType::ConstraintSetImpliesSubtypeOf(_)
+                | KnownBoundMethodType::ConstraintSetSatisfiedByAllTypeVars(_)
             )
             | Type::DataclassDecorator(_)
             | Type::DataclassTransformer(_)
@@ -7064,7 +7073,8 @@ impl<'db> Type<'db> {
                 | KnownBoundMethodType::ConstraintSetRange
                 | KnownBoundMethodType::ConstraintSetAlways
                 | KnownBoundMethodType::ConstraintSetNever
-                | KnownBoundMethodType::ConstraintSetImpliesSubtypeOf(_),
+                | KnownBoundMethodType::ConstraintSetImpliesSubtypeOf(_)
+                | KnownBoundMethodType::ConstraintSetSatisfiedByAllTypeVars(_),
             )
             | Type::DataclassDecorator(_)
             | Type::DataclassTransformer(_)
@@ -10324,6 +10334,7 @@ pub enum KnownBoundMethodType<'db> {
     ConstraintSetAlways,
     ConstraintSetNever,
     ConstraintSetImpliesSubtypeOf(TrackedConstraintSet<'db>),
+    ConstraintSetSatisfiedByAllTypeVars(TrackedConstraintSet<'db>),
 }
 
 pub(super) fn walk_method_wrapper_type<'db, V: visitor::TypeVisitor<'db> + ?Sized>(
@@ -10351,7 +10362,8 @@ pub(super) fn walk_method_wrapper_type<'db, V: visitor::TypeVisitor<'db> + ?Size
         | KnownBoundMethodType::ConstraintSetRange
         | KnownBoundMethodType::ConstraintSetAlways
         | KnownBoundMethodType::ConstraintSetNever
-        | KnownBoundMethodType::ConstraintSetImpliesSubtypeOf(_) => {}
+        | KnownBoundMethodType::ConstraintSetImpliesSubtypeOf(_)
+        | KnownBoundMethodType::ConstraintSetSatisfiedByAllTypeVars(_) => {}
     }
 }
 
@@ -10419,6 +10431,10 @@ impl<'db> KnownBoundMethodType<'db> {
             | (
                 KnownBoundMethodType::ConstraintSetImpliesSubtypeOf(_),
                 KnownBoundMethodType::ConstraintSetImpliesSubtypeOf(_),
+            )
+            | (
+                KnownBoundMethodType::ConstraintSetSatisfiedByAllTypeVars(_),
+                KnownBoundMethodType::ConstraintSetSatisfiedByAllTypeVars(_),
             ) => ConstraintSet::from(true),
 
             (
@@ -10431,7 +10447,8 @@ impl<'db> KnownBoundMethodType<'db> {
                 | KnownBoundMethodType::ConstraintSetRange
                 | KnownBoundMethodType::ConstraintSetAlways
                 | KnownBoundMethodType::ConstraintSetNever
-                | KnownBoundMethodType::ConstraintSetImpliesSubtypeOf(_),
+                | KnownBoundMethodType::ConstraintSetImpliesSubtypeOf(_)
+                | KnownBoundMethodType::ConstraintSetSatisfiedByAllTypeVars(_),
                 KnownBoundMethodType::FunctionTypeDunderGet(_)
                 | KnownBoundMethodType::FunctionTypeDunderCall(_)
                 | KnownBoundMethodType::PropertyDunderGet(_)
@@ -10441,7 +10458,8 @@ impl<'db> KnownBoundMethodType<'db> {
                 | KnownBoundMethodType::ConstraintSetRange
                 | KnownBoundMethodType::ConstraintSetAlways
                 | KnownBoundMethodType::ConstraintSetNever
-                | KnownBoundMethodType::ConstraintSetImpliesSubtypeOf(_),
+                | KnownBoundMethodType::ConstraintSetImpliesSubtypeOf(_)
+                | KnownBoundMethodType::ConstraintSetSatisfiedByAllTypeVars(_),
             ) => ConstraintSet::from(false),
         }
     }
@@ -10494,6 +10512,10 @@ impl<'db> KnownBoundMethodType<'db> {
             (
                 KnownBoundMethodType::ConstraintSetImpliesSubtypeOf(left_constraints),
                 KnownBoundMethodType::ConstraintSetImpliesSubtypeOf(right_constraints),
+            )
+            | (
+                KnownBoundMethodType::ConstraintSetSatisfiedByAllTypeVars(left_constraints),
+                KnownBoundMethodType::ConstraintSetSatisfiedByAllTypeVars(right_constraints),
             ) => left_constraints
                 .constraints(db)
                 .iff(db, right_constraints.constraints(db)),
@@ -10508,7 +10530,8 @@ impl<'db> KnownBoundMethodType<'db> {
                 | KnownBoundMethodType::ConstraintSetRange
                 | KnownBoundMethodType::ConstraintSetAlways
                 | KnownBoundMethodType::ConstraintSetNever
-                | KnownBoundMethodType::ConstraintSetImpliesSubtypeOf(_),
+                | KnownBoundMethodType::ConstraintSetImpliesSubtypeOf(_)
+                | KnownBoundMethodType::ConstraintSetSatisfiedByAllTypeVars(_),
                 KnownBoundMethodType::FunctionTypeDunderGet(_)
                 | KnownBoundMethodType::FunctionTypeDunderCall(_)
                 | KnownBoundMethodType::PropertyDunderGet(_)
@@ -10518,7 +10541,8 @@ impl<'db> KnownBoundMethodType<'db> {
                 | KnownBoundMethodType::ConstraintSetRange
                 | KnownBoundMethodType::ConstraintSetAlways
                 | KnownBoundMethodType::ConstraintSetNever
-                | KnownBoundMethodType::ConstraintSetImpliesSubtypeOf(_),
+                | KnownBoundMethodType::ConstraintSetImpliesSubtypeOf(_)
+                | KnownBoundMethodType::ConstraintSetSatisfiedByAllTypeVars(_),
             ) => ConstraintSet::from(false),
         }
     }
@@ -10542,7 +10566,8 @@ impl<'db> KnownBoundMethodType<'db> {
             | KnownBoundMethodType::ConstraintSetRange
             | KnownBoundMethodType::ConstraintSetAlways
             | KnownBoundMethodType::ConstraintSetNever
-            | KnownBoundMethodType::ConstraintSetImpliesSubtypeOf(_) => self,
+            | KnownBoundMethodType::ConstraintSetImpliesSubtypeOf(_)
+            | KnownBoundMethodType::ConstraintSetSatisfiedByAllTypeVars(_) => self,
         }
     }
 
@@ -10558,7 +10583,10 @@ impl<'db> KnownBoundMethodType<'db> {
             KnownBoundMethodType::ConstraintSetRange
             | KnownBoundMethodType::ConstraintSetAlways
             | KnownBoundMethodType::ConstraintSetNever
-            | KnownBoundMethodType::ConstraintSetImpliesSubtypeOf(_) => KnownClass::ConstraintSet,
+            | KnownBoundMethodType::ConstraintSetImpliesSubtypeOf(_)
+            | KnownBoundMethodType::ConstraintSetSatisfiedByAllTypeVars(_) => {
+                KnownClass::ConstraintSet
+            }
         }
     }
 
@@ -10697,6 +10725,15 @@ impl<'db> KnownBoundMethodType<'db> {
                     Some(KnownClass::ConstraintSet.to_instance(db)),
                 )))
             }
+
+            KnownBoundMethodType::ConstraintSetSatisfiedByAllTypeVars(_) => {
+                Either::Right(std::iter::once(Signature::new(
+                    Parameters::new([Parameter::variadic(Name::new_static("inferable"))
+                        .type_form()
+                        .with_annotated_type(Type::any())]),
+                    Some(KnownClass::Bool.to_instance(db)),
+                )))
+            }
         }
     }
 }

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

@@ -9,6 +9,7 @@ use std::fmt;
 use itertools::{Either, Itertools};
 use ruff_db::parsed::parsed_module;
 use ruff_python_ast::name::Name;
+use rustc_hash::FxHashSet;
 use smallvec::{SmallVec, smallvec, smallvec_inline};
 
 use super::{Argument, CallArguments, CallError, CallErrorKind, InferContext, Signature, Type};
@@ -162,7 +163,7 @@ impl<'db> Bindings<'db> {
             }
         }
 
-        self.evaluate_known_cases(db, dataclass_field_specifiers);
+        self.evaluate_known_cases(db, argument_types, dataclass_field_specifiers);
 
         // In order of precedence:
         //
@@ -284,7 +285,12 @@ impl<'db> Bindings<'db> {
 
     /// Evaluates the return type of certain known callables, where we have special-case logic to
     /// determine the return type in a way that isn't directly expressible in the type system.
-    fn evaluate_known_cases(&mut self, db: &'db dyn Db, dataclass_field_specifiers: &[Type<'db>]) {
+    fn evaluate_known_cases(
+        &mut self,
+        db: &'db dyn Db,
+        argument_types: &CallArguments<'_, 'db>,
+        dataclass_field_specifiers: &[Type<'db>],
+    ) {
         let to_bool = |ty: &Option<Type<'_>>, default: bool| -> bool {
             if let Some(Type::BooleanLiteral(value)) = ty {
                 *value
@@ -1176,6 +1182,26 @@ impl<'db> Bindings<'db> {
                         ));
                     }
 
+                    Type::KnownBoundMethod(
+                        KnownBoundMethodType::ConstraintSetSatisfiedByAllTypeVars(tracked),
+                    ) => {
+                        let inferable: Option<FxHashSet<_>> = overload
+                            .arguments_for_parameter(argument_types, 0)
+                            .map(|(_, ty)| {
+                                ty.as_typevar()
+                                    .map(|bound_typevar| bound_typevar.identity(db))
+                            })
+                            .collect();
+                        let Some(inferable) = inferable else {
+                            continue;
+                        };
+
+                        let result = tracked
+                            .constraints(db)
+                            .satisfied_by_all_typevars(db, InferableTypeVars::One(&inferable));
+                        overload.set_return_type(Type::BooleanLiteral(result));
+                    }
+
                     Type::ClassLiteral(class) => match class.known(db) {
                         Some(KnownClass::Bool) => match overload.parameter_types() {
                             [Some(arg)] => overload.set_return_type(arg.bool(db).into_type(db)),