Files
Carl Meyer 20dd9f08ba [ty] Account for known subclasses in equality inference (#28005)
ty can infer `Literal[False]` for `Sequence[object] == ()`, even though
the sequence can be an empty tuple. This can also make reachable
branches disappear and hide errors.

Keep comparisons ambiguous when the operands' known classes have a
base/subclass relationship, even if their inherited equality
implementations differ. Apply the same reasoning to literals and
truthiness-narrowed intersections while retaining the default behavior
for unrelated classes.

Fixes astral-sh/ty#4377.

## Test plan

Added mdtests cover sequence comparisons with empty and nonempty tuples,
strings, bytes, and `LiteralString`; both operand orders and equality
operators; partial generic overlap; and custom base/tuple subclass
relationships. Narrowing regressions check branch reachability and
preserve tuple-comparison and membership precision for unrelated types.

The added Ibis diagnostics in the ecosystem are correct.
2026-08-24 16:10:09 -07:00

2.2 KiB

Comparison: Strings

String literals

def _(x: str):
    reveal_type("abc" == "abc")  # revealed: Literal[True]
    reveal_type("ab_cd" <= "ab_ce")  # revealed: Literal[True]
    reveal_type("abc" in "ab cd")  # revealed: Literal[False]
    reveal_type("" not in "hello")  # revealed: Literal[False]
    reveal_type("--" is "--")  # revealed: bool
    reveal_type("A" is "B")  # revealed: Literal[False]
    reveal_type("--" is not "--")  # revealed: bool
    reveal_type("A" is not "B")  # revealed: Literal[True]
    reveal_type(x < "...")  # revealed: bool

    # ensure we're not comparing the interned salsa symbols, which compare by order of declaration.
    reveal_type("ab" < "ab_cd")  # revealed: Literal[True]

Mismatched literal kinds

Exact built-in literals of different kinds compare unequal. A LiteralString can equal any particular string literal, so those comparisons remain ambiguous.

from typing_extensions import LiteralString

reveal_type(True == "")  # revealed: Literal[False]
reveal_type(True != "")  # revealed: Literal[True]
reveal_type(b"" == "")  # revealed: Literal[False]
reveal_type(b"" != "")  # revealed: Literal[True]

def _(value: LiteralString):
    reveal_type(value == 1)  # revealed: Literal[False]
    reveal_type(b"" != value)  # revealed: Literal[True]
    reveal_type(value == "")  # revealed: bool
    reveal_type(value != "")  # revealed: bool

Equality with sequences

A Sequence[str] can be a string, including the empty string, so comparing it with a string literal has an unknown result:

from collections.abc import Sequence

def _(value: Sequence[str]):
    reveal_type(value == "")  # revealed: bool
    reveal_type("" == value)  # revealed: bool
    reveal_type(value != "")  # revealed: bool
    reveal_type("" != value)  # revealed: bool

The result is also unknown when the string's precise literal value is not known:

from typing_extensions import LiteralString

def _(value: Sequence[str], other: LiteralString):
    reveal_type(value == other)  # revealed: bool
    reveal_type(other == value)  # revealed: bool
    reveal_type(value != other)  # revealed: bool
    reveal_type(other != value)  # revealed: bool