Incorrect type narrowing for literal patterns

[erictraut]

Summary

I just fixed a longstanding bug in pyright that ty appears to suffer from too. It's related to literal patterns in case statements. The runtime uses equality checks for literal pattern matching, but equality checks can succeed for non-overlapping types.

Consider the following:

def func(x: int):
    match x:
        case 1.0:
            reveal_type(x) # ty incorrectly reveals Never here
            print("This code is reachable")

func(1)

Version

No response

[ericmarkmartin]

I think we got this right in visibility constraints but not narrowing @carljm ---in the former we only do any narrowing if the subject type is single-valued but in the latter we always narrow to subject type.

For singly-valued subjects we can still do some narrowing...

def func(x: Literal["spam"]):
    match x:
        case 4:
            reveal_type(x)  # Never

but also if the subject is a union of singly-valued types

def func(x: Literal["ham", "spam"] | None):
    match x:
        case "ham":
            reveal_type(x)  # Literal["ham"]
        case "spam":
            reveal_type(x)  # Literal["spam"]
        case "eggs":
            reveal_type(x)  # Never

or even a singly-valued type union'd to something else

def func(x: Literal["ham", "spam"] | int):
    match x:
        case "ham":
            reveal_type(x)  # Literal["ham"] | int
        case "spam":
            reveal_type(x)  # Literal["spam"] | int
        case "eggs":
            reveal_type(x)  # int

Are there other cases you can do this?

Edit: We have this logic already implemented in evaluate_expr_eq

[ericmarkmartin]

@erictraut I tried to test these examples in the pyright playground but I think it hasn't picked up the fix you mentioned. Do you know if pyright does the above narrowing?