[phpstan-bot]

Summary

A match (true) whose arms are complementary comparisons, e.g. $bar !== $baz and then $bar === $baz, was reported as match.unhandled ("does not handle remaining value: true"). On the current branch this happened in both arm orders. After a falsey arm, the scope remembers that arm's comparison expression as false. Nothing connected that remembered value to the next arm's comparison: it is a different AST node (the complement, or the same comparison with its operands swapped). That comparison was priced from its int operands only, so it came out as bool.

The comparison type resolution now reads the equivalent and complementary forms the scope already tracks. The narrowing of a comparison also updates those forms.

Changes

• src/Analyser/ExprHandler/BinaryOpHandler.php
  • getEquivalentComparisonForms() lists the forms that always evaluate to the same value as the comparison, or always to the opposite value:
    • ===/!== and ==/!=: both operand orders, plus the complement.
    • <, <=, >, >=: the operand-swapped mirror ($a < $b ≡ $b > $a). The complement ($a >= $b) is included only when both operands are integers. NAN and uncomparable values are neither < nor >=, so the two are not complements in general.
  • resolveRememberedComparisonType(): the type callback returns true/false when one of these forms is tracked in the scope with a constant boolean value.
  • specifyRememberedComparisonForms(): the specify callback wraps the existing narrowing. When the comparison is narrowed to true or false, it also pins the forms the scope already tracks, so a form remembered as plain bool (from an earlier merged match) does not keep answering with a stale value.
• turbo-ext/src/BinaryOpHandler.cpp + turbo-ext/src/generated/BinaryOpHandler.h: native port of the three methods and of the wrapped specify callback.

Probed and already correct: arm pairs built from instanceof, is_*() and !$bool. Their negations read the narrowed operand, not a separate remembered expression.

Root cause

The scope keeps comparison verdicts keyed by the printed expression, so $a !== $b, $a === $b and $b === $a are unrelated keys. The BinaryOpHandler type callback priced each of them from the operand types alone and never consulted a remembered verdict stored under an equivalent or complementary key. The same pattern affected every equality and relational operator. All of them are now handled in the same place.

Test

• tests/PHPStan/Rules/Comparison/data/bug-10583.php (MatchExpressionRuleTest::testBug10583) covers:
  • the issue's two arm orders;
  • swapped operands, ==/!= with swapped operands, </<= and >/<= on int, and match (false);
  • a float </>= pair, which is still correctly reported as unhandled.
• tests/PHPStan/Analyser/nsrt/bug-10583.php asserts the inferred types of every form after a falsey arm. It includes the stale-bool scenario (two matches in a row) and checks that reassigning an operand invalidates the remembered verdict.
• Both tests fail without the change.
• The full suite passes with and without the turbo extension loaded.
• The turbo smoke test and signature parity pass.
• walk-trace.php is identical over its default corpus.

Fixes phpstan/phpstan#10583
Fixes phpstan/phpstan#5610

🤖 Generated with Claude Code

[VincentLanglet]

@staabm I recommend to remove the whitespace changes to review this PR.

[staabm]

lgtm

---

all the testing is concentrated on match(), but shouldn't this also work for regular if ? maybe a followup

https://phpstan.org/r/c448fd56-a92d-432b-bbc1-61cfe1ec9a94