`match-case` does not work correctly with Literals vs Enums

[randolf-scholz]

from enum import StrEnum
from typing import Literal, assert_never, reveal_type

class Color(StrEnum):
 RED = "r"
 GREEN = "g"
 BLUE = "b"

def test_literal_as_enum(x: Literal["g"] = "g") -> None:
 match x:
 case Color.RED:
 assert_never(x)
 case Color.GREEN:
 reveal_type(x)
 case Color.BLUE:
 assert_never(x)
 case _:
 assert_never(x)

def test_enum_as_litearl(y: Literal[Color.BLUE] = Color.BLUE) -> None:
 match y:
 case "r":
 assert_never(y)
 case "g":
 assert_never(y)
 case "b":
 reveal_type(y)
 case _:
 assert_never(y)

test_literal_as_enum() # selects green branch at runtim
test_enum_as_litearl() # selects blue branch at runtime

Expected no errors, but mypy-playground reports

main.py:14: error: Statement is unreachable [unreachable]
main.py:18: error: Argument 1 to "assert_never" has incompatible type "Literal['g']"; expected "Never" [arg-type]
main.py:27: error: Statement is unreachable [unreachable]
main.py:29: error: Argument 1 to "assert_never" has incompatible type "Literal[Color.BLUE]"; expected "Never" [arg-type]

Related: https://discuss.python.org/t/amend-pep-586-to-make-enum-values-subtypes-of-literal/59456
Also: #16327, #17162, #19616 (but none of these is specifically about match-case)

[sterliakov]

#19594 should (at least partially) address this issue: it will still report fallback assert_never as failing (and I'm not sure whether that's correct), but reveal_type will be reachable and reveal Literal[Color.Green] and Literal["b"], resp.

[randolf-scholz]

but reveal_type will be reachable and reveal Literal[Color.Green] and Literal["b"], resp.

Uhm, that is exactly the wrong way around. The literal and value patterns are equality based, so in the first case it should be Literal["g"] and in the latter it should be Literal[Color.BLUE]. Alex actually added some nice extra detail in his issue report in ty after I brought this problem up in discourse.

[sterliakov]

Ough, and you're right, otherwise

class Foo(StrEnum):
 A = 'a'
 
 def meth(self) -> None: ...


a: Literal['a'] = 'a'
match a:
 case Foo.A:
 a.meth()

will pass. Thanks!

The literal and value patterns are equality based

This is a nice observation. I wonder why visit_value_pattern uses conditional_types_with_intersection instead of the equality helper then...