Skip constant-array guards when creating conditional expressions for subtype-absorbed targets

[phpstan-bot]

Summary

phpstan-src#5876 ("Keep subtype-absorbed variables as conditional-expression targets when merging branches") added a ~15% analysis-time regression on constant-array-heavy loop code — the bench tests/bench/data/bug-10538.php (nested foreach over a ~100-entry constant array of string array shapes).

Where the previous code dropped a subtype-absorbed variable entirely (unset($newVariableTypes[$exprString])), #5876 keeps it as a conditional-expression target so it can be re-narrowed when its guard is re-asserted. The regression comes from these extra targets being paired with constant-array guards during branch merging in loop convergence: those pairings never re-narrow anything, but the guard-selection machinery (two isSuperTypeOf() calls per pair, one of them added by phpstan-src#5848) still pays to compare the potentially huge constant arrays on every merge.

This change keeps the #5876 inference improvement but stops creating those useless-but-expensive conditional expressions.

Changes

• src/Analyser/MutatingScope.php, createConditionalExpressions(): when the current conditional-expression target is a subtype-absorbed variable (i.e. it is in $guardsToExclude, kept only for re-narrowing), skip guards whose type is a constant array ($guardHolder->getType()->isConstantArray()->yes()). This avoids both the ConditionalExpressionHolder creation and the expensive isSuperTypeOf() guard comparisons for those pairs.

Root cause

The subtype-absorbed target (e.g. $stateId = 9) was paired with every type guard, including guards whose type is a large nested constant array (e.g. the foreach value $changesets or self::CHANGESET[$stateCode]). A constant array is a unique literal value that is essentially never re-asserted as a condition, so the resulting conditional expression $stateId = 9 WHEN $changesets = array{…huge…} can never fire a re-narrowing. It is, however, disproportionately expensive:

• ConditionalExpressionHolder::getKey() serialises the guard type via describe(VerbosityLevel::precise()).
• The Keep subtype-absorbed variables as conditional-expression targets when merging branches #5876 guard loop runs two isSuperTypeOf() comparisons per (target, guard) pair, and phpstan-src#5848 added the reverse comparison — both over the huge constant arrays.
• The holders are then carried through every subsequent branch merge in loop convergence.

Restricting the skip to subtype-absorbed targets is deliberate: probing a broader skip (constant-array guards for all targets) recovers even more time but breaks a legitimate re-narrowing where a non-absorbed target relies on a constant-array guard (one NodeScopeResolverTest case fails). Subtype-absorbed targets are the ones newly kept by #5876, and for them the constant-array-guarded conditional expressions were verified to be dead (see Test).

Test

This is a performance fix with no behavior change; the regression is covered by the existing bench file tests/bench/data/bug-10538.php (bench.yml Test job).

• Local in-process bench (median of 7 steady-state iterations, same setup as RegressionBench): bug-10538.php went from ~3777 ms (before) to ~3373 ms (after), matching the ~3344 ms measured with phpstan-src#5876 reverted — i.e. the full Keep subtype-absorbed variables as conditional-expression targets when merging branches #5876 step is recovered.
• Confirmed no inference change: a subtype-absorbed target guarded by a constant-array equality (if ($arr === ['a' => 1]) { $value = 5; } if ($arr === ['a' => 1]) { … }) already inferred the widened int|string both before and after the change — the removed conditional expressions never re-narrowed.
• #5876's inference improvement is preserved: bug-7948.php (subtype absorption re-narrowed under a repeated is_array/boolean-flag guard) and bug-11281.php remain green.
• All 1671 NodeScopeResolverTest inference tests and the full tests/PHPStan/Analyser suite (2852 tests) pass unchanged; make phpstan is clean.

Fixes phpstan/phpstan#14921