false narrowing on Enum == when Enum has custom __eq__

[KotlinIsland]

from enum import Enum, auto
from typing import Literal


class MyEnum(Enum):
    A = auto()
    B = auto()

    def __eq__(self, other: object) -> bool:
        return True

def func(m: MyEnum) -> None:
    if m == MyEnum.A:
        a: Literal[MyEnum.A] = m  # m could be MyEnum.B here

Maybe don't narrow if the Enum has a custom __eq__ defined or inherited?

[DetachHead]

related: python/mypy#10915

[erictraut]

Static type checkers need to make certain assumptions, and a language as dynamic as Python will always provide ways to violate those assumptions. I think this falls into the category of "don't do this if you want static type checking to work".

[KotlinIsland]

I believe in typecheckers being as strict as possible, I would always prefer false positives over false negatives.

But you do you.

[erictraut]

It's not so simple in this case. This involves a heuristic ("narrowing is unsafe with there's a customer __eq__ method") that will produce correct results some of the time and incorrect results other times. When the heuristic turns out to be wrong and type narrowing isn't applied, false positives will likely be the result. Rather than add more complexity that's going to eliminate some false positives and create others, I'd rather avoid the complexity and additional layers of special casing.