Are generics in self types always bound to the function?

[davidhalter]

In the mypy test suite there's this example that shows this issue:

class C(Generic[T]):
    @overload
    def __init__(self: C[T], item: T, use_tuple: Literal[False]) -> None: ...
    @overload
    def __init__(self: C[Tuple[T, ...]], item: T, use_tuple: Literal[True]) -> None: ...

reveal_type(C(0, use_tuple=False))  # N: Revealed type is "lib.C[builtins.int]"
reveal_type(C(0, use_tuple=True))  # N: Revealed type is "lib.C[builtins.tuple[builtins.int, ...]]"

It is a bit strange to me that in the case of use_tuple=True, we get a tuple, because the T of the class C is lib.C[builtins.tuple[builtins.int, ...]], while the T in the function __init__ is actually int. This feels very confusing as a user. Is this intentional or a Mypy bug? Because normally the class type variables are bound to the class and not the function. Is this also how pyright and pyre work? Clearly this example should work if it was a different type variable: def __init__(self: C[Tuple[U, ...]], item: U, use_tuple: Literal[True]) -> None: ....

The test is from mypy's testSelfTypeRestrictedMethodOverloadFallback in test-data/unit/check-selftype.test.

[hauntsaninja]

I agree that this mypy behaviour seems is fragile, if not outright buggy. It would certainly be clearer to use a different type variable if you wanted a different binding.

Pyright interprets this as doing something recursive, which looks more correct than what mypy does, but I'm not convinced pyright's behaviour is fully correct either.

Here is a program that crashes with a TypeError that neither type checker has any complaints about:

from __future__ import annotations
from typing import Generic, Literal, Tuple, TypeVar, overload, reveal_type
T = TypeVar("T")

class C(Generic[T]):
    @overload
    def __init__(self: C[T], item: T, use_tuple: Literal[False]) -> None: ...
    @overload
    def __init__(self: C[Tuple[T, ...]], item: T, use_tuple: Literal[True]) -> None: ...
    def __init__(self, item: T, use_tuple: bool) -> None:
        self.item = item

    def get(self) -> T:
        return self.item

reveal_type(C(0, use_tuple=False))
reveal_type(C(0, use_tuple=True))

reveal_type(C(0, use_tuple=True).get()[0])  # no complaint, but crashes with TypeError