[ty] Infer typevar specializations for Callable types

crates/ty_python_semantic/resources/mdtest/annotations/self.md

@@ -189,7 +189,7 @@ reveal_type(B().name_does_not_matter())  # revealed: B
 reveal_type(B().positional_only(1))  # revealed: B
 reveal_type(B().keyword_only(x=1))  # revealed: B
 # TODO: This should deally be `B`
-reveal_type(B().decorated_method())  # revealed: Unknown
+reveal_type(B().decorated_method())  # revealed: Self@decorated_method | Unknown
 
 reveal_type(B().a_property)  # revealed: B
 

crates/ty_python_semantic/resources/mdtest/async.md

@@ -43,9 +43,7 @@ async def main():
     loop = asyncio.get_event_loop()
     with concurrent.futures.ThreadPoolExecutor() as pool:
         result = await loop.run_in_executor(pool, blocking_function)
-
-        # TODO: should be `int`
-        reveal_type(result)  # revealed: Unknown
+        reveal_type(result)  # revealed: int
 ```
 
 ### `asyncio.Task`

crates/ty_python_semantic/resources/mdtest/dataclasses/fields.md

@@ -82,8 +82,7 @@ def get_default() -> str:
 
 reveal_type(field(default=1))  # revealed: dataclasses.Field[Literal[1]]
 reveal_type(field(default=None))  # revealed: dataclasses.Field[None]
-# TODO: this could ideally be `dataclasses.Field[str]` with a better generics solver
-reveal_type(field(default_factory=get_default))  # revealed: dataclasses.Field[Unknown]
+reveal_type(field(default_factory=get_default))  # revealed: dataclasses.Field[str]
 ```
 
 ## dataclass_transform field_specifiers

crates/ty_python_semantic/resources/mdtest/decorators.md

@@ -144,11 +144,12 @@ from functools import cache
 def f(x: int) -> int:
     return x**2
 
-# TODO: Should be `_lru_cache_wrapper[int]`
-reveal_type(f)  # revealed: _lru_cache_wrapper[Unknown]
-
-# TODO: Should be `int`
-reveal_type(f(1))  # revealed: Unknown
+# TODO: revealed: _lru_cache_wrapper[int]
+# revealed: _lru_cache_wrapper[int] | _lru_cache_wrapper[Unknown]
+reveal_type(f)
+# TODO: revealed: int
+# revealed: int | Unknown
+reveal_type(f(1))
 ```
 
 ## Lambdas as decorators

crates/ty_python_semantic/resources/mdtest/deprecated.md

@@ -11,9 +11,9 @@ classes. Uses of these items should subsequently produce a warning.
 from typing_extensions import deprecated
 
 @deprecated("use OtherClass")
-def myfunc(): ...
+def myfunc(x: int): ...
 
-myfunc()  # error: [deprecated] "use OtherClass"
+myfunc(1)  # error: [deprecated] "use OtherClass"
 ```
 
 ```py

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

@@ -379,14 +379,13 @@ T = TypeVar("T")
 def invoke(fn: Callable[[A], B], value: A) -> B:
     return fn(value)
 
-def identity(x: T) -> T:
+def identity(x: T, /) -> T:
     return x
 
-def head(xs: list[T]) -> T:
+def head(xs: list[T], /) -> T:
     return xs[0]
 
-# TODO: this should be `Literal[1]`
-reveal_type(invoke(identity, 1))  # revealed: Unknown
+reveal_type(invoke(identity, 1))  # revealed: Literal[1]
 
 # TODO: this should be `Unknown | int`
 reveal_type(invoke(head, [1, 2, 3]))  # revealed: Unknown

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

@@ -490,8 +490,7 @@ V = TypeVar("V", default="V")
 class D(Generic[V]):
     x: V
 
-# TODO: we shouldn't leak a typevar like this in type inference
-reveal_type(D().x)  # revealed: V@D
+reveal_type(D().x)  # revealed: Unknown
 ```
 
 ## Regression

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

@@ -334,14 +334,13 @@ from typing import Callable
 def invoke[A, B](fn: Callable[[A], B], value: A) -> B:
     return fn(value)
 
-def identity[T](x: T) -> T:
+def identity[T](x: T, /) -> T:
     return x
 
-def head[T](xs: list[T]) -> T:
+def head[T](xs: list[T], /) -> T:
     return xs[0]
 
-# TODO: this should be `Literal[1]`
-reveal_type(invoke(identity, 1))  # revealed: Unknown
+reveal_type(invoke(identity, 1))  # revealed: Literal[1]
 
 # TODO: this should be `Unknown | int`
 reveal_type(invoke(head, [1, 2, 3]))  # revealed: Unknown
@@ -583,3 +582,108 @@ def f[T](x: T, y: Not[T]) -> T:
     y = x  # error: [invalid-assignment]
     return x
 ```
+
+## `Callable` parameters
+
+We can recurse into the parameters and return values of `Callable` parameters to infer
+specializations of a generic function.
+
+```py
+from typing import Any, Callable, NoReturn, overload, Self
+
+def accepts_callable[**P, R](callable: Callable[P, R]) -> Callable[P, R]:
+    return callable
+
+def returns_int() -> int:
+    raise NotImplementedError
+
+# revealed: int
+reveal_type(accepts_callable(returns_int)())
+
+class ClassWithoutConstructor: ...
+
+# revealed: ClassWithoutConstructor
+reveal_type(accepts_callable(ClassWithoutConstructor)())
+
+class ClassWithNew:
+    def __new__(cls, *args, **kwargs) -> Self:
+        raise NotImplementedError
+
+# revealed: ClassWithNew
+reveal_type(accepts_callable(ClassWithNew)())
+
+class ClassWithInit:
+    def __init__(self) -> None: ...
+
+# revealed: ClassWithInit
+reveal_type(accepts_callable(ClassWithInit)())
+
+class ClassWithNewAndInit:
+    def __new__(cls, *args, **kwargs) -> Self:
+        raise NotImplementedError
+
+    def __init__(self) -> None: ...
+
+# revealed: ClassWithNewAndInit
+reveal_type(accepts_callable(ClassWithNewAndInit)())
+
+class Meta(type):
+    def __call__(cls, *args: Any, **kwargs: Any) -> NoReturn:
+        raise NotImplementedError
+
+class ClassWithNoReturnMetatype(metaclass=Meta):
+    def __new__(cls, *args: Any, **kwargs: Any) -> Self:
+        raise NotImplementedError
+
+# revealed: Never
+reveal_type(accepts_callable(ClassWithNoReturnMetatype)())
+
+class Proxy: ...
+
+class ClassWithIgnoredInit:
+    def __new__(cls) -> Proxy:
+        return Proxy()
+
+    def __init__(self, x: int) -> None: ...
+
+# revealed: Proxy
+reveal_type(accepts_callable(ClassWithIgnoredInit)())
+
+class ClassWithOverloadedInit[T]:
+    t: T  # invariant
+
+    @overload
+    def __init__(self: "ClassWithOverloadedInit[int]", x: int) -> None: ...
+    @overload
+    def __init__(self: "ClassWithOverloadedInit[str]", x: str) -> None: ...
+    def __init__(self, x: int | str) -> None: ...
+
+# TODO: The old solver cannot handle this overloaded constructor. The ideal solution is that we
+# would solve **P once, and map it to the entire overloaded signature of the constructor. This
+# mapping would have to include the return types, since there are different return types for each
+# overload. We would then also have to determine that R must be equal to the return type of **P's
+# solution.
+
+# TODO: revealed: ClassWithOverloadedInit[int]
+# revealed: ClassWithOverloadedInit[int] | ClassWithOverloadedInit[str]
+reveal_type(accepts_callable(ClassWithOverloadedInit)(0))
+# TODO: revealed: ClassWithOverloadedInit[str]
+# revealed: ClassWithOverloadedInit[int] | ClassWithOverloadedInit[str]
+reveal_type(accepts_callable(ClassWithOverloadedInit)(""))
+
+class GenericClass[T]:
+    t: T  # invariant
+
+    def __new__(cls, x: list[T], y: list[T]) -> Self:
+        raise NotImplementedError
+
+def _(x: list[str]):
+    # TODO: This fails because we are not propagating GenericClass's generic context into the
+    # Callable that we create for it.
+    # TODO: revealed: GenericClass[str]
+    # TODO: no errors
+    # revealed: GenericClass[T@GenericClass]
+    # error: [invalid-argument-type]
+    # error: [invalid-argument-type]
+    reveal_type(accepts_callable(GenericClass)(x, x))
+```

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

@@ -392,15 +392,13 @@ def f3(x: int, y: str) -> int:
     return 1
 
 # TODO: This should reveal `(x: int, y: str) -> bool` but there's a cycle: https://github.com/astral-sh/ty/issues/1729
-reveal_type(f3)  # revealed: ((x: int, y: str) -> bool) | ((x: Divergent, y: Divergent) -> bool)
+reveal_type(f3)  # revealed: ((x: int, y: str) -> bool) | ((...) -> bool)
 
 reveal_type(f3(1, "a"))  # revealed: bool
 reveal_type(f3(x=1, y="a"))  # revealed: bool
 reveal_type(f3(1, y="a"))  # revealed: bool
 reveal_type(f3(y="a", x=1))  # revealed: bool
 
-# TODO: There should only be one error but the type of `f3` is a union: https://github.com/astral-sh/ty/issues/1729
-# error: [missing-argument] "No argument provided for required parameter `y`"
 # error: [missing-argument] "No argument provided for required parameter `y`"
 f3(1)
 # error: [invalid-argument-type] "Argument is incorrect: Expected `int`, found `Literal["a"]`"
@@ -480,7 +478,8 @@ class C[**P]:
     def __init__(self, f: Callable[P, int]) -> None:
         self.f = f
 
-def f(x: int, y: str) -> bool:
+# Note that the return type must match exactly, since C is invariant on the return type of C.f.
+def f(x: int, y: str) -> int:
     return True
 
 c = C(f)
@@ -632,18 +631,24 @@ def with_parameters[**P](f: Callable[P, int], *args: P.args, **kwargs: P.kwargs)
         return str(f(*args, **kwargs))
     return nested
 
-reveal_type(change_return_type(int_int))  # revealed: Overload[(x: int) -> str, (x: str) -> str]
+# revealed: Overload[(x: int) -> str, (x: str) -> str]
+reveal_type(change_return_type(int_int))
 
 # TODO: This shouldn't error and should pick the first overload because of the return type
 # error: [invalid-argument-type]
-reveal_type(change_return_type(int_str))  # revealed: Overload[(x: int) -> str, (x: str) -> str]
+# revealed: Overload[(x: int) -> str, (x: str) -> str]
+reveal_type(change_return_type(int_str))
 
+# TODO: revealed: Overload[(x: int) -> str, (x: str) -> str]
 # error: [invalid-argument-type]
-reveal_type(change_return_type(str_str))  # revealed: Overload[(x: int) -> str, (x: str) -> str]
+# revealed: (...) -> str
+reveal_type(change_return_type(str_str))
 
 # TODO: Both of these shouldn't raise an error
 # error: [invalid-argument-type]
-reveal_type(with_parameters(int_int, 1))  # revealed: Overload[(x: int) -> str, (x: str) -> str]
+# revealed: Overload[(x: int) -> str, (x: str) -> str]
+reveal_type(with_parameters(int_int, 1))
 # error: [invalid-argument-type]
-reveal_type(with_parameters(int_int, "a"))  # revealed: Overload[(x: int) -> str, (x: str) -> str]
+# revealed: Overload[(x: int) -> str, (x: str) -> str]
+reveal_type(with_parameters(int_int, "a"))
 ```

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

@@ -863,7 +863,7 @@ reveal_type(C[int]().y)  # revealed: int
 class D[T = T]:
     x: T
 
-reveal_type(D().x)  # revealed: T@D
+reveal_type(D().x)  # revealed: Unknown
 ```
 
 [pep 695]: https://peps.python.org/pep-0695/

crates/ty_python_semantic/resources/mdtest/literal_promotion.md

@@ -304,7 +304,7 @@ x11: list[Literal[1] | Literal[2] | Literal[3]] = [1, 2, 3]
 reveal_type(x11)  # revealed: list[Literal[1, 2, 3]]
 
 x12: Y[Y[Literal[1]]] = [[1]]
-reveal_type(x12)  # revealed: list[Y[Literal[1]]]
+reveal_type(x12)  # revealed: list[list[Literal[1]]]
 
 x13: list[tuple[Literal[1], Literal[2], Literal[3]]] = [(1, 2, 3)]
 reveal_type(x13)  # revealed: list[tuple[Literal[1], Literal[2], Literal[3]]]

crates/ty_python_semantic/resources/mdtest/snapshots/deprecated.md_-_Tests_for_the_`@depr…_-_Introduction_(cff2724f4c9d28c4).snap

@@ -15,9 +15,9 @@ mdtest path: crates/ty_python_semantic/resources/mdtest/deprecated.md
  1 | from typing_extensions import deprecated
  2 | 
  3 | @deprecated("use OtherClass")
- 4 | def myfunc(): ...
+ 4 | def myfunc(x: int): ...
  5 | 
- 6 | myfunc()  # error: [deprecated] "use OtherClass"
+ 6 | myfunc(1)  # error: [deprecated] "use OtherClass"
  7 | from typing_extensions import deprecated
  8 | 
  9 | @deprecated("use BetterClass")
@@ -42,9 +42,9 @@ mdtest path: crates/ty_python_semantic/resources/mdtest/deprecated.md
 warning[deprecated]: The function `myfunc` is deprecated
  --> src/mdtest_snippet.py:6:1
   |
-4 | def myfunc(): ...
+4 | def myfunc(x: int): ...
 5 |
-6 | myfunc()  # error: [deprecated] "use OtherClass"
+6 | myfunc(1)  # error: [deprecated] "use OtherClass"
   | ^^^^^^ use OtherClass
 7 | from typing_extensions import deprecated
   |

crates/ty_python_semantic/resources/mdtest/with/async.md

@@ -213,7 +213,7 @@ async def connect() -> AsyncGenerator[Session]:
     yield Session()
 
 # TODO: this should be `() -> _AsyncGeneratorContextManager[Session, None]`
-reveal_type(connect)  # revealed: () -> _AsyncGeneratorContextManager[Unknown, None]
+reveal_type(connect)  # revealed: (...) -> _AsyncGeneratorContextManager[Unknown, None]
 
 async def main():
     async with connect() as session: