[ty] Fix upcasting type[T] types to Callable types (#23472)

Author: AlexWaygood

crates/ty_python_semantic/resources/mdtest/type_of/generics.md

@@ -491,3 +491,98 @@ expects_type_c_default(C[int])
 expects_type_c_default_of_int(C[str])
 expects_type_c_default_of_int_str(C[str, int])
 ```
+
+## Upcasting a `type[]` type to a `Callable` type
+
+`type[T]` accepts the same parameters as `object.__init__` if `T` does not have an upper bound. If
+`T` is bound to a nominal-instance type, `type[T]` accepts the same parameters as the constructor of
+the class that the instance-type refers to.
+
+```py
+from ty_extensions import CallableTypeOf
+
+class TakesStrInConstructor:
+    def __init__(self, x: int, y: str | None = None): ...
+
+class TakesIntInConstructor:
+    def __init__(self, x: int, y: int | None = None): ...
+
+def f[
+    T,
+    T1: object,
+    T2: int,
+    T3: TakesStrInConstructor | TakesIntInConstructor,
+    T4: (TakesStrInConstructor, TakesIntInConstructor),
+](
+    bare_type: type,
+    type_object: type[object],
+    type_t_unbound: type[T],
+    type_t_object_bound: type[T1],
+    type_int: type[int],
+    type_t_int_bound: type[T2],
+    type_t_union_bound: type[T3],
+    type_t_constrained: type[T4],
+):
+    # TODO: these are all `Any` because of typeshed's signature for `type.__call__`.
+    # We could consider overriding that.
+    reveal_type(bare_type())  # revealed: Any
+    reveal_type(type_object())  # revealed: Any
+
+    # TODO: we could consider emitting errors for these two, but don't currently,
+    # for the same reason
+    reveal_type(bare_type(""))  # revealed: Any
+    reveal_type(type_object(""))  # revealed: Any
+
+    reveal_type(type_t_unbound())  # revealed: T@f
+    reveal_type(type_t_unbound(""))  # revealed: T@f
+
+    reveal_type(type_int())  # revealed: int
+    reveal_type(type_int("1"))  # revealed: int
+    # error: [invalid-argument-type]
+    reveal_type(type_int([]))  # revealed: int
+
+    reveal_type(type_t_union_bound(42))  # revealed: T3@f
+    # error: [invalid-argument-type]
+    reveal_type(type_t_union_bound(42, ""))  # revealed: T3@f
+    # error: [invalid-argument-type]
+    reveal_type(type_t_union_bound(42, 42))  # revealed: T3@f
+
+    reveal_type(type_t_constrained(42))  # revealed: T4@f
+    # error: [invalid-argument-type]
+    reveal_type(type_t_constrained(42, ""))  # revealed: T4@f
+    # error: [invalid-argument-type]
+    reveal_type(type_t_constrained(42, 42))  # revealed: T4@f
+
+    def g(
+        object_class_upcast: CallableTypeOf[object],
+        bare_type_upcast: CallableTypeOf[bare_type],
+        type_object_upcast: CallableTypeOf[type_object],
+        type_t_unbound_upcast: CallableTypeOf[type_t_unbound],
+        type_t_object_bound_upcast: CallableTypeOf[type_t_object_bound],
+        type_int_upcast: CallableTypeOf[type_int],
+        type_t_int_bound_upcast: CallableTypeOf[type_t_int_bound],
+        type_t_union_bound_upcast: CallableTypeOf[type_t_union_bound],
+        type_t_constrained_upcast: CallableTypeOf[type_t_constrained],
+    ):
+        reveal_type(object_class_upcast)  # revealed: () -> object
+
+        # TODO: these two could arguably be `() -> object`,
+        # but have more dynamic signatures due to typeshed's `type.__call__` annotations.
+        # We could consider overriding those.
+        reveal_type(bare_type_upcast)  # revealed: (...) -> Any
+        reveal_type(type_object_upcast)  # revealed: (...) -> Any
+
+        # TODO: if we did decide to override typeshed's `type.__call__` annotations (see above),
+        # we should also turn these two into `() -> T@f` / `() -> T1@f`
+        reveal_type(type_t_unbound_upcast)  # revealed: (...) -> T@f
+        reveal_type(type_t_object_bound_upcast)  # revealed: (...) -> T1@f
+
+        # revealed: Overload[(x: str | Buffer | SupportsInt | SupportsIndex | SupportsTrunc = 0, /) -> int, (x: str | bytes | bytearray, /, base: SupportsIndex) -> int]
+        reveal_type(type_int_upcast)
+        # revealed: Overload[(x: str | Buffer | SupportsInt | SupportsIndex | SupportsTrunc = 0, /) -> T2@f, (x: str | bytes | bytearray, /, base: SupportsIndex) -> T2@f]
+        reveal_type(type_t_int_bound_upcast)
+        # revealed: ((x: int, y: str | None = None) -> T3@f) | ((x: int, y: int | None = None) -> T3@f)
+        reveal_type(type_t_union_bound_upcast)
+        # revealed: ((x: int, y: str | None = None) -> T4@f) | ((x: int, y: int | None = None) -> T4@f)
+        reveal_type(type_t_constrained_upcast)
+```

crates/ty_python_semantic/src/types.rs

@@ -2092,13 +2092,49 @@ impl<'db> Type<'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::Dynamic(_) | SubclassOfInner::TypeVar(_) => {
-                    Some(CallableTypes::one(CallableType::single(
+                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)?;
+                        Some(upcast_callables.map(|callable| {
+                            let signatures = callable
+                                .signatures(db)
+                                .into_iter()
+                                .map(|sig| sig.clone().with_return_type(Type::TypeVar(tvar)));
+                            CallableType::new(
+                                db,
+                                CallableSignature::from_overloads(signatures),
+                                callable.kind(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)?;
+                            for callable in element_upcast.into_inner() {
+                                let signatures = callable
+                                    .signatures(db)
+                                    .into_iter()
+                                    .map(|sig| sig.clone().with_return_type(Type::TypeVar(tvar)));
+                                callables.push(CallableType::new(
+                                    db,
+                                    CallableSignature::from_overloads(signatures),
+                                    callable.kind(db),
+                                ));
+                            }
+                        }
+                        Some(CallableTypes(callables))
+                    }
+                    None => Some(CallableTypes::one(CallableType::single(
                         db,
-                        Signature::new(Parameters::unknown(), Type::from(subclass_of_ty)),
-                    )))
-                }
+                        Signature::new(Parameters::gradual_form(), Type::TypeVar(tvar)),
+                    ))),
+                },
+                SubclassOfInner::Dynamic(_) => Some(CallableTypes::one(CallableType::single(
+                    db,
+                    Signature::new(Parameters::unknown(), Type::from(subclass_of_ty)),
+                ))),
             },
 
             Type::Union(union) => {
@@ -4287,25 +4323,23 @@ impl<'db> Type<'db> {
                     Binding::single(self, Signature::dynamic(Type::Dynamic(dynamic_type))).into()
                 }
                 SubclassOfInner::Class(class) => self.constructor_bindings(db, class),
-                SubclassOfInner::TypeVar(bound_typevar) => {
-                    let Some(class) = (match bound_typevar.typevar(db).bound_or_constraints(db) {
-                        None | Some(TypeVarBoundOrConstraints::UpperBound(_)) => {
-                            subclass_of_type.subclass_of().into_class(db)
+                SubclassOfInner::TypeVar(tvar) => {
+                    let bindings = match tvar.typevar(db).bound_or_constraints(db) {
+                        None => KnownClass::Type.to_instance(db).bindings(db),
+                        Some(TypeVarBoundOrConstraints::UpperBound(bound)) => {
+                            bound.to_meta_type(db).bindings(db)
+                        }
+                        Some(TypeVarBoundOrConstraints::Constraints(constraints)) => {
+                            Bindings::from_union(
+                                self,
+                                constraints
+                                    .elements(db)
+                                    .iter()
+                                    .map(|ty| ty.to_meta_type(db).bindings(db)),
+                            )
                         }
-                        // TODO: model calls to `type[T]` where `T` is constrained
-                        Some(TypeVarBoundOrConstraints::Constraints(_)) => None,
-                    }) else {
-                        return Binding::single(
-                            self,
-                            Signature::new(
-                                Parameters::gradual_form(),
-                                self.to_instance(db).unwrap_or(Type::unknown()),
-                            ),
-                        )
-                        .into();
                     };
-
-                    self.constructor_bindings(db, class)
+                    bindings.with_constructor_instance_type(Type::TypeVar(tvar))
                 }
             },
 

crates/ty_python_semantic/src/types/signatures.rs

@@ -1715,6 +1715,11 @@ impl<'db> Signature<'db> {
     pub(crate) fn with_definition(self, definition: Option<Definition<'db>>) -> Self {
         Self { definition, ..self }
     }
+
+    /// Create a new signature with the given return type.
+    pub(crate) fn with_return_type(self, return_ty: Type<'db>) -> Self {
+        Self { return_ty, ..self }
+    }
 }
 
 impl<'db> VarianceInferable<'db> for &Signature<'db> {