Unable to narrow unions including EllipsisType or NoneType using the identity of their singleton

[tungol]

Bug Report

Variables whose type is a union that includes types.EllipsisType can't be narrowed using if foo is Ellipsis. That's unexpected to me, because Ellipsis is documented as the only instance of EllipsisType.

Similar but slightly different issues occur with NoneType and NotImplementedType.

To Reproduce

Minimal reproducing case:

from types import EllipsisType


def working(foo: EllipsisType | int) -> int:
    if isinstance(foo, EllipsisType):
        # Revealed type is "builtins.ellipsis"  (seems to understand the singleton relationship here)
        foo = 1
    reveal_type(foo)  # Revealed type is "builtins.int"
    return foo  # no error

def not_working(foo: EllipsisType | int) -> int:
    if foo is Ellipsis:
        reveal_type(foo)  # Revealed type is "Union[builtins.ellipsis, builtins.int]" (why is int still here?)
        foo = 1
    reveal_type(foo)  # Revealed type is "Union[builtins.ellipsis, builtins.int]"
    return foo  # error: Incompatible return value type (got "Union[ellipsis, int]", expected "int")

Mypy appears to believe that there might be values whose type is EllipsisType but which don't have the same identity as Ellipsis. I don't think that's possible.

Similar things happen with None and NoneType:

from types import NoneType


def working(foo: NoneType | int) -> int:
    if isinstance(foo, NoneType):
        reveal_type(foo)  # Revealed type is "types.NoneType"  (interesting difference from Ellipsis)
        foo = 1
    reveal_type(foo)  # Revealed type is "builtins.int"
    return foo  # no error


def not_working(foo: NoneType | int) -> int:
    if foo is None:
        reveal_type(foo)  # Doesn't show any output (?)
        foo = 1
    reveal_type(foo)  # Revealed type is "Union[types.NoneType, builtins.int]"
    return foo  # Incompatible return value type (got "Union[NoneType, int]", expected "int")

NotImplemented and NotImplementedType pass without error, but appear to do so for the wrong reasons:

from types import NotImplementedType


def working(foo: NotImplementedType | int) -> int:
    if isinstance(foo, NotImplementedType):
        reveal_type(foo)  # Revealed type is "builtins._NotImplementedType"
        foo = 1
    reveal_type(foo)  # Revealed type is "Union[builtins._NotImplementedType, builtins.int]"
    return foo  # no error ??


def also_working(foo: NotImplementedType | int) -> int:
    if foo is NotImplemented:
        reveal_type(foo)  # Revealed type is "Union[builtins._NotImplementedType, builtins.int]"
        foo = 1
    reveal_type(foo)  # Revealed type is "Union[builtins._NotImplementedType, builtins.int]"
    return foo  # no error ??

Your Environment

• Mypy version used: mypy 0.961 (compiled: yes)
• Mypy command-line flags: none
• Mypy configuration options from mypy.ini (and other config files): none
• Python version used: python Python 3.10.4
• Operating system and version: macOS 10.15.7

[tungol]

I tested with bool. It almost works correctly, but it's a little over-eager. Checking for either True or False will narrow out both boolean values:

def test_bool(foo: bool | int) -> int:
    if foo is True:
        reveal_type(foo)  # Revealed type is "Literal[True]"
        foo = 1

    reveal_type(foo)  # Revealed type is "builtins.int"
    return foo  # no error

[JelleZijlstra]

The bool | int case is probably because bool is a subclass of int, and sometimes mypy simplifies the union and throws away bool. If you type foo as bool | str instead, the types are as expected.

[tungol]

Ah, that makes sense. So the relevant parallel case for boolean literals is something like this:

def test_bool(foo: bool | str) -> str:
    if foo is True:
        reveal_type(foo)  # Revealed type is "Literal[True]"
        foo = "1"
    reveal_type(foo)  # Revealed type is "Union[Literal[False], builtins.str]"
    if foo is False:
        reveal_type(foo)  # Revealed type is "Literal[False]"
        foo = "1"
    reveal_type(foo)  # Revealed type is "builtins.str"
    return foo  # no error

which works like I'd expect it to.

[JukkaL]

NoneType should be rejected by mypy (#11288) so it doesn't need to be special cased. If using just None, things already work.

Summarizing the above discussion, these cases are relevant:

• EllipsisType / Ellipsis
• NotImplementedType / NotImplemented

I think that the implementation will have to touch find_isinstance_check_helper (or the functions that it calls) in mypy.checker.

[vlaci]

I think, the NotImplemented case works as intended: it is implemented similarly as Any, so it can be a substitute for all types.