generics are removed from function signatures that are assigned to `Callable` types

from typing import TypeVar, Callable

T = TypeVar("T")

def asdf(fn: Callable[[], T]) -> Callable[[], T]: ...

@asdf
def foo() -> list[T]: ...

reveal_type(foo) # "def () -> list[Never]", should be "def [T] () -> list[T]"

playground

use case

i'm making a @NoInstance decorator that bans usages of classmethods on instances:

from typing import TypeVar, ParamSpec, Concatenate, Callable, Generic, overload, Never

out_T = TypeVar("out_T", covariant=True)
P = ParamSpec("P")
out_R = TypeVar("out_R", covariant=True)

class NoInstance(Generic[P, out_R]):

    def __init__(self, function: Callable[Concatenate[type[out_T], P], out_R]):
        ...

    @overload
    def __get__(self, instance: None, owner: type[object]) -> Callable[P, out_R]:
        ...
    @overload
    def __get__(self, instance: object, owner: type[object]) -> Never:
        ...
    
    def __get__(self, instance: object, owner: type[object]) -> object:
        ...     

class Foo:
    @NoInstance
    @classmethod
    def foo(cls):
        ...

Foo.foo() # allowed
Foo().foo() # not allowed

but the primary use case for class methods that should not be called on instances are constructor methods, which means the resulting signature only has the typevar on the return type (in this case, Self):

class Foo:
    @NoInstance
    @classmethod
    def from_int(cls) -> Self:
        ...

reveal_type(Foo.from_int) # `"def () -> Never"`, because the `Self` generic was removed by the `Concatenate`. should be `def () -> Foo` instead

Inizia eseguendo gli esempi minimi nel mypy playground collegato e confronta i tipi rivelati con le firme generiche previste. Traccia l'inferenza dei tipi e la gestione di Callable/Concatenate coinvolte in questi esempi; il lavoro è completo quando il T generico o Self viene preservato invece di essere ridotto a Never.