[ty] Reachability and narrowing for enum methods

[sharkdp]

Summary

Adds proper type narrowing and reachability analysis for matching on non-inferable type variables bound to enums. For example:

from enum import Enum

class Answer(Enum):
    NO = 0
    YES = 1

    def is_yes(self) -> bool:  # no error here!
        match self:
            case Answer.YES:
                return True
            case Answer.NO:
                return False

closes astral-sh/ty#1404

Test Plan

Added regression tests

[github-actions]

Diagnostic diff on typing conformance tests

No changes detected when running ty on typing conformance tests ✅

[github-actions]

mypy_primer results

Changes were detected when running on open source projects

mitmproxy (https://github.com/mitmproxy/mitmproxy)
- mitmproxy/proxy/layers/http/_events.py:127:17: error[type-assertion-failure] Argument does not have asserted type `Never`
- Found 1890 diagnostics
+ Found 1889 diagnostics

jax (https://github.com/google/jax)
- jax/_src/pallas/mosaic_gpu/core.py:1527:24: error[invalid-return-type] Function can implicitly return `None`, which is not assignable to return type `TMEMLayout`
- Found 2545 diagnostics
+ Found 2544 diagnostics

No memory usage changes detected ✅

[github-actions]

ecosystem-analyzer results

Lint rule	Added	Removed	Changed
invalid-return-type	0	1	0
type-assertion-failure	0	1	0
Total	0	2	0

Full report with detailed diff (timing results)

[AlexWaygood]

This fixes the issue for methods on enums, but there appear to be lots of other cases where you can have a TypeVar bound to a union (or type equivalent to a union) where we also exhibit similar issues with reachability and narrowing. These are all on this branch:

from typing import assert_never, Literal

def f[T: bool](x: T) -> T:
    match x:
        case True:
            return x
        case False:
            return x
        case _:
            reveal_type(x) # T@f & ~Literal[True] & ~Literal[False]
            assert_never(x)  # false-positive error

def g[T: Literal["foo", "bar"]](x: T) -> T:
    match x:
        case "foo":
            return x
        case "bar":
            return x
        case _:
            reveal_type(x)  # T@g & ~Literal["foo"] & ~Literal["bar"]
            assert_never(x)  # false-positive error

def h[T: int | str](x: T) -> T:
    if isinstance(x, int):
        return x
    elif isinstance(x, str):
        return x
    else:
        reveal_type(x)  # T@h & ~int & ~str
        assert_never(x)  # false-positive error