Make closure signature and static variable inference cheaper, fix benchmark regressions

[ondrejmirtes]

Speeds up the two bleeding-edge features added in the last days, closureSignaturesFromUsages and staticVariablesFromUsages. On Slevomat they cost about +5% user CPU over the toggles being off.

Commits

• Collect the markers of an array literal or union once for all its items. ArrayHandler::collectAbsorbedItems() collected the markers of the whole array type once per closure-carrying item. A data provider with 2,000 $item(...) results in a nested literal became quadratic.
• Do not build the value type of an array sent to plain mixed. Returning a large constant array from an : array function built the union of all its values, only to observe nothing in observeSend() and let everything escape in observeClosureSend().
• Walk a by-ref closure's body once per state it is invoked from. Each invocation of a closure with followed use (&$x) walked its body again. A data provider calling $room(...) 362 times walked it 1,297 times.
  • The walks are kept in the walk's ExpressionResultStorage, keyed by the template argument frame, until-fixpoint, native types promoted, and the entered scope (equals()).
• Replay the last walk inferring static variables as the second pass. Pass 2 walked the statements after static $x again with the converged types, which the last convergence walk had just used. The Enum trait's static $cache methods did this for every enum.
  • The replay only happens when the body observed no template argument or closure signature (empty constraints) and no closure or class follows the first static statement.

All four are ported to turbo-ext.

Benchmark slowdowns since the phpbench baseline (2026-08-09)

The phpbench check compares against tests/bench/storage/baseline*.xml committed on 2026-08-09, 1,033 commits ago. It fails the same way on every recent PR. The two biggest regressions were bisected, with bin/phpstan analyse -l 8 <file> --debug per-file times:

• bug-12671 (0.88 s → 2.1 s): e606ca20e3 "Merge unions of constant arrays with many keys instead of degrading" removed the 62-key cap. Two fixes:
  • Skip keys-superset checks of arrays differing in constant scalar values. A pair differing in two single constant scalars (or in one, when the key counts differ) can't pass isKeysSupersetOf() in either direction. Previously this was 654K calls, none of which merged.
  • Intersect finite benevolent unions by identity too. A benevolent union of ~890 constant strings narrowed by a falsy check was distributed member by member.
• bug-15061 (0.84 s → 1.78 s): 77527df087 "Narrow falsey isset() on an optional constant-array offset". Fix:
  • Answer the isset() conjunction fold's left operand once per ask. 26 isset subjects re-folded the conjunction chain 700 times.

The benchmark is also back to PHP 8.5 only (Run the benchmark on PHP 8.5 only again, reverting the 7.4 leg of #6121). 7.4 and 8.5 run the same code paths again since NodeCallbackScope replaced the fibers.

Measurements

Bench files, analysis time only (hyperfine wall minus the same bootstrap in all legs), PHP mode:

file	2026-08-09 baseline commit	2.3.x	this PR
bug-12671	0.81 s	1.90 s	1.28 s
bug-15061	0.77 s	1.53 s	1.04 s
bug-14462, bug-7581, bug-10538, bug-14972-concat			unchanged (per-commit check, within noise)

The remaining difference to the baseline commit is general drift across many later commits, not one mechanism.

Slevomat, locally built phar + turbo, 6 interleaved ABBA pairs, user CPU vs. 2.3.x (dda82d9):

	user CPU	t	pairs faster
first two commits	−0.14%	−0.6	4/6
all four	−1.01%	−4.5	6/6
2.3.x with both toggles off	−5.35%	−19.9	6/6

Per file (turbo): LimitedCreditsCalculatorTest 4.05 s → 2.56 s. TravelCalendarOccupationCalculatorTest (repro, PHP mode): 4.7 s → 2.9 s.

The remaining overhead is mostly per-invocation re-typing of stored closures, multiplied by array_map per-element callback typing, plus the static-variable convergence walks themselves. Both are the features working as designed.

Verification

• Full suite green with PHP and with turbo loaded, re-run after the benchmark commits.
• turbo-ext/tests/walk-trace.php identical (647,845 lines).
• Smoke, side-by-side and signature-parity pass.
• Slevomat reports identical errors across all legs.

🤖 Generated with Claude Code

https://claude.ai/code/session_01Y5roddukgqaSAB2BT765UX