from collections.abc import Callable
from ty_extensions import TypeOf

class Box[T]:
    @staticmethod
    def method(x: T) -> T:
        return x

def factory[T]() -> Callable[[TypeOf[Box[T].method]], T]:
    raise NotImplementedError

# The following is a case of the "typevar only appears inside a returned
# `Callable`" rule involving a `FunctionLiteral`. The only occurrence of
# `factory`'s `T` is in the return annotation, under `Callable[...]`, so
# `factory` itself should become non-generic and `factory()` should return a
# generic callable instead. In that returned callable, the old `T@factory`
# should be consistently rewritten to the new callable-owned typevar, usually
# displayed as `T'return@factory`. That means its parameter should be the exact
# function type `TypeOf[Box[T'return]. method]`, and passing `Box[int].method`
# should instantiate the returned callable at `T'return = int`.
#
# The current fix skips applying this rewrite recursively into `FunctionLiteral`
# types. `TypeOf[Box[T].method]` is represented as a function-literal-shaped
# type, so the outer returned `Callable` gets the new `T'return`, but the exact
# function type inside its parameter still contains the stale `T@factory`. Since
# `factory` is no longer generic, that stale `T@factory` is no longer something
# the returned callable can bind. As a result, ty rejects `Box[int].method`
# (`def method(x: int) -> int`) against the stale expected type
# (`def method(x: T@factory) -> T@factory`). This line should type-check and
# have type `int`. On main it's currently `Unknown`, but there is no diagnostic.

factory()(Box[int].method)  # error[invalid-argument-type]