`__new__()` on a `Generic` class doesn't work with `Self` as return type if the typevar is not specified, picking the first element of the typevar

Bug Report

In pandas-stubs, we want to be able to return Series[int], Series[str], etc., as well as just Series from a __new__() constructor. In the current released version, we had return types of Series[S1] and Series and everything worked fine. But pyright made a change and developers there (@erictraut) say that Self needs to be the return type. See discussion starting here: https://github.com/microsoft/pyright/issues/5178#issuecomment-1563478640

With that change, mypy has a strange behavior, where returning Self in an overload that doesn't specify the value of the Generic parameter picks the first value. in the list provided in the TypeVar declaration.

To Reproduce

from typing import Generic, Self, TypeVar, overload, cast

S = TypeVar("S", int, str, bytes)


class Foo(Generic[S]):
    @overload
    def __new__(cls, dtype: type[S]) -> Self:
        ...

    @overload
    def __new__(cls, dtype=None) -> Self:
        ...

    def __new__(cls, dtype: type[S] | None = None) -> Self:
        return cast(Self, object.__new__(cls))


f = Foo(None)
reveal_type(f)  # Mypy reveals: Foo[int]; should be Foo[Any]

f2 = Foo(str)
reveal_type(f2)

Expected Behavior

Output from pyright:

gennewself.py:20:13 - information: Type of "f" is "Foo[Unknown]"
gennewself.py:23:13 - information: Type of "f2" is "Foo[str]"

Actual Behavior

gennewself.py:20: note: Revealed type is "gennewself.Foo[builtins.int]"
gennewself.py:23: note: Revealed type is "gennewself.Foo[builtins.str]"

The issue here is that the type of f should be Foo[Any], not Foo[int] .

Your Environment

• Mypy version used: 1.3.0
• Mypy command-line flags: None
• Mypy configuration options from mypy.ini (and other config files): None
• Python version used: 3.11.31

Inizia eseguendo il reproducer fornito di Generic, overload e Self con mypy 1.3.0 e confronta i tipi rivelati con l'output di pyright. Traccia l'inferenza dei tipi per un parametro Generic non specificato negli overload di new; il lavoro è completo quando Foo(None) rivela Foo[Any], mentre Foo(str) rimane Foo[str], con copertura di regressione per entrambi i casi.