[ty] Ensure a type[] type T is always considered assignable to a union that holds T and a protocol P (#23901)

AlexWaygood · web-flow · commit 88d1eecd2616 · 2026-03-12T14:36:29.000Z
diff --git a/crates/ty_python_semantic/resources/mdtest/type_of/basic.md b/crates/ty_python_semantic/resources/mdtest/type_of/basic.md
@@ -395,24 +395,29 @@ def _[T]():
     static_assert(not is_disjoint_from(type[InvSub[T]], type[Inv[Any]]))
 ```
 
-## `type[]` types in unions with `Callable` types
+## `type[]` types in unions with `Callable` types and callback protocols
 
 `type[Foo]` is assignable to `Callable[[], Foo]` here:
 
 ```py
-from typing import Callable
+from typing import Callable, Protocol
 from ty_extensions import is_assignable_to, is_subtype_of, static_assert, TypeOf, Top
 
 class Foo:
     def __init__(self): ...
 
+class CustomCallback(Protocol):
+    def __call__(self, /) -> Foo: ...
+
 static_assert(is_assignable_to(type[Foo], Callable[[], Foo]))
+static_assert(is_assignable_to(type[Foo], CustomCallback))
 ```
 
 but it is not a subtype of `Callable[[], Foo]` or redundant with `Callable[[], Foo]`:
 
 ```py
 static_assert(not is_subtype_of(type[Foo], Callable[[], Foo]))
+static_assert(not is_subtype_of(type[Foo], CustomCallback))
 ```
 
 and the reason for that is that constructor signatures are not checked for Liskov violations,
@@ -428,15 +433,17 @@ so if `type[Foo]` were considered a subtype of `Callable[[], Foo]`, then this un
 incorrectly simplified to `Callable[[], Foo]`:
 
 ```py
-def test(x: type[Foo] | Callable[[], Foo]):
-    # this remains unsimplified!
+def test(x: type[Foo] | Callable[[], Foo], y: type[Foo] | CustomCallback):
+    # these remain unsimplified!
     reveal_type(x)  # revealed: type[Foo] | (() -> Foo)
+    reveal_type(y)  # revealed: type[Foo] | CustomCallback
 ```
 
-which means that this assertion would fail:
+which means that these assertions would fail:
 
 ```py
 static_assert(is_subtype_of(type[Bar], type[Foo] | Callable[[], Foo]))
+static_assert(is_subtype_of(type[Bar], type[Foo] | CustomCallback))
 ```
 
 despite the fact that this would still pass!
@@ -466,17 +473,26 @@ constructor signatures:
 
 ```py
 static_assert(is_subtype_of(TypeOf[Foo], Callable[[], Foo]))
+static_assert(is_subtype_of(TypeOf[Foo], CustomCallback))
 static_assert(is_subtype_of(TypeOf[Bar], Callable[[int], Bar]))
 static_assert(not is_subtype_of(TypeOf[Bar], TypeOf[Foo]))
 static_assert(is_subtype_of(TypeOf[Foo], TypeOf[Foo] | Callable[[], Foo]))
+static_assert(is_subtype_of(TypeOf[Foo], TypeOf[Foo] | CustomCallback))
 static_assert(is_subtype_of(TypeOf[Bar], type[Foo] | Callable[[], Foo]))
+static_assert(is_subtype_of(TypeOf[Bar], type[Foo] | CustomCallback))
 static_assert(is_subtype_of(TypeOf[Bar], TypeOf[Bar] | Callable[[], Bar]))
 static_assert(is_subtype_of(TypeOf[Bar], type[Bar] | Callable[[], Bar]))
 static_assert(is_subtype_of(TypeOf[Bar], TypeOf[Bar] | Callable[[int], Bar]))
 static_assert(is_subtype_of(TypeOf[Bar], type[Bar] | Callable[[int], Bar]))
 
-def f(x: TypeOf[Foo] | Callable[[], Foo], y: TypeOf[Bar] | Callable[[int], Bar], z: TypeOf[Bar] | Callable[[], Bar]):
-    reveal_type(x)  # revealed: () -> Foo
-    reveal_type(y)  # revealed: (int, /) -> Bar
-    reveal_type(z)  # revealed: <class 'Bar'> | (() -> Bar)
+def f(
+    a: TypeOf[Foo] | Callable[[], Foo],
+    b: TypeOf[Bar] | Callable[[int], Bar],
+    c: TypeOf[Bar] | Callable[[], Bar],
+    d: TypeOf[Foo] | CustomCallback,
+):
+    reveal_type(a)  # revealed: () -> Foo
+    reveal_type(b)  # revealed: (int, /) -> Bar
+    reveal_type(c)  # revealed: <class 'Bar'> | (() -> Bar)
+    reveal_type(d)  # revealed: CustomCallback
 ```
diff --git a/crates/ty_python_semantic/src/types.rs b/crates/ty_python_semantic/src/types.rs
@@ -19,6 +19,7 @@ use ruff_text_size::Ranged;
 use smallvec::smallvec_inline;
 use ty_module_resolver::{KnownModule, Module, ModuleName, resolve_module};
 
+pub(crate) use self::callable::UpcastPolicy;
 pub use self::cyclic::CycleDetector;
 pub(crate) use self::cyclic::TypeTransformer;
 pub(crate) use self::diagnostic::register_lints;
diff --git a/crates/ty_python_semantic/src/types/callable.rs b/crates/ty_python_semantic/src/types/callable.rs
@@ -41,6 +41,14 @@ impl<'db> Type<'db> {
     }
 
     pub(crate) fn try_upcast_to_callable(self, db: &'db dyn Db) -> Option<CallableTypes<'db>> {
+        self.try_upcast_to_callable_with_policy(db, UpcastPolicy::default())
+    }
+
+    pub(crate) fn try_upcast_to_callable_with_policy(
+        self,
+        db: &'db dyn Db,
+        policy: UpcastPolicy,
+    ) -> Option<CallableTypes<'db>> {
         match self {
             Type::Callable(callable) => Some(CallableTypes::one(callable)),
 
@@ -68,7 +76,7 @@ impl<'db> Type<'db> {
                 if let Place::Defined(place) = call_symbol
                     && place.is_definitely_defined()
                 {
-                    place.ty.try_upcast_to_callable(db)
+                    place.ty.try_upcast_to_callable_with_policy(db, policy)
                 } else {
                     None
                 }
@@ -79,16 +87,25 @@ impl<'db> Type<'db> {
 
             Type::GenericAlias(alias) => Some(ClassType::Generic(alias).into_callable(db)),
 
-            Type::NewTypeInstance(newtype) => {
-                newtype.concrete_base_type(db).try_upcast_to_callable(db)
+            Type::NewTypeInstance(newtype) => newtype
+                .concrete_base_type(db)
+                .try_upcast_to_callable_with_policy(db, policy),
+
+            Type::SubclassOf(subclass_of_ty) if policy == UpcastPolicy::Sound => {
+                Some(CallableTypes::one(CallableType::function_like(
+                    db,
+                    Signature::new(Parameters::top(), subclass_of_ty.to_instance(db)),
+                )))
             }
 
             // TODO: This is unsound so in future we can consider an opt-in option to disable it.
             Type::SubclassOf(subclass_of_ty) => match subclass_of_ty.subclass_of() {
                 SubclassOfInner::Class(class) => Some(class.into_callable(db)),
                 SubclassOfInner::TypeVar(tvar) => match tvar.typevar(db).bound_or_constraints(db) {
                     Some(TypeVarBoundOrConstraints::UpperBound(bound)) => {
-                        let upcast_callables = bound.to_meta_type(db).try_upcast_to_callable(db)?;
+                        let upcast_callables = bound
+                            .to_meta_type(db)
+                            .try_upcast_to_callable_with_policy(db, policy)?;
                         Some(upcast_callables.map(|callable| {
                             let signatures = callable
                                 .signatures(db)
@@ -104,8 +121,9 @@ impl<'db> Type<'db> {
                     Some(TypeVarBoundOrConstraints::Constraints(constraints)) => {
                         let mut callables = SmallVec::new();
                         for constraint in constraints.elements(db) {
-                            let element_upcast =
-                                constraint.to_meta_type(db).try_upcast_to_callable(db)?;
+                            let element_upcast = constraint
+                                .to_meta_type(db)
+                                .try_upcast_to_callable_with_policy(db, policy)?;
                             for callable in element_upcast.into_inner() {
                                 let signatures = callable
                                     .signatures(db)
@@ -134,7 +152,8 @@ impl<'db> Type<'db> {
             Type::Union(union) => {
                 let mut callables = SmallVec::new();
                 for element in union.elements(db) {
-                    let element_callable = element.try_upcast_to_callable(db)?;
+                    let element_callable =
+                        element.try_upcast_to_callable_with_policy(db, policy)?;
                     callables.extend(element_callable.into_inner());
                 }
                 Some(CallableTypes::new(callables))
@@ -143,11 +162,13 @@ impl<'db> Type<'db> {
             Type::LiteralValue(literal) => match literal.kind() {
                 LiteralValueTypeKind::Enum(enum_literal) => enum_literal
                     .enum_class_instance(db)
-                    .try_upcast_to_callable(db),
+                    .try_upcast_to_callable_with_policy(db, policy),
                 _ => None,
             },
 
-            Type::TypeAlias(alias) => alias.value_type(db).try_upcast_to_callable(db),
+            Type::TypeAlias(alias) => alias
+                .value_type(db)
+                .try_upcast_to_callable_with_policy(db, policy),
 
             Type::KnownBoundMethod(method) => Some(CallableTypes::one(CallableType::new(
                 db,
@@ -220,6 +241,50 @@ pub enum CallableTypeKind {
     ParamSpecValue,
 }
 
+/// A "policy" enum that describes how `type[]` types should be upcast
+/// to `Callable` types.
+///
+/// `type[T]` is generally considered assignable to
+/// `Callable[<constructor signature of T>, T]` in Python, and most
+/// type-checking in Python uses assignability rather than subtyping
+/// when determining whether to emit errors on code, so -- despite its
+/// scary name -- [`UpcastPolicy::Unsound`] is actually the policy that
+/// you probably want in most situations. We *have* to use
+/// [`UpcastPolicy::Sound`], however, when doing subtyping or redundancy
+/// checks, because constructor signatures in subclasses are not checked
+/// for Liskov substitutability: `type[S]` may not be a subtype of
+/// `Callable[<constructor signature of T>, T]` even if `S` is a subtype
+/// of `T`. If this unsoundness leaked into our union simplification or
+/// subtyping checks, it would ead to nontransitivity of subtyping,
+/// breaking fundamental assumptions in our model.
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Default)]
+pub(crate) enum UpcastPolicy {
+    /// Only upcast types to callables in a sound fashion.
+    ///
+    /// This means that `type[T]` is upcast to `Top[Callable[..., T]]`
+    /// rather than `Callable[<constructor signature of T>, T]`,
+    /// since the former is sound while the latter is not.
+    Sound,
+
+    /// Allow unsound upcasts to callables, such as treating `type[T]` as
+    /// `Callable[<constructor signature of T>, T`.
+    #[default]
+    Unsound,
+}
+
+impl From<TypeRelation> for UpcastPolicy {
+    fn from(relation: TypeRelation) -> Self {
+        match relation {
+            TypeRelation::Subtyping
+            | TypeRelation::Redundancy { .. }
+            | TypeRelation::SubtypingAssuming => UpcastPolicy::Sound,
+            TypeRelation::Assignability | TypeRelation::ConstraintSetAssignability => {
+                UpcastPolicy::Unsound
+            }
+        }
+    }
+}
+
 /// This type represents the set of all callable objects with a certain, possibly overloaded,
 /// signature.
 ///
diff --git a/crates/ty_python_semantic/src/types/protocol_class.rs b/crates/ty_python_semantic/src/types/protocol_class.rs
@@ -6,9 +6,9 @@ use itertools::Itertools;
 use ruff_python_ast::name::Name;
 use rustc_hash::FxHashMap;
 
-use crate::types::TypeContext;
 use crate::types::callable::CallableTypeKind;
 use crate::types::relation::{HasRelationToVisitor, IsDisjointVisitor, TypeRelation};
+use crate::types::{TypeContext, UpcastPolicy};
 use crate::{
     Db, FxOrderSet,
     place::{
@@ -780,10 +780,9 @@ impl<'a, 'db> ProtocolMember<'a, 'db> {
                 // With the new solver, we should be to replace all of this with an additional
                 // constraint that enforces what `Self` can specialize to.
                 let fallback_other = other.literal_fallback_instance(db).unwrap_or(other);
-                attribute_type.try_upcast_to_callable(db).when_some_and(
-                    db,
-                    constraints,
-                    |callables| {
+                attribute_type
+                    .try_upcast_to_callable_with_policy(db, UpcastPolicy::from(relation))
+                    .when_some_and(db, constraints, |callables| {
                         callables
                             .map(|callable| callable.apply_self(db, fallback_other))
                             .has_relation_to_impl(
@@ -795,8 +794,7 @@ impl<'a, 'db> ProtocolMember<'a, 'db> {
                                 relation_visitor,
                                 disjointness_visitor,
                             )
-                    },
-                )
+                    })
             }
             // TODO: consider the types of the attribute on `other` for property members
             ProtocolMemberKind::Property(_) => ConstraintSet::from_bool(
diff --git a/crates/ty_python_semantic/src/types/relation.rs b/crates/ty_python_semantic/src/types/relation.rs
@@ -10,9 +10,9 @@ use crate::types::cyclic::PairVisitor;
 use crate::types::enums::is_single_member_enum;
 use crate::types::set_theoretic::RecursivelyDefined;
 use crate::types::{
-    CallableType, CallableTypes, ClassBase, ClassType, CycleDetector, DynamicType, KnownClass,
-    KnownInstanceType, LiteralValueTypeKind, MemberLookupPolicy, Parameters, ProtocolInstanceType,
-    Signature, SubclassOfInner, TypeVarBoundOrConstraints, UnionType,
+    CallableType, ClassBase, ClassType, CycleDetector, DynamicType, KnownClass, KnownInstanceType,
+    LiteralValueTypeKind, MemberLookupPolicy, ProtocolInstanceType, SubclassOfInner,
+    TypeVarBoundOrConstraints, UnionType, UpcastPolicy,
 };
 use crate::{
     Db,
@@ -1185,37 +1185,19 @@ impl<'db> Type<'db> {
                 }),
 
             (_, Type::Callable(other_callable)) => {
-                // Special-case: upcasting a subclass-of to its `Callable` "supertype" is unsound,
-                // because we don't do Liskov checks for constructor signatures.
-                let upcasted = if let Type::SubclassOf(inner) = self {
-                    match relation {
-                        TypeRelation::Subtyping
-                        | TypeRelation::SubtypingAssuming
-                        | TypeRelation::Redundancy { .. } => {
-                            Some(CallableTypes::one(CallableType::function_like(
-                                db,
-                                Signature::new(Parameters::top(), inner.to_instance(db)),
-                            )))
-                        }
-                        TypeRelation::Assignability | TypeRelation::ConstraintSetAssignability => {
-                            self.try_upcast_to_callable(db)
-                        }
-                    }
-                } else {
-                    self.try_upcast_to_callable(db)
-                };
                 relation_visitor.visit((self, target, relation), || {
-                    upcasted.when_some_and(db, constraints, |callables| {
-                        callables.has_relation_to_impl(
-                            db,
-                            other_callable,
-                            constraints,
-                            inferable,
-                            relation,
-                            relation_visitor,
-                            disjointness_visitor,
-                        )
-                    })
+                    self.try_upcast_to_callable_with_policy(db, UpcastPolicy::from(relation))
+                        .when_some_and(db, constraints, |callables| {
+                            callables.has_relation_to_impl(
+                                db,
+                                other_callable,
+                                constraints,
+                                inferable,
+                                relation,
+                                relation_visitor,
+                                disjointness_visitor,
+                            )
+                        })
                 })
             }
 
