mirror of
https://github.com/astral-sh/ruff.git
synced 2026-11-22 03:31:49 +08:00
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.
2.2 KiB
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