Typing conformance results

No changes detected ✅

Memory usage report

Memory usage unchanged ✅

ecosystem-analyzer results

No diagnostic changes detected ✅

Full report with detailed diff (timing results)

Merging this PR will improve performance by 13.78%

⚡ 2 improved benchmarks
✅ 69 untouched benchmarks
⏩ 64 skipped benchmarks¹

Performance Changes

_{Comparing charlie/avoid-redundant-equality-intersections (fdfd4d8) with main (870fc14)}

Just gonna merge this in as a fast-follow-up on the previous PR; it's a bit silly but seems not-useless.

It's nice that this is faster, but unfortunately I don't think this is correct. The premise seems to be that an intersection T & ~U, where U is a Literal type, can only be unsimplifiable if T is a dynamic type. But that doesn't hold true -- there are lots of T & ~U intersections where T is not a dynamic type yet the intersection cannot be simplified, e.g Sequence[str] & ~Literal[""], or T where T is some kind of protocol type, etc. etc.

Sequence[str] & ~Literal[""] takes a different path through equality.rs so isn't actually affected by the fast path you've introduced here, but codex was able to find the following regression as a result of this change:

from enum import Enum
from typing import Literal, TypeVar

from ty_extensions import Not


class Color(Enum):
    RED = 1
    BLUE = 2


T = TypeVar("T")


def accepts_not_red(value: Not[Literal[Color.RED]]) -> None:
    pass


def f(value: T | Literal[Color.RED]) -> None:
    if value == Color.RED:
        return
    accepts_not_red(value)

Prior to this PR, we accepted this code; now, on main, we reject it and report invalid-assignment on the last line because we incorrectly infer value as having type T after the return statement instead of T & ~Color.RED.

I think we should revert this change and add ^that as a regression test.