[ty] Infer single-valuedness for enums based on int/str

[sharkdp]

Summary

We previously didn't recognize Literal[Color.RED] as single-valued, if the enum also derived from str or int:

from enum import Enum

class Color(str, Enum):
    RED = "red"
    GREEN = "green"
    BLUE = "blue"

def _(color: Color):
    if color == Color.RED:
        reveal_type(color)  # previously: Color, now: Literal[Color.RED]

The reason for that was that int and str have "custom" __eq__ and __ne__ implementations that return bool. We do not treat enum literals from classes with custom __eq__ and __ne__ implementations as single-valued, but of course we know that int.__eq__ and str.__eq__ are well-behaved.

Test Plan

New Markdown tests.

[github-actions]

mypy_primer results

No ecosystem changes detected ✅
No memory usage changes detected ✅

[AlexWaygood]

I was also wondering if we could generalize this logic so that it applies to all instances of @final classes that do not override __eq__/__ne__ from object/int/str (not just instances of enum classes).

It's really the finality of enum classes that allows us to safely determine whether instances of enums are single-valued or not: because an enum class is final, we know that there are no possible subclasses of the enum class, therefore there are no possible subtypes of the enum type that could have badly behaved __eq__ or __ne__ methods. And that reasoning applies to any final class, not just enums