From b82594723c7f2e63635f1a490b5c3a61b6e7ca2f Mon Sep 17 00:00:00 2001
From: Ondrej Mirtes <ondrej@mirtes.cz>
Date: Mon, 28 Sep 2026 10:39:26 +0200
Subject: [PATCH 1/9] Collect the markers of an array literal or union once for
 all its items

collectAbsorbed() collected the markers of the whole result for every
input carrying any, so an array literal whose items are results of
stored closures (a data provider calling `$item(...)` two thousand times)
traversed the whole array type once per item, at every nesting level.
collectAbsorbedInto() collects the result's markers once for all inputs
of a literal or of a ternary/match/`??` union.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y5roddukgqaSAB2BT765UX
---
 src/Analyser/ExprHandler/ArrayHandler.php     |   5 +-
 .../Generics/ClosureSignatureInference.php    |  46 ++--
 turbo-ext/src/ArrayHandler.cpp                |  10 +-
 turbo-ext/src/ClosureSignatureInference.cpp   |  54 +++--
 .../src/generated/ClosureSignatureInference.h | 216 +++++++++---------
 turbo-ext/src/support.h                       |   1 +
 6 files changed, 185 insertions(+), 147 deletions(-)

diff --git a/src/Analyser/ExprHandler/ArrayHandler.php b/src/Analyser/ExprHandler/ArrayHandler.php
index 9e3b11c2d3a..de7b6c6ea89 100644
--- a/src/Analyser/ExprHandler/ArrayHandler.php
+++ b/src/Analyser/ExprHandler/ArrayHandler.php
@@ -225,11 +225,8 @@ private function collectAbsorbedItems(Array_ $expr, array $itemResults, Mutating
 		}
 
 		$arrayType = $this->initializerExprTypeResolver->getArrayType($expr, static fn (Expr $inner): Type => $itemResults[spl_object_id($inner)]->getType());
-		foreach ($itemTypes as $itemType) {
-			$scope = $scope->addTemplateArgumentConstraints(ClosureSignatureInference::collectAbsorbed($itemType, $arrayType));
-		}
 
-		return $scope;
+		return $scope->addTemplateArgumentConstraints(ClosureSignatureInference::collectAbsorbedInto($itemTypes, $arrayType));
 	}
 
 	private function getExpectedArrayType(?Type $type): ?Type
diff --git a/src/Analyser/Generics/ClosureSignatureInference.php b/src/Analyser/Generics/ClosureSignatureInference.php
index d715734b5e2..c2062519c1c 100644
--- a/src/Analyser/Generics/ClosureSignatureInference.php
+++ b/src/Analyser/Generics/ClosureSignatureInference.php
@@ -289,21 +289,38 @@ public static function collectInvokedCallee(Type $calleeType): TemplateArgumentC
 	 * they escape.
 	 */
 	public static function collectAbsorbed(Type $input, Type $result): TemplateArgumentConstraints
+	{
+		return self::collectAbsorbedInto([$input], $result);
+	}
+
+	/**
+	 * The values of $inputs merged into $result - the items of an array
+	 * literal, the members of a union. See collectAbsorbed(). The markers
+	 * $result kept are collected once for all of them: a large literal of
+	 * closure-carrying items would otherwise traverse the whole array type
+	 * once per item.
+	 *
+	 * @param list<Type> $inputs
+	 */
+	public static function collectAbsorbedInto(array $inputs, Type $result): TemplateArgumentConstraints
 	{
 		$constraints = TemplateArgumentConstraints::createEmpty();
-		if ($input === $result) {
-			return $constraints;
-		}
-		$markers = self::collectMarkers($input);
-		if ($markers === []) {
-			return $constraints;
-		}
-		$kept = self::collectMarkers($result);
-		foreach ($markers as $key => $marker) {
-			if (isset($kept[$key])) {
+		$kept = null;
+		foreach ($inputs as $input) {
+			if ($input === $result) {
 				continue;
 			}
-			$constraints = $constraints->withUnconstrainingSend($marker);
+			$markers = self::collectMarkers($input);
+			if ($markers === []) {
+				continue;
+			}
+			$kept ??= self::collectMarkers($result);
+			foreach ($markers as $key => $marker) {
+				if (isset($kept[$key])) {
+					continue;
+				}
+				$constraints = $constraints->withUnconstrainingSend($marker);
+			}
 		}
 
 		return $constraints;
@@ -330,12 +347,7 @@ public static function collectAbsorbedInUnion(array $types): TemplateArgumentCon
 			return $constraints;
 		}
 
-		$union = TypeCombinator::union(...$types);
-		foreach ($types as $type) {
-			$constraints = $constraints->merge(self::collectAbsorbed($type, $union));
-		}
-
-		return $constraints;
+		return self::collectAbsorbedInto($types, TypeCombinator::union(...$types));
 	}
 
 	/** Whether $type carries a closure written where nothing types it. */
diff --git a/turbo-ext/src/ArrayHandler.cpp b/turbo-ext/src/ArrayHandler.cpp
index 4e999d6d1cc..ef35055b328 100644
--- a/turbo-ext/src/ArrayHandler.cpp
+++ b/turbo-ext/src/ArrayHandler.cpp
@@ -412,13 +412,9 @@ class ArrayHandler
 			if (UNEXPECTED(arrayType.isUndef())) return zv::Val();
 		}
 		zv::Val itemTypesHold(std::move(itemTypes));
-		for (zv::ArrayEntry entry : zv::ArrRef(itemTypesHold.raw())) {
-			zv::Val absorbed = pt_closure_signature_inference_collect_absorbed(entry.value().deref().raw(), arrayType.raw());
-			if (UNEXPECTED(absorbed.isUndef())) return zv::Val();
-			scope = pt_mutating_scope_add_template_argument_constraints(Z_OBJ_P(scope.raw()), absorbed.raw());
-			if (UNEXPECTED(scope.isUndef())) return zv::Val();
-		}
-		return scope;
+		zv::Val absorbed = pt_closure_signature_inference_collect_absorbed_into(itemTypesHold.raw(), arrayType.raw());
+		if (UNEXPECTED(absorbed.isUndef())) return zv::Val();
+		return pt_mutating_scope_add_template_argument_constraints(Z_OBJ_P(scope.raw()), absorbed.raw());
 	}
 
 	/* the handler entry (Engine.h) */
diff --git a/turbo-ext/src/ClosureSignatureInference.cpp b/turbo-ext/src/ClosureSignatureInference.cpp
index 4dbe668636e..ac4334ac077 100644
--- a/turbo-ext/src/ClosureSignatureInference.cpp
+++ b/turbo-ext/src/ClosureSignatureInference.cpp
@@ -1167,16 +1167,34 @@ class ClosureSignatureInference
 
 	/* Mirrors collectAbsorbed() */
 	static zv::Val collectAbsorbed(zval *input, zval *result)
+	{
+		zv::Arr inputs = zv::Arr::create(1);
+		inputs.push(zv::Val::copyOf(zv::Ref(input)));
+		zv::Val inputsHold(std::move(inputs));
+		return collectAbsorbedInto(inputsHold.raw(), result);
+	}
+
+	/* Mirrors collectAbsorbedInto(): the markers $result kept are collected
+	 * once, on the first input carrying any */
+	static zv::Val collectAbsorbedInto(zval *inputs, zval *result)
 	{
 		zv::Val constraints = pt_template_argument_constraints_create_empty();
 		if (UNEXPECTED(constraints.isUndef())) return zv::Val();
-		if (Z_TYPE_P(input) == IS_OBJECT && Z_TYPE_P(result) == IS_OBJECT && Z_OBJ_P(input) == Z_OBJ_P(result)) return constraints;
-		zv::Val markers = collectMarkers(input);
-		if (UNEXPECTED(markers.isUndef())) return zv::Val();
-		if (zend_hash_num_elements(Z_ARRVAL_P(markers.raw())) == 0) return constraints;
-		zv::Val kept = collectMarkers(result);
-		if (UNEXPECTED(kept.isUndef())) return zv::Val();
-		return unconstrainMarkers(std::move(constraints), markers.raw(), kept.raw());
+		zv::Val kept;
+		for (auto entry : zv::ArrRef(inputs)) {
+			zval *input = entry.value().deref().raw();
+			if (Z_TYPE_P(input) == IS_OBJECT && Z_TYPE_P(result) == IS_OBJECT && Z_OBJ_P(input) == Z_OBJ_P(result)) continue;
+			zv::Val markers = collectMarkers(input);
+			if (UNEXPECTED(markers.isUndef())) return zv::Val();
+			if (zend_hash_num_elements(Z_ARRVAL_P(markers.raw())) == 0) continue;
+			if (kept.isUndef()) {
+				kept = collectMarkers(result);
+				if (UNEXPECTED(kept.isUndef())) return zv::Val();
+			}
+			constraints = unconstrainMarkers(std::move(constraints), markers.raw(), kept.raw());
+			if (UNEXPECTED(constraints.isUndef())) return zv::Val();
+		}
+		return constraints;
 	}
 
 	/* Mirrors hasMarkers() */
@@ -1212,13 +1230,7 @@ class ClosureSignatureInference
 		zv::Val unionType = pt_type_combinator_union(count, argv);
 		efree(argv);
 		if (UNEXPECTED(unionType.isUndef())) return zv::Val();
-		for (auto entry : zv::ArrRef(types)) {
-			zv::Val absorbed = collectAbsorbed(entry.value().deref().raw(), unionType.raw());
-			if (UNEXPECTED(absorbed.isUndef())) return zv::Val();
-			constraints = pt_template_argument_constraints_merge(constraints.raw(), absorbed.raw());
-			if (UNEXPECTED(constraints.isUndef())) return zv::Val();
-		}
-		return constraints;
+		return collectAbsorbedInto(types, unionType.raw());
 	}
 
 	/* Mirrors collectInvocation() */
@@ -1847,6 +1859,11 @@ zv::Val pt_closure_signature_inference_collect_absorbed(zval *input, zval *resul
 	return ClosureSignatureInference::collectAbsorbed(input, result);
 }
 
+zv::Val pt_closure_signature_inference_collect_absorbed_into(zval *inputs, zval *result)
+{
+	return ClosureSignatureInference::collectAbsorbedInto(inputs, result);
+}
+
 zv::Val pt_closure_signature_inference_collect_absorbed_in_union(zval *types)
 {
 	return ClosureSignatureInference::collectAbsorbedInUnion(types);
@@ -2007,6 +2024,15 @@ PT_MINIT_REGISTRATION(pt_register_closure_signature_inference)
 		PT_RETURN_VAL(ClosureSignatureInference::collectAbsorbed(input, result));
 	});
 
+	cls.method(sigs::collectAbsorbedInto, [](INTERNAL_FUNCTION_PARAMETERS) {
+		zval *inputs, *result;
+		ZEND_PARSE_PARAMETERS_START(2, 2)
+			Z_PARAM_ARRAY(inputs)
+			Z_PARAM_OBJECT(result)
+		ZEND_PARSE_PARAMETERS_END();
+		PT_RETURN_VAL(ClosureSignatureInference::collectAbsorbedInto(inputs, result));
+	});
+
 	cls.method(sigs::collectAbsorbedInUnion, [](INTERNAL_FUNCTION_PARAMETERS) {
 		zval *types;
 		ZEND_PARSE_PARAMETERS_START(1, 1)
diff --git a/turbo-ext/src/generated/ClosureSignatureInference.h b/turbo-ext/src/generated/ClosureSignatureInference.h
index 9d988e3a13f..b3eefcb2851 100644
--- a/turbo-ext/src/generated/ClosureSignatureInference.h
+++ b/turbo-ext/src/generated/ClosureSignatureInference.h
@@ -57,54 +57,56 @@ inline constexpr char strings[] =
 	"input\0" /* 533 */
 	"result\0" /* 539 */
 	"collectAbsorbed\0" /* 546 */
-	"types\0" /* 562 */
-	"collectAbsorbedInUnion\0" /* 568 */
-	"hasMarkers\0" /* 591 */
-	"collectMarkers\0" /* 602 */
-	"call\0" /* 617 */
-	"PhpParser\\Node\\Expr\0" /* 622 */
-	"closureType\0" /* 642 */
-	"PHPStan\\Type\\ClosureType\0" /* 654 */
-	"observing\0" /* 679 */
-	"collectInvocation\0" /* 689 */
-	"collectByRefEntryTypes\0" /* 707 */
-	"PhpParser\\Node\\Expr\\ArrowFunction\0" /* 730 */
-	"getArrowFunctionOuterVariables\0" /* 764 */
-	"byRefUseNames\0" /* 795 */
-	"stmts\0" /* 809 */
-	"names\0" /* 815 */
-	"bodyYieldsOrInvokes\0" /* 821 */
-	"body\0" /* 841 */
-	"PhpParser\\Node\0" /* 846 */
-	"getReboundVariableNames\0" /* 861 */
-	"node\0" /* 885 */
-	"collectVariableName\0" /* 890 */
-	"target\0" /* 910 */
-	"collectByRefItemNames\0" /* 917 */
-	"parameterName\0" /* 939 */
-	"parameterTemplateName\0" /* 953 */
-	"PHPStan\\Analyser\\Generics\\TemplateArgumentFrame\0" /* 975 */
-	"getFrame\0" /* 1023 */
-	"isObserving\0" /* 1032 */
-	"declaredParameters\0" /* 1044 */
-	"getSignatureParameters\0" /* 1063 */
-	"getBodyParameters\0" /* 1086 */
-	"returnType\0" /* 1104 */
-	"getSignatureReturnType\0" /* 1115 */
-	"getExpectedReturnType\0" /* 1138 */
-	"collectSites\0" /* 1160 */
-	"parameter\0" /* 1173 */
-	"PHPStan\\Reflection\\Native\\NativeParameterReflection\0" /* 1183 */
-	"createParameterMarker\0" /* 1235 */
-	"returnsContextTypedExpression\0" /* 1257 */
-	"functionLike\0" /* 1287 */
-	"isClosedBody\0" /* 1300 */
-	"scanClosedBody\0" /* 1313 */
-	"infersInvocationReturnType\0" /* 1328 */
-	"findAssignedClosures\0" /* 1355 */
-	"getAssignedClosures\0" /* 1376 */
-	"collectTargetNames\0" /* 1396 */
-	"isContextTyped"; /* 1415 */
+	"inputs\0" /* 562 */
+	"collectAbsorbedInto\0" /* 569 */
+	"types\0" /* 589 */
+	"collectAbsorbedInUnion\0" /* 595 */
+	"hasMarkers\0" /* 618 */
+	"collectMarkers\0" /* 629 */
+	"call\0" /* 644 */
+	"PhpParser\\Node\\Expr\0" /* 649 */
+	"closureType\0" /* 669 */
+	"PHPStan\\Type\\ClosureType\0" /* 681 */
+	"observing\0" /* 706 */
+	"collectInvocation\0" /* 716 */
+	"collectByRefEntryTypes\0" /* 734 */
+	"PhpParser\\Node\\Expr\\ArrowFunction\0" /* 757 */
+	"getArrowFunctionOuterVariables\0" /* 791 */
+	"byRefUseNames\0" /* 822 */
+	"stmts\0" /* 836 */
+	"names\0" /* 842 */
+	"bodyYieldsOrInvokes\0" /* 848 */
+	"body\0" /* 868 */
+	"PhpParser\\Node\0" /* 873 */
+	"getReboundVariableNames\0" /* 888 */
+	"node\0" /* 912 */
+	"collectVariableName\0" /* 917 */
+	"target\0" /* 937 */
+	"collectByRefItemNames\0" /* 944 */
+	"parameterName\0" /* 966 */
+	"parameterTemplateName\0" /* 980 */
+	"PHPStan\\Analyser\\Generics\\TemplateArgumentFrame\0" /* 1002 */
+	"getFrame\0" /* 1050 */
+	"isObserving\0" /* 1059 */
+	"declaredParameters\0" /* 1071 */
+	"getSignatureParameters\0" /* 1090 */
+	"getBodyParameters\0" /* 1113 */
+	"returnType\0" /* 1131 */
+	"getSignatureReturnType\0" /* 1142 */
+	"getExpectedReturnType\0" /* 1165 */
+	"collectSites\0" /* 1187 */
+	"parameter\0" /* 1200 */
+	"PHPStan\\Reflection\\Native\\NativeParameterReflection\0" /* 1210 */
+	"createParameterMarker\0" /* 1262 */
+	"returnsContextTypedExpression\0" /* 1284 */
+	"functionLike\0" /* 1314 */
+	"isClosedBody\0" /* 1327 */
+	"scanClosedBody\0" /* 1340 */
+	"infersInvocationReturnType\0" /* 1355 */
+	"findAssignedClosures\0" /* 1382 */
+	"getAssignedClosures\0" /* 1403 */
+	"collectTargetNames\0" /* 1423 */
+	"isContextTyped"; /* 1442 */
 inline constexpr reg::PackedArg args[] = {
 	reg::packed(0, MAY_BE_BOOL), /* __construct $enabled */
 	reg::packed(20, 0, 27), /* isClosureSignatureMarker $marker */
@@ -136,82 +138,85 @@ inline constexpr reg::PackedArg args[] = {
 	reg::packed(533, 0, 307), /* collectAbsorbed $input */
 	reg::packed(539, 0, 307), /* collectAbsorbed $result */
 	reg::packed(79, 0, 410), /* collectAbsorbed return */
-	reg::packed(562, MAY_BE_ARRAY), /* collectAbsorbedInUnion $types */
+	reg::packed(562, MAY_BE_ARRAY), /* collectAbsorbedInto $inputs */
+	reg::packed(539, 0, 307), /* collectAbsorbedInto $result */
+	reg::packed(79, 0, 410), /* collectAbsorbedInto return */
+	reg::packed(589, MAY_BE_ARRAY), /* collectAbsorbedInUnion $types */
 	reg::packed(79, 0, 410), /* collectAbsorbedInUnion return */
 	reg::packed(405, 0, 307), /* hasMarkers $type */
 	reg::packed(79, MAY_BE_BOOL), /* hasMarkers return */
 	reg::packed(405, 0, 307), /* collectMarkers $type */
 	reg::packed(79, MAY_BE_ARRAY), /* collectMarkers return */
 	reg::packed(134, 0, 140), /* collectInvocation $scope */
-	reg::packed(617, 0, 622), /* collectInvocation $call */
-	reg::packed(642, 0, 654), /* collectInvocation $closureType */
-	reg::packed(679, MAY_BE_BOOL), /* collectInvocation $observing */
+	reg::packed(644, 0, 649), /* collectInvocation $call */
+	reg::packed(669, 0, 681), /* collectInvocation $closureType */
+	reg::packed(706, MAY_BE_BOOL), /* collectInvocation $observing */
 	reg::packed(79, 0, 410), /* collectInvocation return */
 	reg::packed(134, 0, 140), /* collectByRefEntryTypes $scope */
 	reg::packed(79, MAY_BE_ARRAY), /* collectByRefEntryTypes return */
-	reg::packed(171, 0, 730), /* getArrowFunctionOuterVariables $expr */
+	reg::packed(171, 0, 757), /* getArrowFunctionOuterVariables $expr */
 	reg::packed(79, MAY_BE_ARRAY), /* getArrowFunctionOuterVariables return */
 	reg::packed(171, 0, 257), /* byRefUseNames $expr */
 	reg::packed(79, MAY_BE_ARRAY), /* byRefUseNames return */
-	reg::packed(809, MAY_BE_ARRAY), /* bodyYieldsOrInvokes $stmts */
-	reg::packed(815, MAY_BE_ARRAY), /* bodyYieldsOrInvokes $names */
+	reg::packed(836, MAY_BE_ARRAY), /* bodyYieldsOrInvokes $stmts */
+	reg::packed(842, MAY_BE_ARRAY), /* bodyYieldsOrInvokes $names */
 	reg::packed(79, MAY_BE_BOOL), /* bodyYieldsOrInvokes return */
-	reg::packed(841, 0, 846), /* getReboundVariableNames $body */
-	reg::packed(809, MAY_BE_ARRAY), /* getReboundVariableNames $stmts */
+	reg::packed(868, 0, 873), /* getReboundVariableNames $body */
+	reg::packed(836, MAY_BE_ARRAY), /* getReboundVariableNames $stmts */
 	reg::packed(79, MAY_BE_ARRAY), /* getReboundVariableNames return */
-	reg::packed(885, 0, 846), /* collectVariableName $node */
-	reg::packed(815, MAY_BE_ARRAY, reg::NoString, true, false), /* collectVariableName $names */
+	reg::packed(912, 0, 873), /* collectVariableName $node */
+	reg::packed(842, MAY_BE_ARRAY, reg::NoString, true, false), /* collectVariableName $names */
 	reg::packed(79, MAY_BE_VOID), /* collectVariableName return */
-	reg::packed(910, 0, 622), /* collectByRefItemNames $target */
-	reg::packed(815, MAY_BE_ARRAY, reg::NoString, true, false), /* collectByRefItemNames $names */
+	reg::packed(937, 0, 649), /* collectByRefItemNames $target */
+	reg::packed(842, MAY_BE_ARRAY, reg::NoString, true, false), /* collectByRefItemNames $names */
 	reg::packed(79, MAY_BE_VOID), /* collectByRefItemNames return */
-	reg::packed(939, MAY_BE_STRING), /* parameterTemplateName $parameterName */
+	reg::packed(966, MAY_BE_STRING), /* parameterTemplateName $parameterName */
 	reg::packed(79, MAY_BE_STRING), /* parameterTemplateName return */
 	reg::packed(134, 0, 140), /* getFrame $scope */
-	reg::packed(79, MAY_BE_NULL, 975), /* getFrame return */
+	reg::packed(79, MAY_BE_NULL, 1002), /* getFrame return */
 	reg::packed(134, 0, 140), /* isObserving $scope */
 	reg::packed(79, MAY_BE_BOOL), /* isObserving return */
 	reg::packed(134, 0, 140), /* getSignatureParameters $scope */
 	reg::packed(171, 0, 176), /* getSignatureParameters $expr */
-	reg::packed(1044, MAY_BE_ARRAY), /* getSignatureParameters $declaredParameters */
+	reg::packed(1071, MAY_BE_ARRAY), /* getSignatureParameters $declaredParameters */
 	reg::packed(79, MAY_BE_ARRAY), /* getSignatureParameters return */
 	reg::packed(134, 0, 140), /* getBodyParameters $scope */
 	reg::packed(171, 0, 176), /* getBodyParameters $expr */
 	reg::packed(79, MAY_BE_NULL | MAY_BE_ARRAY), /* getBodyParameters return */
 	reg::packed(134, 0, 140), /* getSignatureReturnType $scope */
 	reg::packed(171, 0, 176), /* getSignatureReturnType $expr */
-	reg::packed(1104, 0, 307), /* getSignatureReturnType $returnType */
+	reg::packed(1131, 0, 307), /* getSignatureReturnType $returnType */
 	reg::packed(79, 0, 307), /* getSignatureReturnType return */
 	reg::packed(134, 0, 140), /* getExpectedReturnType $scope */
 	reg::packed(171, 0, 176), /* getExpectedReturnType $expr */
 	reg::packed(79, MAY_BE_NULL, 307), /* getExpectedReturnType return */
 	reg::packed(134, 0, 140), /* collectSites $scope */
-	reg::packed(642, 0, 307), /* collectSites $closureType */
+	reg::packed(669, 0, 307), /* collectSites $closureType */
 	reg::packed(79, 0, 410), /* collectSites return */
 	reg::packed(171, 0, 176), /* createParameterMarker $expr */
-	reg::packed(1173, 0, 1183), /* createParameterMarker $parameter */
+	reg::packed(1200, 0, 1210), /* createParameterMarker $parameter */
 	reg::packed(79, 0, 27), /* createParameterMarker return */
 	reg::packed(171, 0, 176), /* returnsContextTypedExpression $expr */
 	reg::packed(79, MAY_BE_BOOL), /* returnsContextTypedExpression return */
-	reg::packed(1287, 0, 846), /* isClosedBody $functionLike */
-	reg::packed(809, MAY_BE_ARRAY), /* isClosedBody $stmts */
+	reg::packed(1314, 0, 873), /* isClosedBody $functionLike */
+	reg::packed(836, MAY_BE_ARRAY), /* isClosedBody $stmts */
 	reg::packed(79, MAY_BE_BOOL), /* isClosedBody return */
-	reg::packed(1287, 0, 846), /* scanClosedBody $functionLike */
-	reg::packed(809, MAY_BE_ARRAY), /* scanClosedBody $stmts */
+	reg::packed(1314, 0, 873), /* scanClosedBody $functionLike */
+	reg::packed(836, MAY_BE_ARRAY), /* scanClosedBody $stmts */
 	reg::packed(79, MAY_BE_BOOL), /* scanClosedBody return */
 	reg::packed(134, 0, 140), /* infersInvocationReturnType $scope */
-	reg::packed(642, 0, 654), /* infersInvocationReturnType $closureType */
+	reg::packed(669, 0, 681), /* infersInvocationReturnType $closureType */
 	reg::packed(79, MAY_BE_BOOL), /* infersInvocationReturnType return */
 	reg::packed(134, 0, 140), /* findAssignedClosures $scope */
 	reg::packed(302, MAY_BE_STRING), /* findAssignedClosures $name */
 	reg::packed(79, MAY_BE_ARRAY), /* findAssignedClosures return */
-	reg::packed(841, 0, 846), /* getAssignedClosures $body */
-	reg::packed(809, MAY_BE_ARRAY), /* getAssignedClosures $stmts */
+	reg::packed(868, 0, 873), /* getAssignedClosures $body */
+	reg::packed(836, MAY_BE_ARRAY), /* getAssignedClosures $stmts */
 	reg::packed(79, MAY_BE_ARRAY), /* getAssignedClosures return */
-	reg::packed(910, 0, 622), /* collectTargetNames $target */
-	reg::packed(815, MAY_BE_ARRAY, reg::NoString, true, false), /* collectTargetNames $names */
+	reg::packed(937, 0, 649), /* collectTargetNames $target */
+	reg::packed(842, MAY_BE_ARRAY, reg::NoString, true, false), /* collectTargetNames $names */
 	reg::packed(79, MAY_BE_VOID), /* collectTargetNames return */
-	reg::packed(171, 0, 622), /* isContextTyped $expr */
+	reg::packed(171, 0, 649), /* isContextTyped $expr */
 	reg::packed(79, MAY_BE_BOOL), /* isContextTyped return */
 };
 using Sig = reg::Sig<strings, args>;
@@ -231,34 +236,35 @@ inline constexpr sigtab::Sig collectCaptureEscapes = { { 464 /* collectCaptureEs
 inline constexpr sigtab::Sig collectEscapes = { { 486 /* collectEscapes */, 1, 23, 1, 24, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } };
 inline constexpr sigtab::Sig collectInvokedCallee = { { 512 /* collectInvokedCallee */, 1, 25, 1, 26, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } };
 inline constexpr sigtab::Sig collectAbsorbed = { { 546 /* collectAbsorbed */, 2, 27, 2, 29, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig collectAbsorbedInUnion = { { 568 /* collectAbsorbedInUnion */, 1, 30, 1, 31, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig hasMarkers = { { 591 /* hasMarkers */, 1, 32, 1, 33, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig collectMarkers = { { 602 /* collectMarkers */, 1, 34, 1, 35, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig collectInvocation = { { 689 /* collectInvocation */, 4, 36, 4, 40, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig collectByRefEntryTypes = { { 707 /* collectByRefEntryTypes */, 1, 41, 1, 42, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig getArrowFunctionOuterVariables = { { 764 /* getArrowFunctionOuterVariables */, 1, 43, 1, 44, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig byRefUseNames = { { 795 /* byRefUseNames */, 1, 45, 1, 46, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig bodyYieldsOrInvokes = { { 821 /* bodyYieldsOrInvokes */, 2, 47, 2, 49, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig getReboundVariableNames = { { 861 /* getReboundVariableNames */, 2, 50, 2, 52, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig collectVariableName = { { 890 /* collectVariableName */, 2, 53, 2, 55, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig collectByRefItemNames = { { 917 /* collectByRefItemNames */, 2, 56, 2, 58, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig parameterTemplateName = { { 953 /* parameterTemplateName */, 1, 59, 1, 60, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig getFrame = { { 1023 /* getFrame */, 1, 61, 1, 62, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig isObserving = { { 1032 /* isObserving */, 1, 63, 1, 64, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getSignatureParameters = { { 1063 /* getSignatureParameters */, 3, 65, 3, 68, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getBodyParameters = { { 1086 /* getBodyParameters */, 2, 69, 2, 71, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getSignatureReturnType = { { 1115 /* getSignatureReturnType */, 3, 72, 3, 75, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getExpectedReturnType = { { 1138 /* getExpectedReturnType */, 2, 76, 2, 78, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig collectSites = { { 1160 /* collectSites */, 2, 79, 2, 81, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig createParameterMarker = { { 1235 /* createParameterMarker */, 2, 82, 2, 84, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig returnsContextTypedExpression = { { 1257 /* returnsContextTypedExpression */, 1, 85, 1, 86, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig isClosedBody = { { 1300 /* isClosedBody */, 2, 87, 2, 89, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig scanClosedBody = { { 1313 /* scanClosedBody */, 2, 90, 2, 92, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig infersInvocationReturnType = { { 1328 /* infersInvocationReturnType */, 2, 93, 2, 95, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig findAssignedClosures = { { 1355 /* findAssignedClosures */, 2, 96, 2, 98, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getAssignedClosures = { { 1376 /* getAssignedClosures */, 2, 99, 2, 101, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig collectTargetNames = { { 1396 /* collectTargetNames */, 2, 102, 2, 104, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig isContextTyped = { { 1415 /* isContextTyped */, 1, 105, 1, 106, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig collectAbsorbedInto = { { 569 /* collectAbsorbedInto */, 2, 30, 2, 32, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig collectAbsorbedInUnion = { { 595 /* collectAbsorbedInUnion */, 1, 33, 1, 34, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig hasMarkers = { { 618 /* hasMarkers */, 1, 35, 1, 36, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig collectMarkers = { { 629 /* collectMarkers */, 1, 37, 1, 38, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig collectInvocation = { { 716 /* collectInvocation */, 4, 39, 4, 43, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig collectByRefEntryTypes = { { 734 /* collectByRefEntryTypes */, 1, 44, 1, 45, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig getArrowFunctionOuterVariables = { { 791 /* getArrowFunctionOuterVariables */, 1, 46, 1, 47, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig byRefUseNames = { { 822 /* byRefUseNames */, 1, 48, 1, 49, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig bodyYieldsOrInvokes = { { 848 /* bodyYieldsOrInvokes */, 2, 50, 2, 52, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig getReboundVariableNames = { { 888 /* getReboundVariableNames */, 2, 53, 2, 55, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig collectVariableName = { { 917 /* collectVariableName */, 2, 56, 2, 58, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig collectByRefItemNames = { { 944 /* collectByRefItemNames */, 2, 59, 2, 61, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig parameterTemplateName = { { 980 /* parameterTemplateName */, 1, 62, 1, 63, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig getFrame = { { 1050 /* getFrame */, 1, 64, 1, 65, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig isObserving = { { 1059 /* isObserving */, 1, 66, 1, 67, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getSignatureParameters = { { 1090 /* getSignatureParameters */, 3, 68, 3, 71, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getBodyParameters = { { 1113 /* getBodyParameters */, 2, 72, 2, 74, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getSignatureReturnType = { { 1142 /* getSignatureReturnType */, 3, 75, 3, 78, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getExpectedReturnType = { { 1165 /* getExpectedReturnType */, 2, 79, 2, 81, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig collectSites = { { 1187 /* collectSites */, 2, 82, 2, 84, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig createParameterMarker = { { 1262 /* createParameterMarker */, 2, 85, 2, 87, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig returnsContextTypedExpression = { { 1284 /* returnsContextTypedExpression */, 1, 88, 1, 89, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig isClosedBody = { { 1327 /* isClosedBody */, 2, 90, 2, 92, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig scanClosedBody = { { 1340 /* scanClosedBody */, 2, 93, 2, 95, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig infersInvocationReturnType = { { 1355 /* infersInvocationReturnType */, 2, 96, 2, 98, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig findAssignedClosures = { { 1382 /* findAssignedClosures */, 2, 99, 2, 101, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getAssignedClosures = { { 1403 /* getAssignedClosures */, 2, 102, 2, 104, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig collectTargetNames = { { 1423 /* collectTargetNames */, 2, 105, 2, 107, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig isContextTyped = { { 1442 /* isContextTyped */, 1, 108, 1, 109, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
 } // namespace sig
 
 } // namespace ptdecl::ClosureSignatureInference
diff --git a/turbo-ext/src/support.h b/turbo-ext/src/support.h
index 832fa6c67b1..96cf47dd3b5 100644
--- a/turbo-ext/src/support.h
+++ b/turbo-ext/src/support.h
@@ -3128,6 +3128,7 @@ zv::Val pt_closure_signature_inference_get_arrow_function_outer_variables(zval *
 zv::Val pt_closure_signature_inference_collect_escapes(zval *type);
 zv::Val pt_closure_signature_inference_collect_invoked_callee(zval *calleeType);
 zv::Val pt_closure_signature_inference_collect_absorbed(zval *input, zval *result);
+zv::Val pt_closure_signature_inference_collect_absorbed_into(zval *inputs, zval *result);
 zv::Val pt_closure_signature_inference_collect_absorbed_in_union(zval *types);
 [[nodiscard]] bool pt_closure_signature_inference_has_markers(zval *type, bool &out);
 /* the handlers' `$scope->addTemplateArgumentConstraints(

From 4bbf5c7976991bf1314e40c11875ca22b63f7b7d Mon Sep 17 00:00:00 2001
From: Ondrej Mirtes <ondrej@mirtes.cz>
Date: Mon, 28 Sep 2026 10:39:26 +0200
Subject: [PATCH 2/9] Do not build the value type of an array sent to plain
 mixed

Sending an array to `array` (a function's return type, a property)
recursed into getIterableValueType() of the sent array - for a large
constant array the union of all its values - only to observe nothing in
observeSend() and to let everything escape in observeClosureSend().
Outside a call argument observeSend() skips plain mixed key and value
targets, and observeClosureSend() lets the closures in the array itself
escape.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y5roddukgqaSAB2BT765UX
---
 .../Generics/TemplateArgumentObserver.php     | 30 +++++++++++++++++--
 turbo-ext/src/TemplateArgumentObserver.cpp    | 29 +++++++++++++++---
 .../src/generated/TemplateArgumentObserver.h  | 25 +++++++++-------
 3 files changed, 67 insertions(+), 17 deletions(-)

diff --git a/src/Analyser/Generics/TemplateArgumentObserver.php b/src/Analyser/Generics/TemplateArgumentObserver.php
index c96bc05d3d2..c3eaf43a5d4 100644
--- a/src/Analyser/Generics/TemplateArgumentObserver.php
+++ b/src/Analyser/Generics/TemplateArgumentObserver.php
@@ -192,8 +192,14 @@ private function observeClosureSend(TemplateArgumentConstraints $constraints, Ty
 			&& $declared->isIterable()->yes()
 		) {
 			$constraints = $this->observeClosureSend($constraints, $declared->getIterableKeyType(), $actual->getIterableKeyType());
+			$declaredValueType = $declared->getIterableValueType();
+			if ($declaredValueType instanceof MixedType && !$declaredValueType instanceof TemplateType) {
+				// every value sent to plain mixed escapes - collected from the
+				// array itself, not from the union of a large constant array's values
+				return $this->escapeClosures($constraints, $actual);
+			}
 
-			return $this->observeClosureSend($constraints, $declared->getIterableValueType(), $actual->getIterableValueType());
+			return $this->observeClosureSend($constraints, $declaredValueType, $actual->getIterableValueType());
 		}
 
 		return $this->escapeClosures($constraints, $actual);
@@ -501,12 +507,30 @@ private function observeSend(TemplateArgumentConstraints $constraints, Type $dec
 			return $constraints;
 		}
 
-		$constraints = $this->observeSend($constraints, $declared->getIterableKeyType(), $actual->getIterableKeyType(), $isCallArgument);
-		$constraints = $this->observeSend($constraints, $declared->getIterableValueType(), $actual->getIterableValueType(), $isCallArgument);
+		// the key and value types of a large constant array are the unions of
+		// all its keys and values - not built for a target they cannot constrain
+		$declaredKeyType = $declared->getIterableKeyType();
+		if (!self::isInertSendTarget($declaredKeyType, $isCallArgument)) {
+			$constraints = $this->observeSend($constraints, $declaredKeyType, $actual->getIterableKeyType(), $isCallArgument);
+		}
+		$declaredValueType = $declared->getIterableValueType();
+		if (!self::isInertSendTarget($declaredValueType, $isCallArgument)) {
+			$constraints = $this->observeSend($constraints, $declaredValueType, $actual->getIterableValueType(), $isCallArgument);
+		}
 
 		return $constraints;
 	}
 
+	/**
+	 * observeSend() observes nothing sent to plain mixed outside a call
+	 * argument: a union recurses into its members, a bare marker never
+	 * constrains, mixed names no class and is not certainly iterable.
+	 */
+	private static function isInertSendTarget(Type $declared, bool $isCallArgument): bool
+	{
+		return !$isCallArgument && $declared instanceof MixedType && !$declared instanceof TemplateType;
+	}
+
 	/**
 	 * An argument was passed to a parameter: the argument's markers are sent to
 	 * the parameter type, and a parameter type carrying the receiver's markers
diff --git a/turbo-ext/src/TemplateArgumentObserver.cpp b/turbo-ext/src/TemplateArgumentObserver.cpp
index a8d1026c7f5..198de1c0a11 100644
--- a/turbo-ext/src/TemplateArgumentObserver.cpp
+++ b/turbo-ext/src/TemplateArgumentObserver.cpp
@@ -343,6 +343,11 @@ class TemplateArgumentObserver
 						if (UNEXPECTED(constraints.isUndef())) return zv::Val();
 						zv::Val declaredValue = pt_type_op(Z_OBJ_P(declared), PT_OP_GET_ITERABLE_VALUE_TYPE, 0, NULL);
 						if (UNEXPECTED(declaredValue.isUndef())) return zv::Val();
+						bool plainMixed;
+						if (UNEXPECTED(!isPlainMixed(declaredValue.raw(), plainMixed))) return zv::Val();
+						if (plainMixed) {
+							return escapeClosures(std::move(constraints), actual);
+						}
 						zv::Val actualValue = pt_type_op(Z_OBJ_P(actual), PT_OP_GET_ITERABLE_VALUE_TYPE, 0, NULL);
 						if (UNEXPECTED(actualValue.isUndef())) return zv::Val();
 						return observeClosureSend(std::move(constraints), declaredValue.raw(), actualValue.raw());
@@ -842,17 +847,33 @@ class TemplateArgumentObserver
 
 		zv::Val declaredKey = pt_type_op(Z_OBJ_P(declared), PT_OP_GET_ITERABLE_KEY_TYPE, 0, NULL);
 		if (UNEXPECTED(declaredKey.isUndef())) return zv::Val();
-		zv::Val actualKey = pt_type_op(Z_OBJ_P(actual), PT_OP_GET_ITERABLE_KEY_TYPE, 0, NULL);
-		if (UNEXPECTED(actualKey.isUndef())) return zv::Val();
-		constraints = observeSend(std::move(constraints), declaredKey.raw(), actualKey.raw(), isCallArgument);
-		if (UNEXPECTED(constraints.isUndef())) return zv::Val();
+		bool inert;
+		if (UNEXPECTED(!isInertSendTarget(declaredKey.raw(), isCallArgument, inert))) return zv::Val();
+		if (!inert) {
+			zv::Val actualKey = pt_type_op(Z_OBJ_P(actual), PT_OP_GET_ITERABLE_KEY_TYPE, 0, NULL);
+			if (UNEXPECTED(actualKey.isUndef())) return zv::Val();
+			constraints = observeSend(std::move(constraints), declaredKey.raw(), actualKey.raw(), isCallArgument);
+			if (UNEXPECTED(constraints.isUndef())) return zv::Val();
+		}
 		zv::Val declaredValue = pt_type_op(Z_OBJ_P(declared), PT_OP_GET_ITERABLE_VALUE_TYPE, 0, NULL);
 		if (UNEXPECTED(declaredValue.isUndef())) return zv::Val();
+		if (UNEXPECTED(!isInertSendTarget(declaredValue.raw(), isCallArgument, inert))) return zv::Val();
+		if (inert) return constraints;
 		zv::Val actualValue = pt_type_op(Z_OBJ_P(actual), PT_OP_GET_ITERABLE_VALUE_TYPE, 0, NULL);
 		if (UNEXPECTED(actualValue.isUndef())) return zv::Val();
 		return observeSend(std::move(constraints), declaredValue.raw(), actualValue.raw(), isCallArgument);
 	}
 
+	/* Mirrors isInertSendTarget(); false = pending exception */
+	[[nodiscard]] static bool isInertSendTarget(zval *declared, bool isCallArgument, bool &out)
+	{
+		if (isCallArgument) {
+			out = false;
+			return true;
+		}
+		return isPlainMixed(declared, out);
+	}
+
 	/* Mirrors observeArgument(). */
 	static zv::Val observeArgument(zv::Val constraints, zval *parameterType, zval *argumentType)
 	{
diff --git a/turbo-ext/src/generated/TemplateArgumentObserver.h b/turbo-ext/src/generated/TemplateArgumentObserver.h
index fd44452cb68..03d1f36b851 100644
--- a/turbo-ext/src/generated/TemplateArgumentObserver.h
+++ b/turbo-ext/src/generated/TemplateArgumentObserver.h
@@ -63,11 +63,12 @@ inline constexpr char strings[] =
 	"replaceInferableTemplates\0" /* 634 */
 	"isCallArgument\0" /* 660 */
 	"observeSend\0" /* 675 */
-	"observeArgument\0" /* 687 */
-	"observeLowerBound\0" /* 703 */
-	"declaredArgument\0" /* 721 */
-	"isUninformativeSendTarget\0" /* 738 */
-	"hasOnlyInferableTemplates"; /* 764 */
+	"isInertSendTarget\0" /* 687 */
+	"observeArgument\0" /* 705 */
+	"observeLowerBound\0" /* 721 */
+	"declaredArgument\0" /* 739 */
+	"isUninformativeSendTarget\0" /* 756 */
+	"hasOnlyInferableTemplates"; /* 782 */
 inline constexpr reg::PackedArg args[] = {
 	reg::packed(0, 0, 5), /* collectSites $type */
 	reg::packed(23, 0, 24), /* collectSites return */
@@ -123,6 +124,9 @@ inline constexpr reg::PackedArg args[] = {
 	reg::packed(143, 0, 5), /* observeSend $actual */
 	reg::packed(660, MAY_BE_BOOL, reg::NoString, false, false, 113), /* observeSend $isCallArgument */
 	reg::packed(23, 0, 24), /* observeSend return */
+	reg::packed(134, 0, 5), /* isInertSendTarget $declared */
+	reg::packed(660, MAY_BE_BOOL), /* isInertSendTarget $isCallArgument */
+	reg::packed(23, MAY_BE_BOOL), /* isInertSendTarget return */
 	reg::packed(386, 0, 24), /* observeArgument $constraints */
 	reg::packed(162, 0, 5), /* observeArgument $parameterType */
 	reg::packed(176, 0, 5), /* observeArgument $argumentType */
@@ -131,7 +135,7 @@ inline constexpr reg::PackedArg args[] = {
 	reg::packed(162, 0, 5), /* observeLowerBound $parameterType */
 	reg::packed(176, 0, 5), /* observeLowerBound $argumentType */
 	reg::packed(23, 0, 24), /* observeLowerBound return */
-	reg::packed(721, 0, 5), /* isUninformativeSendTarget $declaredArgument */
+	reg::packed(739, 0, 5), /* isUninformativeSendTarget $declaredArgument */
 	reg::packed(23, MAY_BE_BOOL), /* isUninformativeSendTarget return */
 	reg::packed(0, 0, 5), /* hasOnlyInferableTemplates $type */
 	reg::packed(23, MAY_BE_BOOL), /* hasOnlyInferableTemplates return */
@@ -157,10 +161,11 @@ inline constexpr sigtab::Sig collectArgument = { { 514 /* collectArgument */, 2,
 inline constexpr sigtab::Sig collectCall = { { 612 /* collectCall */, 3, 39, 4, 43, ZEND_ACC_PUBLIC } };
 inline constexpr sigtab::Sig replaceInferableTemplates = { { 634 /* replaceInferableTemplates */, 4, 44, 4, 48, ZEND_ACC_PRIVATE } };
 inline constexpr sigtab::Sig observeSend = { { 675 /* observeSend */, 3, 49, 4, 53, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig observeArgument = { { 687 /* observeArgument */, 3, 54, 3, 57, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig observeLowerBound = { { 703 /* observeLowerBound */, 3, 58, 3, 61, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig isUninformativeSendTarget = { { 738 /* isUninformativeSendTarget */, 1, 62, 1, 63, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig hasOnlyInferableTemplates = { { 764 /* hasOnlyInferableTemplates */, 1, 64, 1, 65, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig isInertSendTarget = { { 687 /* isInertSendTarget */, 2, 54, 2, 56, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig observeArgument = { { 705 /* observeArgument */, 3, 57, 3, 60, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig observeLowerBound = { { 721 /* observeLowerBound */, 3, 61, 3, 64, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig isUninformativeSendTarget = { { 756 /* isUninformativeSendTarget */, 1, 65, 1, 66, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig hasOnlyInferableTemplates = { { 782 /* hasOnlyInferableTemplates */, 1, 67, 1, 68, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
 } // namespace sig
 
 } // namespace ptdecl::TemplateArgumentObserver

From 766dcc4a6703d631f1cbffc23ada34558c66c074 Mon Sep 17 00:00:00 2001
From: Ondrej Mirtes <ondrej@mirtes.cz>
Date: Mon, 28 Sep 2026 11:23:53 +0200
Subject: [PATCH 3/9] Walk a by-ref closure's body once per state it is invoked
 from

Every invocation of a closure whose by-ref uses are followed walked its
body - until the by-ref variables converge while observing - even when an
earlier invocation in the same pass entered it in the same state: a data
provider invoking `$room(...)` 362 times walked the body 1297 times.

The walks are kept in the ExpressionResultStorage of the walk they run in,
keyed by the closure, the template argument frame, whether they ran until
the fixpoint, whether native types are promoted, and the entered scope. An
invocation entering an equal scope takes the stored exit scope and throw
points and applies them to its own scope and call, as the walk would.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y5roddukgqaSAB2BT765UX
---
 src/Analyser/ClosureProcessor.php             |  61 +++++++++-
 src/Analyser/ExpressionResultStorage.php      |  38 ++++++
 turbo-ext/src/ClosureProcessor.cpp            | 115 ++++++++++++++----
 turbo-ext/src/ExpressionResultStorage.cpp     |  88 ++++++++++++++
 turbo-ext/src/generated/ClosureProcessor.h    |  97 ++++++++-------
 .../src/generated/ExpressionResultStorage.h   |  16 ++-
 turbo-ext/src/support.h                       |   4 +
 turbo-ext/tests/signature-parity.php          |   1 +
 turbo-ext/tests/smoke.php                     |  15 +++
 9 files changed, 360 insertions(+), 75 deletions(-)

diff --git a/src/Analyser/ClosureProcessor.php b/src/Analyser/ClosureProcessor.php
index 88d632b1e99..f1b2f89a9e2 100644
--- a/src/Analyser/ClosureProcessor.php
+++ b/src/Analyser/ClosureProcessor.php
@@ -434,6 +434,60 @@ public function processByRefInvocation(
 		$enter = fn (MutatingScope $byRefSource): MutatingScope => $this->enterWithCapturedUses($scope, $expr, $callableParameters, $creationScope)->processClosureScope($byRefSource, null, $byRefUses);
 
 		$entryScope = $enter($scope);
+		$frame = $scope->getCurrentTemplateArgumentFrame();
+		$walk = null;
+		// the body entered in a state it was already walked from, in the same
+		// pass: a closure invoked many times mostly re-enters one of a few states
+		foreach ($storage->findByRefInvocationWalks($expr) as $storedWalk) {
+			[$walkFrame, $walkUntilFixpoint, $walkNativeTypesPromoted, $walkEntryScope] = $storedWalk;
+			if (
+				$walkFrame !== $frame
+				|| $walkUntilFixpoint !== $untilFixpoint
+				|| $walkNativeTypesPromoted !== $scope->nativeTypesPromoted
+				|| !$walkEntryScope->equals($entryScope)
+			) {
+				continue;
+			}
+			$walk = $storedWalk;
+			break;
+		}
+		if ($walk === null) {
+			[$exitScope, $bodyThrowPoints] = $this->walkByRefInvocation($nodeScopeResolver, $expr, $scope, $storage, $entryScope, $enter, $byRefUses, $untilFixpoint);
+			$walk = [$frame, $untilFixpoint, $scope->nativeTypesPromoted, $entryScope, $exitScope, $bodyThrowPoints];
+			$storage->storeByRefInvocationWalk($expr, $walk);
+		}
+		[, , , , $exitScope, $bodyThrowPoints] = $walk;
+
+		$throwPoints = [];
+		foreach ($bodyThrowPoints as $throwPoint) {
+			$throwScope = $this->assignByRefUses($scope, $throwPoint->getScope(), $byRefUses);
+			$throwPoints[] = $throwPoint->isExplicit()
+				? InternalThrowPoint::createExplicit($throwScope, $throwPoint->getType(), $call, $throwPoint->canContainAnyThrowable())
+				: InternalThrowPoint::createImplicit($throwScope, $call);
+		}
+
+		return [$this->assignByRefUses($scope, $exitScope, $byRefUses), $throwPoints];
+	}
+
+	/**
+	 * The walks of processByRefInvocation() from the entry scope: the body's
+	 * exit scope and throw points, in the closure's own scope.
+	 *
+	 * @param callable(MutatingScope): MutatingScope $enter
+	 * @param Node\ClosureUse[] $byRefUses
+	 * @return array{MutatingScope, list<InternalThrowPoint>}
+	 */
+	private function walkByRefInvocation(
+		NodeScopeResolver $nodeScopeResolver,
+		Expr\Closure $expr,
+		MutatingScope $scope,
+		ExpressionResultStorage $storage,
+		MutatingScope $entryScope,
+		callable $enter,
+		array $byRefUses,
+		bool $untilFixpoint,
+	): array
+	{
 		$exitScope = null;
 		$throwPoints = [];
 		$count = 0;
@@ -445,10 +499,7 @@ public function processByRefInvocation(
 			}
 			$exitScope = $exitScope === null ? $passExitScope : $exitScope->mergeWith($passExitScope);
 			foreach ($result->getThrowPoints() as $throwPoint) {
-				$throwScope = $this->assignByRefUses($scope, $throwPoint->getScope(), $byRefUses);
-				$throwPoints[] = $throwPoint->isExplicit()
-					? InternalThrowPoint::createExplicit($throwScope, $throwPoint->getType(), $call, $throwPoint->canContainAnyThrowable())
-					: InternalThrowPoint::createImplicit($throwScope, $call);
+				$throwPoints[] = $throwPoint;
 			}
 			if (!$untilFixpoint) {
 				break;
@@ -471,7 +522,7 @@ public function processByRefInvocation(
 			$exitScope = $exitScope->mergeWith($entryScope);
 		}
 
-		return [$this->assignByRefUses($scope, $exitScope, $byRefUses), $throwPoints];
+		return [$exitScope, $throwPoints];
 	}
 
 	/**
diff --git a/src/Analyser/ExpressionResultStorage.php b/src/Analyser/ExpressionResultStorage.php
index 15d4a520915..a3de0d9a208 100644
--- a/src/Analyser/ExpressionResultStorage.php
+++ b/src/Analyser/ExpressionResultStorage.php
@@ -3,6 +3,7 @@
 namespace PHPStan\Analyser;
 
 use PhpParser\Node\Expr;
+use PHPStan\Analyser\Generics\TemplateArgumentFrame;
 use PHPStan\Turbo\ShadowedByTurboExtension;
 use SplObjectStorage;
 
@@ -19,6 +20,17 @@ final class ExpressionResultStorage
 	 */
 	private ?self $fallback = null;
 
+	/**
+	 * The walks of closure bodies run for invocations of closures whose by-ref
+	 * uses are followed (see ClosureProcessor::processByRefInvocation()),
+	 * keyed by the closure: [frame, until fixpoint, native types promoted,
+	 * entry scope, exit scope, throw points]. The walk is a function of these,
+	 * so an invocation entering the body in a state already walked reads it.
+	 *
+	 * @var SplObjectStorage<Expr\Closure, list<array{TemplateArgumentFrame|null, bool, bool, MutatingScope, MutatingScope, list<InternalThrowPoint>}>>|null
+	 */
+	private ?SplObjectStorage $byRefInvocationWalks = null;
+
 	public function __construct()
 	{
 		$this->exprResults = new SplObjectStorage();
@@ -46,4 +58,30 @@ public function findExpressionResult(Expr $expr): ?ExpressionResult
 		return $this->exprResults[$expr] ?? ($this->fallback !== null ? $this->fallback->findExpressionResult($expr) : null);
 	}
 
+	/**
+	 * @param array{TemplateArgumentFrame|null, bool, bool, MutatingScope, MutatingScope, list<InternalThrowPoint>} $walk
+	 */
+	public function storeByRefInvocationWalk(Expr\Closure $closure, array $walk): void
+	{
+		$this->byRefInvocationWalks ??= new SplObjectStorage();
+		$walks = $this->byRefInvocationWalks[$closure] ?? [];
+		$walks[] = $walk;
+		$this->byRefInvocationWalks[$closure] = $walks;
+	}
+
+	/**
+	 * The walks stored here and in the storages this one falls back to.
+	 *
+	 * @return list<array{TemplateArgumentFrame|null, bool, bool, MutatingScope, MutatingScope, list<InternalThrowPoint>}>
+	 */
+	public function findByRefInvocationWalks(Expr\Closure $closure): array
+	{
+		$walks = $this->byRefInvocationWalks[$closure] ?? [];
+		if ($this->fallback === null) {
+			return $walks;
+		}
+
+		return [...$walks, ...$this->fallback->findByRefInvocationWalks($closure)];
+	}
+
 }
diff --git a/turbo-ext/src/ClosureProcessor.cpp b/turbo-ext/src/ClosureProcessor.cpp
index 9f56650eedc..20a0b041491 100644
--- a/turbo-ext/src/ClosureProcessor.cpp
+++ b/turbo-ext/src/ClosureProcessor.cpp
@@ -343,6 +343,89 @@ class ClosureProcessor
 		zv::Val stmtsHold = zv::Val::copyOf(zv::Ref(stmts));
 		zv::Val entryScope = enter(scope);
 		if (UNEXPECTED(entryScope.isUndef())) return zv::Val();
+		zv::Val frame = pt_mutating_scope_get_current_template_argument_frame(Z_OBJ_P(scope));
+		if (UNEXPECTED(frame.isUndef())) return zv::Val();
+		bool nativeTypesPromoted;
+		if (UNEXPECTED(!pt_mutating_scope_native_types_promoted(Z_OBJ_P(scope), nativeTypesPromoted))) return zv::Val();
+		// the body entered in a state it was already walked from, in the same
+		// pass: a closure invoked many times mostly re-enters one of a few states
+		zv::Val walk;
+		{
+			zv::Val storedWalks = pt_expression_result_storage_find_by_ref_invocation_walks(storage, expr);
+			if (UNEXPECTED(storedWalks.isUndef())) return zv::Val();
+			for (zv::ArrayEntry entry : zv::ArrRef(storedWalks.raw())) {
+				zval *storedWalk = entry.value().deref().raw();
+				zval *walkFrame = zend_hash_index_find(Z_ARRVAL_P(storedWalk), 0);
+				zval *walkUntilFixpoint = zend_hash_index_find(Z_ARRVAL_P(storedWalk), 1);
+				zval *walkNativeTypesPromoted = zend_hash_index_find(Z_ARRVAL_P(storedWalk), 2);
+				zval *walkEntryScope = zend_hash_index_find(Z_ARRVAL_P(storedWalk), 3);
+				if (UNEXPECTED(walkFrame == NULL || walkUntilFixpoint == NULL || walkNativeTypesPromoted == NULL || walkEntryScope == NULL)) continue;
+				bool sameFrame = Z_TYPE_P(walkFrame) == IS_OBJECT
+					? Z_TYPE_P(frame.raw()) == IS_OBJECT && Z_OBJ_P(walkFrame) == Z_OBJ_P(frame.raw())
+					: Z_TYPE_P(frame.raw()) != IS_OBJECT;
+				if (!sameFrame || (Z_TYPE_P(walkUntilFixpoint) == IS_TRUE) != untilFixpoint || (Z_TYPE_P(walkNativeTypesPromoted) == IS_TRUE) != nativeTypesPromoted) continue;
+				bool equals = false;
+				if (UNEXPECTED(!pt_mutating_scope_equals(Z_OBJ_P(walkEntryScope), Z_OBJ_P(entryScope.raw()), equals))) return zv::Val();
+				if (!equals) continue;
+				walk = zv::Val::copyOf(zv::Ref(storedWalk));
+				break;
+			}
+		}
+		if (walk.isUndef()) {
+			zv::Val walked = walkByRefInvocation(nodeScopeResolver, expr, scope, storage, entryScope.raw(), enter, byRefUses.raw(), stmtsHold.raw(), untilFixpoint);
+			if (UNEXPECTED(walked.isUndef())) return zv::Val();
+			zv::Arr stored = zv::Arr::create(6);
+			stored.push(zv::Val::copyOf(zv::Ref(frame.raw())));
+			stored.push(zv::Val::boolean(untilFixpoint));
+			stored.push(zv::Val::boolean(nativeTypesPromoted));
+			stored.push(zv::Val::copyOf(zv::Ref(entryScope.raw())));
+			stored.push(zv::Val::copyOf(zv::Ref(zend_hash_index_find(Z_ARRVAL_P(walked.raw()), 0))));
+			stored.push(zv::Val::copyOf(zv::Ref(zend_hash_index_find(Z_ARRVAL_P(walked.raw()), 1))));
+			walk = zv::Val(std::move(stored));
+			if (UNEXPECTED(!pt_expression_result_storage_store_by_ref_invocation_walk(storage, expr, walk.raw()))) return zv::Val();
+		}
+		zval *exitScope = zend_hash_index_find(Z_ARRVAL_P(walk.raw()), 4);
+		zval *bodyThrowPoints = zend_hash_index_find(Z_ARRVAL_P(walk.raw()), 5);
+		if (UNEXPECTED(exitScope == NULL || bodyThrowPoints == NULL)) return zv::Val();
+
+		zv::Arr throwPoints = zv::Arr::empty();
+		for (zv::ArrayEntry entry : zv::ArrRef(bodyThrowPoints)) {
+			zval *throwPoint = entry.value().deref().raw();
+			zv::Val throwPointScopeHold;
+			zval *throwPointScope = pt_internal_throw_point_scope(throwPoint, throwPointScopeHold);
+			if (UNEXPECTED(throwPointScope == NULL)) return zv::Val();
+			zv::Val throwScope = assignByRefUses(scope, throwPointScope, byRefUses.raw());
+			if (UNEXPECTED(throwScope.isUndef())) return zv::Val();
+			bool isExplicit;
+			if (UNEXPECTED(!pt_internal_throw_point_is_explicit(throwPoint, isExplicit))) return zv::Val();
+			zv::Val created;
+			if (isExplicit) {
+				zv::Val typeHold;
+				zval *type = pt_internal_throw_point_type(throwPoint, typeHold);
+				if (UNEXPECTED(type == NULL)) return zv::Val();
+				bool canContainAnyThrowable;
+				if (UNEXPECTED(!pt_internal_throw_point_can_contain_any_throwable(throwPoint, canContainAnyThrowable))) return zv::Val();
+				created = pt_internal_throw_point_create_explicit(throwScope.raw(), type, call, canContainAnyThrowable);
+			} else {
+				created = pt_internal_throw_point_create_implicit(throwScope.raw(), call);
+			}
+			if (UNEXPECTED(created.isUndef())) return zv::Val();
+			throwPoints.push(std::move(created));
+		}
+
+		zv::Val resultScope = assignByRefUses(scope, exitScope, byRefUses.raw());
+		if (UNEXPECTED(resultScope.isUndef())) return zv::Val();
+		zv::Arr pair = zv::Arr::create(2);
+		pair.push(std::move(resultScope));
+		pair.push(std::move(throwPoints));
+		return zv::Val(std::move(pair));
+	}
+
+	/* Mirrors walkByRefInvocation(): [the body's exit scope, its throw points] */
+	template<typename Enter>
+	zv::Val walkByRefInvocation(zval *nodeScopeResolver, zval *expr, zval *scope, zval *storage, zval *firstEntryScope, Enter &enter, zval *byRefUses, zval *stmts, bool untilFixpoint) const
+	{
+		zv::Val entryScope = zv::Val::copyOf(zv::Ref(firstEntryScope));
 		zv::Val exitScope;
 		zv::Arr throwPoints = zv::Arr::empty();
 		zend_long count = 0;
@@ -353,7 +436,7 @@ class ClosureProcessor
 			if (UNEXPECTED(noop.isUndef())) return zv::Val();
 			zv::Val context = pt_statement_context_create_top_level(false);
 			if (UNEXPECTED(context.isUndef())) return zv::Val();
-			zv::Val result = pt_node_scope_resolver_process_stmt_nodes_internal(nodeScopeResolver, expr, stmtsHold.raw(), entryScope.raw(), passStorage.raw(), noop.raw(), context.raw());
+			zv::Val result = pt_node_scope_resolver_process_stmt_nodes_internal(nodeScopeResolver, expr, stmts, entryScope.raw(), passStorage.raw(), noop.raw(), context.raw());
 			if (UNEXPECTED(result.isUndef())) return zv::Val();
 			zv::Val passExitScope;
 			{
@@ -386,35 +469,15 @@ class ClosureProcessor
 				if (UNEXPECTED(resultThrowPoints == NULL)) return zv::Val();
 				zv::Val throwPointsIterated = zv::Val::copyOf(zv::Ref(resultThrowPoints));
 				for (zv::ArrayEntry entry : zv::ArrRef(throwPointsIterated.raw())) {
-					zval *throwPoint = entry.value().deref().raw();
-					zv::Val throwPointScopeHold;
-					zval *throwPointScope = pt_internal_throw_point_scope(throwPoint, throwPointScopeHold);
-					if (UNEXPECTED(throwPointScope == NULL)) return zv::Val();
-					zv::Val throwScope = assignByRefUses(scope, throwPointScope, byRefUses.raw());
-					if (UNEXPECTED(throwScope.isUndef())) return zv::Val();
-					bool isExplicit;
-					if (UNEXPECTED(!pt_internal_throw_point_is_explicit(throwPoint, isExplicit))) return zv::Val();
-					zv::Val created;
-					if (isExplicit) {
-						zv::Val typeHold;
-						zval *type = pt_internal_throw_point_type(throwPoint, typeHold);
-						if (UNEXPECTED(type == NULL)) return zv::Val();
-						bool canContainAnyThrowable;
-						if (UNEXPECTED(!pt_internal_throw_point_can_contain_any_throwable(throwPoint, canContainAnyThrowable))) return zv::Val();
-						created = pt_internal_throw_point_create_explicit(throwScope.raw(), type, call, canContainAnyThrowable);
-					} else {
-						created = pt_internal_throw_point_create_implicit(throwScope.raw(), call);
-					}
-					if (UNEXPECTED(created.isUndef())) return zv::Val();
-					throwPoints.push(std::move(created));
+					throwPoints.push(entry.value().deref());
 				}
 			}
 			if (!untilFixpoint) break;
 
 			// the next run starts from any state a run may have left
-			zv::Val entryAssigned = assignByRefUses(scope, entryScope.raw(), byRefUses.raw());
+			zv::Val entryAssigned = assignByRefUses(scope, entryScope.raw(), byRefUses);
 			if (UNEXPECTED(entryAssigned.isUndef())) return zv::Val();
-			zv::Val exitAssigned = assignByRefUses(scope, passExitScope.raw(), byRefUses.raw());
+			zv::Val exitAssigned = assignByRefUses(scope, passExitScope.raw(), byRefUses);
 			if (UNEXPECTED(exitAssigned.isUndef())) return zv::Val();
 			zv::Val joined = pt_mutating_scope_merge_with(Z_OBJ_P(entryAssigned.raw()), exitAssigned.raw());
 			if (UNEXPECTED(joined.isUndef())) return zv::Val();
@@ -439,10 +502,8 @@ class ClosureProcessor
 			exitScope = std::move(merged);
 		}
 
-		zv::Val resultScope = assignByRefUses(scope, exitScope.raw(), byRefUses.raw());
-		if (UNEXPECTED(resultScope.isUndef())) return zv::Val();
 		zv::Arr pair = zv::Arr::create(2);
-		pair.push(std::move(resultScope));
+		pair.push(std::move(exitScope));
 		pair.push(std::move(throwPoints));
 		return zv::Val(std::move(pair));
 	}
diff --git a/turbo-ext/src/ExpressionResultStorage.cpp b/turbo-ext/src/ExpressionResultStorage.cpp
index 0d0bcd48f2f..69a85909eb8 100644
--- a/turbo-ext/src/ExpressionResultStorage.cpp
+++ b/turbo-ext/src/ExpressionResultStorage.cpp
@@ -25,6 +25,7 @@ namespace sigs = ptdecl::ExpressionResultStorage::sig;
 #include "zv.h"
 
 #define PT_ERS_PROP_FALLBACK 2
+#define PT_ERS_PROP_BY_REF_INVOCATION_WALKS 3
 
 zend_class_entry *pt_ce_expression_result_storage = nullptr;
 
@@ -82,6 +83,53 @@ class ExpressionResultStorage
 		}
 	}
 
+	/* Mirrors storeByRefInvocationWalk(): the walks keyed by the closure's
+	 * handle as [closure, list of walks] - the closure is pinned like the
+	 * stored Exprs */
+	void storeByRefInvocationWalk(zval *closure, zval *walk)
+	{
+		zend_ulong id = Z_OBJ_HANDLE_P(closure);
+		zv::ObjRef obj(self);
+		zv::ArrRef table(obj.propAt(PT_ERS_PROP_BY_REF_INVOCATION_WALKS).raw());
+		zv::Ref entry = table.findIndex(id);
+		zv::Arr walks = zv::Arr::empty();
+		if (entry.raw() != NULL) {
+			zval *stored = zend_hash_index_find(Z_ARRVAL_P(entry.deref().raw()), 1);
+			if (stored != NULL) walks = zv::Arr::copyOfTable(Z_ARRVAL_P(stored));
+		}
+		walks.push(zv::Val::copyOf(zv::Ref(walk)));
+		zv::Arr pair = zv::Arr::create(2);
+		pair.push(zv::Val::copyOf(zv::Ref(closure)));
+		pair.push(std::move(walks));
+		zv::Val pairHold(std::move(pair));
+		table.setIndex(id, zv::Ref(pairHold.raw()));
+	}
+
+	/* Mirrors findByRefInvocationWalks(): this storage's walks, then the
+	 * fallback chain's */
+	zv::Val findByRefInvocationWalks(zval *closure) const
+	{
+		zend_ulong id = Z_OBJ_HANDLE_P(closure);
+		zv::Arr walks = zv::Arr::empty();
+		zval *cur = self;
+		for (;;) {
+			zv::ObjRef obj(cur);
+			zv::Ref entry = zv::ArrRef(obj.propAt(PT_ERS_PROP_BY_REF_INVOCATION_WALKS).raw()).findIndex(id);
+			if (entry.raw() != NULL) {
+				zval *stored = zend_hash_index_find(Z_ARRVAL_P(entry.deref().raw()), 1);
+				if (stored != NULL) {
+					for (zv::ArrayEntry walk : zv::ArrRef(stored)) {
+						walks.push(zv::Val::copyOf(walk.value()));
+					}
+				}
+			}
+			zval *fallback = obj.propAt(PT_ERS_PROP_FALLBACK).raw();
+			if (Z_TYPE_P(fallback) != IS_OBJECT) break;
+			cur = fallback;
+		}
+		return zv::Val(std::move(walks));
+	}
+
 private:
 	zval *self;
 };
@@ -115,6 +163,9 @@ PT_MINIT_REGISTRATION(pt_register_expression_result_storage)
 	cls.privateArrayProperty("exprsById");
 	cls.privateArrayProperty("resultsById");
 	cls.property("fallback", ZEND_ACC_PRIVATE, reg::PropertyKind::TypedNull, MAY_BE_NULL, "self");
+	/* the twin's ?SplObjectStorage $byRefInvocationWalks: [closure, walks]
+	 * keyed by the closure's handle */
+	cls.privateArrayProperty("byRefInvocationWalksById");
 
 	/* the twin's constructor only initialized its SplObjectStorage; the
 	 * native property defaults already cover that */
@@ -163,6 +214,27 @@ PT_MINIT_REGISTRATION(pt_register_expression_result_storage)
 		ExpressionResultStorage(ZEND_THIS).findExpressionResult(expr).intoReturnValue(return_value);
 	});
 
+	cls.method(sigs::storeByRefInvocationWalk, [](INTERNAL_FUNCTION_PARAMETERS) {
+		zval *closure, *walk;
+		zend_class_entry *closureCe = pt_class(PT_CLASS_CLOSURE_EXPR);
+		if (UNEXPECTED(closureCe == NULL)) RETURN_THROWS();
+		ZEND_PARSE_PARAMETERS_START(2, 2)
+			Z_PARAM_OBJECT_OF_CLASS(closure, closureCe)
+			Z_PARAM_ARRAY(walk)
+		ZEND_PARSE_PARAMETERS_END();
+		ExpressionResultStorage(ZEND_THIS).storeByRefInvocationWalk(closure, walk);
+	});
+
+	cls.method(sigs::findByRefInvocationWalks, [](INTERNAL_FUNCTION_PARAMETERS) {
+		zval *closure;
+		zend_class_entry *closureCe = pt_class(PT_CLASS_CLOSURE_EXPR);
+		if (UNEXPECTED(closureCe == NULL)) RETURN_THROWS();
+		ZEND_PARSE_PARAMETERS_START(1, 1)
+			Z_PARAM_OBJECT_OF_CLASS(closure, closureCe)
+		ZEND_PARSE_PARAMETERS_END();
+		ExpressionResultStorage(ZEND_THIS).findByRefInvocationWalks(closure).intoReturnValue(return_value);
+	});
+
 	cls.shadow(&pt_ce_expression_result_storage);
 }
 
@@ -203,3 +275,19 @@ bool pt_expression_result_storage_merge_results(zval *storage, zval *other)
 }
 
 /* }}} */
+
+zv::Val pt_expression_result_storage_find_by_ref_invocation_walks(zval *storage, zval *closure)
+{
+	if (EXPECTED(Z_OBJCE_P(storage) == pt_ce_expression_result_storage)) return ExpressionResultStorage(storage).findByRefInvocationWalks(closure);
+	return pt_type_call(Z_OBJ_P(storage), "findbyrefinvocationwalks", sizeof("findbyrefinvocationwalks") - 1, 1, closure);
+}
+
+[[nodiscard]] bool pt_expression_result_storage_store_by_ref_invocation_walk(zval *storage, zval *closure, zval *walk)
+{
+	if (EXPECTED(Z_OBJCE_P(storage) == pt_ce_expression_result_storage)) {
+		ExpressionResultStorage(storage).storeByRefInvocationWalk(closure, walk);
+		return true;
+	}
+	zv::Args argv{closure, walk};
+	return !pt_type_call(Z_OBJ_P(storage), "storebyrefinvocationwalk", sizeof("storebyrefinvocationwalk") - 1, 2, argv).isUndef();
+}
diff --git a/turbo-ext/src/generated/ClosureProcessor.h b/turbo-ext/src/generated/ClosureProcessor.h
index c382e861001..e0f9c493e0c 100644
--- a/turbo-ext/src/generated/ClosureProcessor.h
+++ b/turbo-ext/src/generated/ClosureProcessor.h
@@ -79,27 +79,30 @@ inline constexpr char strings[] =
 	"creationScope\0" /* 963 */
 	"untilFixpoint\0" /* 977 */
 	"processByRefInvocation\0" /* 991 */
-	"byRefEntryTypes\0" /* 1014 */
-	"processDeferredByRefClosureBody\0" /* 1030 */
-	"callableParameters\0" /* 1062 */
-	"enterWithCapturedUses\0" /* 1081 */
-	"source\0" /* 1103 */
-	"byRefUses\0" /* 1110 */
-	"assignByRefUses\0" /* 1120 */
-	"closureScope\0" /* 1136 */
-	"gatheredReturnStatementsWithScope\0" /* 1149 */
-	"gatheredYieldStatementsWithScope\0" /* 1183 */
-	"executionEnds\0" /* 1216 */
-	"throwPoints\0" /* 1230 */
-	"impurePoints\0" /* 1242 */
-	"invalidateExpressions\0" /* 1255 */
-	"refineClosureNodeScope\0" /* 1277 */
-	"invalidatedExpressions\0" /* 1300 */
-	"uses\0" /* 1323 */
-	"processImmediatelyCalledCallable\0" /* 1328 */
-	"PhpParser\\Node\\Expr\\ArrowFunction\0" /* 1361 */
-	"PHPStan\\Analyser\\ProcessArrowFunctionResult\0" /* 1395 */
-	"processArrowFunctionNode"; /* 1439 */
+	"entryScope\0" /* 1014 */
+	"enter\0" /* 1025 */
+	"byRefUses\0" /* 1031 */
+	"walkByRefInvocation\0" /* 1041 */
+	"byRefEntryTypes\0" /* 1061 */
+	"processDeferredByRefClosureBody\0" /* 1077 */
+	"callableParameters\0" /* 1109 */
+	"enterWithCapturedUses\0" /* 1128 */
+	"source\0" /* 1150 */
+	"assignByRefUses\0" /* 1157 */
+	"closureScope\0" /* 1173 */
+	"gatheredReturnStatementsWithScope\0" /* 1186 */
+	"gatheredYieldStatementsWithScope\0" /* 1220 */
+	"executionEnds\0" /* 1253 */
+	"throwPoints\0" /* 1267 */
+	"impurePoints\0" /* 1279 */
+	"invalidateExpressions\0" /* 1292 */
+	"refineClosureNodeScope\0" /* 1314 */
+	"invalidatedExpressions\0" /* 1337 */
+	"uses\0" /* 1360 */
+	"processImmediatelyCalledCallable\0" /* 1365 */
+	"PhpParser\\Node\\Expr\\ArrowFunction\0" /* 1398 */
+	"PHPStan\\Analyser\\ProcessArrowFunctionResult\0" /* 1432 */
+	"processArrowFunctionNode"; /* 1476 */
 inline constexpr reg::PackedArg args[] = {
 	reg::packed(0, 0, 10), /* __construct $container */
 	reg::packed(48, 0, 72), /* __construct $expressionResultFactory */
@@ -137,47 +140,56 @@ inline constexpr reg::PackedArg args[] = {
 	reg::packed(963, 0, 649), /* processByRefInvocation $creationScope */
 	reg::packed(977, MAY_BE_BOOL), /* processByRefInvocation $untilFixpoint */
 	reg::packed(471, MAY_BE_ARRAY), /* processByRefInvocation return */
+	reg::packed(532, 0, 550), /* walkByRefInvocation $nodeScopeResolver */
+	reg::packed(610, 0, 615), /* walkByRefInvocation $expr */
+	reg::packed(643, 0, 649), /* walkByRefInvocation $scope */
+	reg::packed(680, 0, 688), /* walkByRefInvocation $storage */
+	reg::packed(1014, 0, 649), /* walkByRefInvocation $entryScope */
+	reg::packed(1025, MAY_BE_CALLABLE), /* walkByRefInvocation $enter */
+	reg::packed(1031, MAY_BE_ARRAY), /* walkByRefInvocation $byRefUses */
+	reg::packed(977, MAY_BE_BOOL), /* walkByRefInvocation $untilFixpoint */
+	reg::packed(471, MAY_BE_ARRAY), /* walkByRefInvocation return */
 	reg::packed(532, 0, 550), /* processDeferredByRefClosureBody $nodeScopeResolver */
 	reg::packed(610, 0, 615), /* processDeferredByRefClosureBody $expr */
 	reg::packed(643, 0, 649), /* processDeferredByRefClosureBody $scope */
 	reg::packed(680, 0, 688), /* processDeferredByRefClosureBody $storage */
 	reg::packed(729, MAY_BE_CALLABLE), /* processDeferredByRefClosureBody $nodeCallback */
-	reg::packed(1014, MAY_BE_ARRAY), /* processDeferredByRefClosureBody $byRefEntryTypes */
+	reg::packed(1061, MAY_BE_ARRAY), /* processDeferredByRefClosureBody $byRefEntryTypes */
 	reg::packed(471, MAY_BE_VOID), /* processDeferredByRefClosureBody return */
 	reg::packed(643, 0, 649), /* enterWithCapturedUses $scope */
 	reg::packed(610, 0, 615), /* enterWithCapturedUses $expr */
-	reg::packed(1062, MAY_BE_ARRAY), /* enterWithCapturedUses $callableParameters */
+	reg::packed(1109, MAY_BE_ARRAY), /* enterWithCapturedUses $callableParameters */
 	reg::packed(963, 0, 649), /* enterWithCapturedUses $creationScope */
 	reg::packed(471, 0, 649), /* enterWithCapturedUses return */
 	reg::packed(643, 0, 649), /* assignByRefUses $scope */
-	reg::packed(1103, 0, 649), /* assignByRefUses $source */
-	reg::packed(1110, MAY_BE_ARRAY), /* assignByRefUses $byRefUses */
+	reg::packed(1150, 0, 649), /* assignByRefUses $source */
+	reg::packed(1031, MAY_BE_ARRAY), /* assignByRefUses $byRefUses */
 	reg::packed(471, 0, 649), /* assignByRefUses return */
-	reg::packed(1136, 0, 649), /* refineClosureNodeScope $closureScope */
+	reg::packed(1173, 0, 649), /* refineClosureNodeScope $closureScope */
 	reg::packed(643, 0, 649), /* refineClosureNodeScope $scope */
 	reg::packed(610, 0, 615), /* refineClosureNodeScope $expr */
-	reg::packed(1149, MAY_BE_ARRAY), /* refineClosureNodeScope $gatheredReturnStatementsWithScope */
-	reg::packed(1183, MAY_BE_ARRAY), /* refineClosureNodeScope $gatheredYieldStatementsWithScope */
-	reg::packed(1216, MAY_BE_ARRAY), /* refineClosureNodeScope $executionEnds */
-	reg::packed(1230, MAY_BE_ARRAY), /* refineClosureNodeScope $throwPoints */
-	reg::packed(1242, MAY_BE_ARRAY), /* refineClosureNodeScope $impurePoints */
-	reg::packed(1255, MAY_BE_ARRAY), /* refineClosureNodeScope $invalidateExpressions */
+	reg::packed(1186, MAY_BE_ARRAY), /* refineClosureNodeScope $gatheredReturnStatementsWithScope */
+	reg::packed(1220, MAY_BE_ARRAY), /* refineClosureNodeScope $gatheredYieldStatementsWithScope */
+	reg::packed(1253, MAY_BE_ARRAY), /* refineClosureNodeScope $executionEnds */
+	reg::packed(1267, MAY_BE_ARRAY), /* refineClosureNodeScope $throwPoints */
+	reg::packed(1279, MAY_BE_ARRAY), /* refineClosureNodeScope $impurePoints */
+	reg::packed(1292, MAY_BE_ARRAY), /* refineClosureNodeScope $invalidateExpressions */
 	reg::packed(680, 0, 688), /* refineClosureNodeScope $storage */
 	reg::packed(471, 0, 649), /* refineClosureNodeScope return */
 	reg::packed(643, 0, 649), /* processImmediatelyCalledCallable $scope */
-	reg::packed(1300, MAY_BE_ARRAY), /* processImmediatelyCalledCallable $invalidatedExpressions */
-	reg::packed(1323, MAY_BE_ARRAY), /* processImmediatelyCalledCallable $uses */
+	reg::packed(1337, MAY_BE_ARRAY), /* processImmediatelyCalledCallable $invalidatedExpressions */
+	reg::packed(1360, MAY_BE_ARRAY), /* processImmediatelyCalledCallable $uses */
 	reg::packed(471, 0, 649), /* processImmediatelyCalledCallable return */
 	reg::packed(532, 0, 550), /* processArrowFunctionNode $nodeScopeResolver */
 	reg::packed(585, 0, 590), /* processArrowFunctionNode $stmt */
-	reg::packed(610, 0, 1361), /* processArrowFunctionNode $expr */
+	reg::packed(610, 0, 1398), /* processArrowFunctionNode $expr */
 	reg::packed(643, 0, 649), /* processArrowFunctionNode $scope */
 	reg::packed(680, 0, 688), /* processArrowFunctionNode $storage */
 	reg::packed(729, MAY_BE_CALLABLE), /* processArrowFunctionNode $nodeCallback */
 	reg::packed(785, MAY_BE_NULL, 798), /* processArrowFunctionNode $passedToType */
 	reg::packed(816, MAY_BE_NULL, 798, false, false, 835), /* processArrowFunctionNode $nativePassedToType */
 	reg::packed(742, MAY_BE_NULL, 750, false, false, 835), /* processArrowFunctionNode $context */
-	reg::packed(471, 0, 1395), /* processArrowFunctionNode return */
+	reg::packed(471, 0, 1432), /* processArrowFunctionNode return */
 };
 using Sig = reg::Sig<strings, args>;
 } // namespace sigtab
@@ -189,12 +201,13 @@ inline constexpr sigtab::Sig getParametersProcessor = { { 509 /* getParametersPr
 inline constexpr sigtab::Sig processClosureNode = { { 878 /* processClosureNode */, 8, 7, 9, 16, ZEND_ACC_PUBLIC } };
 inline constexpr sigtab::Sig processClosureNodeInternal = { { 897 /* processClosureNodeInternal */, 8, 17, 9, 26, ZEND_ACC_PRIVATE } };
 inline constexpr sigtab::Sig processByRefInvocation = { { 991 /* processByRefInvocation */, 8, 27, 8, 35, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig processDeferredByRefClosureBody = { { 1030 /* processDeferredByRefClosureBody */, 6, 36, 6, 42, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig enterWithCapturedUses = { { 1081 /* enterWithCapturedUses */, 4, 43, 4, 47, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig assignByRefUses = { { 1120 /* assignByRefUses */, 3, 48, 3, 51, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig refineClosureNodeScope = { { 1277 /* refineClosureNodeScope */, 10, 52, 10, 62, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig processImmediatelyCalledCallable = { { 1328 /* processImmediatelyCalledCallable */, 3, 63, 3, 66, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig processArrowFunctionNode = { { 1439 /* processArrowFunctionNode */, 7, 67, 9, 76, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig walkByRefInvocation = { { 1041 /* walkByRefInvocation */, 8, 36, 8, 44, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig processDeferredByRefClosureBody = { { 1077 /* processDeferredByRefClosureBody */, 6, 45, 6, 51, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig enterWithCapturedUses = { { 1128 /* enterWithCapturedUses */, 4, 52, 4, 56, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig assignByRefUses = { { 1157 /* assignByRefUses */, 3, 57, 3, 60, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig refineClosureNodeScope = { { 1314 /* refineClosureNodeScope */, 10, 61, 10, 71, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig processImmediatelyCalledCallable = { { 1365 /* processImmediatelyCalledCallable */, 3, 72, 3, 75, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig processArrowFunctionNode = { { 1476 /* processArrowFunctionNode */, 7, 76, 9, 85, ZEND_ACC_PUBLIC } };
 } // namespace sig
 
 } // namespace ptdecl::ClosureProcessor
diff --git a/turbo-ext/src/generated/ExpressionResultStorage.h b/turbo-ext/src/generated/ExpressionResultStorage.h
index 5aa8674d8fe..ca735826a60 100644
--- a/turbo-ext/src/generated/ExpressionResultStorage.h
+++ b/turbo-ext/src/generated/ExpressionResultStorage.h
@@ -12,6 +12,7 @@ namespace ptdecl::ExpressionResultStorage {
 namespace slot {
 inline constexpr uint32_t exprResults = 0;
 inline constexpr uint32_t fallback = 1;
+inline constexpr uint32_t byRefInvocationWalks = 2;
 } // namespace slot
 
 inline void declareClass(reg::Class &cls)
@@ -24,6 +25,7 @@ inline void declareProperties(reg::Class &cls)
 {
 	cls.property("exprResults", ZEND_ACC_PRIVATE, reg::PropertyKind::Typed, 0, "SplObjectStorage");
 	cls.property("fallback", ZEND_ACC_PRIVATE, reg::PropertyKind::TypedNull, MAY_BE_NULL, "PHPStan\\Analyser\\ExpressionResultStorage");
+	cls.property("byRefInvocationWalks", ZEND_ACC_PRIVATE, reg::PropertyKind::TypedNull, MAY_BE_NULL, "SplObjectStorage");
 }
 
 /* the string and parameter tables the signatures below index into (see reg::Sig) */
@@ -40,7 +42,12 @@ inline constexpr char strings[] =
 	"expressionResult\0" /* 108 */
 	"PHPStan\\Analyser\\ExpressionResult\0" /* 125 */
 	"storeExpressionResult\0" /* 159 */
-	"findExpressionResult"; /* 181 */
+	"findExpressionResult\0" /* 181 */
+	"closure\0" /* 202 */
+	"PhpParser\\Node\\Expr\\Closure\0" /* 210 */
+	"walk\0" /* 238 */
+	"storeByRefInvocationWalk\0" /* 243 */
+	"findByRefInvocationWalks"; /* 268 */
 inline constexpr reg::PackedArg args[] = {
 	reg::packed(12, 0, 13), /* duplicate return */
 	reg::packed(64, 0, 13), /* mergeResults $other */
@@ -50,6 +57,11 @@ inline constexpr reg::PackedArg args[] = {
 	reg::packed(12, MAY_BE_VOID), /* storeExpressionResult return */
 	reg::packed(83, 0, 88), /* findExpressionResult $expr */
 	reg::packed(12, MAY_BE_NULL, 125), /* findExpressionResult return */
+	reg::packed(202, 0, 210), /* storeByRefInvocationWalk $closure */
+	reg::packed(238, MAY_BE_ARRAY), /* storeByRefInvocationWalk $walk */
+	reg::packed(12, MAY_BE_VOID), /* storeByRefInvocationWalk return */
+	reg::packed(202, 0, 210), /* findByRefInvocationWalks $closure */
+	reg::packed(12, MAY_BE_ARRAY), /* findByRefInvocationWalks return */
 };
 using Sig = reg::Sig<strings, args>;
 } // namespace sigtab
@@ -61,6 +73,8 @@ inline constexpr sigtab::Sig duplicate = { { 54 /* duplicate */, 0, 0, 0, 0, ZEN
 inline constexpr sigtab::Sig mergeResults = { { 70 /* mergeResults */, 1, 1, 1, 2, ZEND_ACC_PUBLIC } };
 inline constexpr sigtab::Sig storeExpressionResult = { { 159 /* storeExpressionResult */, 2, 3, 2, 5, ZEND_ACC_PUBLIC } };
 inline constexpr sigtab::Sig findExpressionResult = { { 181 /* findExpressionResult */, 1, 6, 1, 7, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig storeByRefInvocationWalk = { { 243 /* storeByRefInvocationWalk */, 2, 8, 2, 10, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig findByRefInvocationWalks = { { 268 /* findByRefInvocationWalks */, 1, 11, 1, 12, ZEND_ACC_PUBLIC } };
 } // namespace sig
 
 } // namespace ptdecl::ExpressionResultStorage
diff --git a/turbo-ext/src/support.h b/turbo-ext/src/support.h
index 96cf47dd3b5..01a4d3f63a2 100644
--- a/turbo-ext/src/support.h
+++ b/turbo-ext/src/support.h
@@ -1556,6 +1556,10 @@ extern zend_class_entry *pt_ce_volatile_expression_helper;
 zv::Val pt_expression_result_storage_new();
 zv::Val pt_expression_result_storage_find(zval *storage, zval *expr);
 zv::Val pt_expression_result_storage_duplicate(zval *storage);
+/* ExpressionResultStorage::findByRefInvocationWalks() / storeByRefInvocationWalk()
+ * (false = pending exception) */
+zv::Val pt_expression_result_storage_find_by_ref_invocation_walks(zval *storage, zval *closure);
+[[nodiscard]] bool pt_expression_result_storage_store_by_ref_invocation_walk(zval *storage, zval *closure, zval *walk);
 /* the shadowing ExpressionResultStorageStack (ExpressionResultStorageStack.cpp)
  * — $stack->getCurrent(): the native body for a native stack, the method for
  * anything else; UNDEF = pending exception */
diff --git a/turbo-ext/tests/signature-parity.php b/turbo-ext/tests/signature-parity.php
index 0f10d7c642a..64ea91b8121 100644
--- a/turbo-ext/tests/signature-parity.php
+++ b/turbo-ext/tests/signature-parity.php
@@ -39,6 +39,7 @@
 	],
 	'PHPStan\\Analyser\\ExpressionResultStorage' => [
 		'~^property (exprResults is not declared natively|(exprsById|resultsById) is declared natively but not in PHP)$~' => 'the result table is two id-keyed arrays instead of the twin\'s SplObjectStorage',
+		'~^property (byRefInvocationWalks is not declared natively|byRefInvocationWalksById is declared natively but not in PHP)$~' => 'the by-ref invocation walks are an id-keyed array of [closure, walks] instead of the twin\'s SplObjectStorage',
 	],
 ];
 
diff --git a/turbo-ext/tests/smoke.php b/turbo-ext/tests/smoke.php
index cf60242c5f3..ee3479e68b4 100644
--- a/turbo-ext/tests/smoke.php
+++ b/turbo-ext/tests/smoke.php
@@ -378,6 +378,21 @@ function check(bool $cond, string $msg): void
 	check($storage->findExpressionResult($exprC) === null, "ERS $label: mergeResults ignores the other's fallback chain");
 	check($storage->findExpressionResult($exprA) === $resultB, "ERS $label: mergeResults keeps existing entries");
 
+	$closureA = new \PhpParser\Node\Expr\Closure();
+	$closureB = new \PhpParser\Node\Expr\Closure();
+	$walkA = [null, true, false, 'entryA', 'exitA', []];
+	$walkB = [null, false, false, 'entryB', 'exitB', []];
+	$walkC = [null, false, true, 'entryC', 'exitC', []];
+	$walks = new $storageClass();
+	check($walks->findByRefInvocationWalks($closureA) === [], "ERS $label: no by-ref walks stored");
+	$walks->storeByRefInvocationWalk($closureA, $walkA);
+	$walks->storeByRefInvocationWalk($closureA, $walkB);
+	check($walks->findByRefInvocationWalks($closureA) === [$walkA, $walkB], "ERS $label: by-ref walks in the order stored");
+	check($walks->findByRefInvocationWalks($closureB) === [], "ERS $label: by-ref walks are per closure");
+	$walksChild = $walks->duplicate();
+	$walksChild->storeByRefInvocationWalk($closureA, $walkC);
+	check($walksChild->findByRefInvocationWalks($closureA) === [$walkC, $walkA, $walkB], "ERS $label: own by-ref walks before the fallback chain's");
+	check($walks->findByRefInvocationWalks($closureA) === [$walkA, $walkB], "ERS $label: by-ref walks stored on a duplicate do not leak back");
 }
 
 

From 0e5c2643c138b113e14771d8d0351bfa6b61a643 Mon Sep 17 00:00:00 2001
From: Ondrej Mirtes <ondrej@mirtes.cz>
Date: Mon, 28 Sep 2026 11:38:53 +0200
Subject: [PATCH 4/9] Replay the last walk inferring static variables as the
 second pass

A body with `static` variables walked the statements from the first
`static` one until their types converged, and then once more in the second
pass with the converged types - which the last walk had just used. The
`Enum` trait's `static $cache` methods did it for every enum using it.

The last walk is made with the returned types and conditional expressions
on every way out of the loop. When the body observed no template argument
or closure signature (its constraints are empty - nothing to resolve, so a
walk that observes computes what one that does not observe computes) and no
closure or class follows the first `static` statement (the second pass
walks their bodies resolving their own template arguments), the second pass
replays that walk's recording and takes its results instead of walking.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y5roddukgqaSAB2BT765UX
---
 .../Generics/StaticVariableInference.php      |  57 ++++
 .../Generics/TemplateArgumentStats.php        |   1 +
 src/Analyser/StatementsHandler.php            |  90 ++++++-
 turbo-ext/src/StatementsHandler.cpp           | 112 +++++++-
 turbo-ext/src/StaticVariableInference.cpp     |  73 +++++
 turbo-ext/src/generated/StatementsHandler.h   | 252 ++++++++++--------
 .../src/generated/StaticVariableInference.h   |  95 ++++---
 turbo-ext/src/support.h                       |   1 +
 8 files changed, 513 insertions(+), 168 deletions(-)

diff --git a/src/Analyser/Generics/StaticVariableInference.php b/src/Analyser/Generics/StaticVariableInference.php
index e6b38e8e892..d7cb9ac1d57 100644
--- a/src/Analyser/Generics/StaticVariableInference.php
+++ b/src/Analyser/Generics/StaticVariableInference.php
@@ -46,6 +46,8 @@ final class StaticVariableInference
 
 	private const SITES_ATTRIBUTE = 'staticVariableInferenceSites';
 
+	private const LAST_FUNCTION_LIKE_ATTRIBUTE = 'staticVariableInferenceLastFunctionLike';
+
 	public function __construct(
 		private ReflectionProvider $reflectionProvider,
 		#[AutowiredParameter(ref: '%featureToggles.staticVariablesFromUsages%')]
@@ -79,6 +81,25 @@ public function getSites(Node $functionLike, array $stmts): array
 		return $sites;
 	}
 
+	/**
+	 * Whether a statement from $index on holds a closure, an arrow function or
+	 * a class: the walks inferring the `static` variables walk their bodies
+	 * without resolving template arguments, unlike the second pass.
+	 *
+	 * @param Node\Stmt[] $stmts
+	 */
+	public function hasFunctionLikeFrom(Node $functionLike, array $stmts, int $index): bool
+	{
+		/** @var int|null $last */
+		$last = $functionLike->getAttribute(self::LAST_FUNCTION_LIKE_ATTRIBUTE);
+		if ($last === null) {
+			$last = self::findLastFunctionLikeStatement($stmts);
+			$functionLike->setAttribute(self::LAST_FUNCTION_LIKE_ATTRIBUTE, $last);
+		}
+
+		return $last >= $index;
+	}
+
 	/** Whether the current walk infers the type of the `static` variable. */
 	public function isInferred(MutatingScope $scope, Expr\Variable $var): bool
 	{
@@ -297,6 +318,42 @@ private static function scanSites(array $stmts): array
 		return $sites;
 	}
 
+	/**
+	 * The index of the last statement holding a function-like or a class, -1
+	 * when none does.
+	 *
+	 * @param Node\Stmt[] $stmts
+	 */
+	private static function findLastFunctionLikeStatement(array $stmts): int
+	{
+		$last = -1;
+		foreach ($stmts as $index => $stmt) {
+			$stack = [$stmt];
+			while (count($stack) > 0) {
+				$node = array_pop($stack);
+				if ($node instanceof Node\FunctionLike || $node instanceof Node\Stmt\ClassLike) {
+					$last = $index;
+					break;
+				}
+				foreach ($node->getSubNodeNames() as $subNodeName) {
+					$subNode = $node->$subNodeName;
+					if ($subNode instanceof Node) {
+						$stack[] = $subNode;
+					} elseif (is_array($subNode)) {
+						foreach ($subNode as $item) {
+							if (!$item instanceof Node) {
+								continue;
+							}
+							$stack[] = $item;
+						}
+					}
+				}
+			}
+		}
+
+		return $last;
+	}
+
 	/**
 	 * @param array<string, true> $names
 	 */
diff --git a/src/Analyser/Generics/TemplateArgumentStats.php b/src/Analyser/Generics/TemplateArgumentStats.php
index 1ee422d6c02..89b20e386fd 100644
--- a/src/Analyser/Generics/TemplateArgumentStats.php
+++ b/src/Analyser/Generics/TemplateArgumentStats.php
@@ -58,6 +58,7 @@ final class TemplateArgumentStats
 		'closureObservationPasses' => 0,
 		'closureObservationStatements' => 0,
 		'closureObservationStatementsReplayed' => 0,
+		'staticVariableWalksReplayed' => 0,
 	];
 
 	public static function enableFromEnvironment(): void
diff --git a/src/Analyser/StatementsHandler.php b/src/Analyser/StatementsHandler.php
index 87e159c04b7..42ddc16f191 100644
--- a/src/Analyser/StatementsHandler.php
+++ b/src/Analyser/StatementsHandler.php
@@ -64,6 +64,15 @@
 final class StatementsHandler
 {
 
+	/** The last walk inferring the `static` variables walked a statement: [kind, recording from, recording to] */
+	private const STATIC_WALK_WALKED = 0;
+
+	/** It carried a statement's recorded effect over: [kind, statement index, 0] */
+	private const STATIC_WALK_CARRIED = 1;
+
+	/** It converged with the observation pass at a statement - the rest stands: [kind, statement index, 0] */
+	private const STATIC_WALK_REST = 2;
+
 	private const MENTIONED_VARIABLES_ATTRIBUTE = 'templateArgumentMentionedVariables';
 
 	/** PHPSTAN_TEMPLATE_ARGUMENTS_DEBUG=1 prints every second-pass re-walk/replay decision. */
@@ -584,16 +593,24 @@ private function processBodyStmtNodesTwoPass(
 		$staticVariableTypes = [];
 		$staticVariableConditionalExpressions = [];
 		$staticStatementIndexes = [];
+		$staticWalk = null;
 		if ($staticSites !== []) {
 			foreach ($staticSites as [, $index]) {
 				$staticStatementIndexes[$index] = true;
 			}
-			[$staticVariableTypes, $staticVariableConditionalExpressions, $constraints] = $this->inferStaticVariableTypes($nodeScopeResolver, $parentNode, $stmts, $staticSites, $staticStatementIndexes, $parentFrame, $entries, $recording, $storage, $observationContext);
+			[$staticVariableTypes, $staticVariableConditionalExpressions, $constraints, $staticWalk] = $this->inferStaticVariableTypes($nodeScopeResolver, $parentNode, $stmts, $staticSites, $staticStatementIndexes, $parentFrame, $entries, $recording, $storage, $observationContext);
 		}
 		$frame = $this->templateArgumentResolver->resolve($constraints, $parentFrame, $statementStartTokenPositions, $parentNode, $stmts);
 		if ($staticVariableTypes !== []) {
 			$frame = $frame->withStaticVariableTypes($staticVariableTypes, $staticStatementIndexes, $staticVariableConditionalExpressions);
 		}
+		if (
+			$staticWalk !== null
+			&& $constraints->isEmpty()
+			&& !$this->staticVariableInference->hasFunctionLikeFrom($parentNode, $stmts, $staticWalk[0])
+		) {
+			return $this->replayStaticVariableWalk($nodeScopeResolver, $stmts, $entries, $recording, $staticWalk, $frame, $parentFrame, $parentConstraints, $storage, $nodeCallback, $scope);
+		}
 		if ($frame->isObservingClosures()) {
 			$frame = $this->observeClosureSignatures($nodeScopeResolver, $parentNode, $stmts, $frame, $entries, $storage, $observationContext, $statementStartTokenPositions);
 		}
@@ -685,7 +702,8 @@ private function processBodyStmtNodesTwoPass(
 	 * statements that read a variable whose type changed - until the type at
 	 * each `static` statement holds every type the variable takes after it,
 	 * generalized like a loop's variables. The facts of the last walk are the
-	 * ones the template arguments and closure signatures are resolved from.
+	 * ones the template arguments and closure signatures are resolved from; the
+	 * walk itself is returned too, see replayStaticVariableWalk().
 	 *
 	 * The variables of a run of `static` statements (see
 	 * StaticVariableInference::getRuns()) hold one of the states a call left
@@ -697,7 +715,7 @@ private function processBodyStmtNodesTwoPass(
 	 * @param non-empty-list<array{Expr\Variable, int, string}> $staticSites
 	 * @param array<int, true> $staticStatementIndexes
 	 * @param array<int, array{StatementListWalkState, int}> $entries
-	 * @return array{array<int, array{Expr\Variable, Type, Type}>, array<int, array{Node\Stmt\Static_, array<string, ConditionalExpressionHolder[]>}>, TemplateArgumentConstraints}
+	 * @return array{array<int, array{Expr\Variable, Type, Type}>, array<int, array{Node\Stmt\Static_, array<string, ConditionalExpressionHolder[]>}>, TemplateArgumentConstraints, array{int, StatementListWalkState, RecordingNodeCallback, ExpressionResultStorage, list<array{int, int, int}>}}
 	 */
 	private function inferStaticVariableTypes(
 		NodeScopeResolver $nodeScopeResolver,
@@ -741,6 +759,8 @@ private function inferStaticVariableTypes(
 			$state->scope = $state->scope->withTemplateArgumentFrame($frame);
 			$walkStorage = $storage->duplicate();
 			$walkRecording = new RecordingNodeCallback();
+			/** @var list<array{int, int, int}> $walkLog see replayStaticVariableWalk() */
+			$walkLog = [];
 			/** @var list<MutatingScope> $replayedScopes */
 			$replayedScopes = [];
 			/** @var list<MutatingScope> $carriedOverScopes the entry scopes of the statements not walked again */
@@ -758,6 +778,7 @@ private function inferStaticVariableTypes(
 						// converged with the observation pass: the rest of it stands
 						$state->scope = $this->withRecordedConstraints($state->scope, $recordedEntry->scope, $entries[$stmtCount][0]->scope);
 						$this->appendRecordedStatementResults($state, $recordedEntry, $entries[$stmtCount][0]);
+						$walkLog[] = [self::STATIC_WALK_REST, $i, 0];
 						break;
 					}
 
@@ -768,13 +789,16 @@ private function inferStaticVariableTypes(
 						|| $frame->ownsSiteInStatement($i)
 						|| $this->statementMentionsAnyVariable($stmt, $differingRoots)
 					) {
+						$from = $walkRecording->count();
 						$this->processStatementStep($nodeScopeResolver, $parentNode, $stmts, $i, $stmt, $state, $walkStorage, $walkRecording, $context, true);
+						$walkLog[] = [self::STATIC_WALK_WALKED, $from, $walkRecording->count()];
 						$replayedScopes[] = $state->scope;
 						continue;
 					}
 
 					// the statement does not read what changed: the variables keep
 					// their types through it
+					$walkLog[] = [self::STATIC_WALK_CARRIED, $i, 0];
 					$replayedScopes[] = $state->scope;
 					$carriedOverScopes[] = $state->scope;
 					$recordedExit = $entries[$i + 1][0];
@@ -847,7 +871,65 @@ private function inferStaticVariableTypes(
 			$siteTypes[spl_object_id($var)] = [$var, $type, $nativeType];
 		}
 
-		return [$siteTypes, $conditionalExpressions, $constraints];
+		// every way out of the loop leaves the last walk made with the types
+		// and conditional expressions returned
+		return [$siteTypes, $conditionalExpressions, $constraints, [$start, $state, $walkRecording, $walkStorage, $walkLog]];
+	}
+
+	/**
+	 * The second pass of a body whose only sites are its `static` statements
+	 * and which observed no template argument or closure signature: it walks
+	 * the statements from the first `static` one with the resolved types, as
+	 * the last walk inferring them did - with no marker to resolve, a walk
+	 * that observes computes what one that does not observe computes. That
+	 * walk's recording and results stand for it. A closure or class in these
+	 * statements is walked differently by the second pass (resolving its own
+	 * template arguments), so the second pass walks those bodies itself.
+	 *
+	 * @param Node\Stmt[] $stmts
+	 * @param array<int, array{StatementListWalkState, int}> $entries
+	 * @param array{int, StatementListWalkState, RecordingNodeCallback, ExpressionResultStorage, list<array{int, int, int}>} $staticWalk
+	 * @param callable(Node $node, Scope $scope): void $nodeCallback
+	 */
+	private function replayStaticVariableWalk(
+		NodeScopeResolver $nodeScopeResolver,
+		array $stmts,
+		array $entries,
+		RecordingNodeCallback $recording,
+		array $staticWalk,
+		TemplateArgumentFrame $frame,
+		?TemplateArgumentFrame $parentFrame,
+		?TemplateArgumentConstraints $parentConstraints,
+		ExpressionResultStorage $storage,
+		callable $nodeCallback,
+		MutatingScope $scope,
+	): InternalStatementResult
+	{
+		[$start, $state, $walkRecording, $walkStorage, $walkLog] = $staticWalk;
+		$stmtCount = count($stmts);
+		if (TemplateArgumentStats::$enabled) {
+			TemplateArgumentStats::increment('bodiesWithSites');
+			TemplateArgumentStats::increment('staticVariableWalksReplayed');
+		}
+		$nodeScopeResolver->replayRecordingRange($recording, 0, $entries[$start][1], $nodeCallback, $storage, $scope);
+		$storage->mergeResults($walkStorage);
+		foreach ($walkLog as [$kind, $a, $b]) {
+			if ($kind === self::STATIC_WALK_WALKED) {
+				$nodeScopeResolver->replayRecordingRange($walkRecording, $a, $b, $nodeCallback, $storage, $scope);
+				continue;
+			}
+			if ($kind === self::STATIC_WALK_CARRIED) {
+				$nodeScopeResolver->replayRecordingRange($recording, $entries[$a][1], $entries[$a + 1][1], $nodeCallback, $storage, $scope);
+				continue;
+			}
+			$nodeScopeResolver->replayRecordingRange($recording, $entries[$a][1], $recording->count(), $nodeCallback, $storage, $scope);
+			// the recorded end scope, as the second pass takes it
+			$state->scope = $entries[$stmtCount][0]->scope;
+		}
+		$this->processDeferredByRefClosureBodies($nodeScopeResolver, $frame, $state, $storage, $nodeCallback);
+
+		$state->scope = $state->scope->withTemplateArgumentFrame($parentFrame)->withTemplateArgumentConstraints($parentConstraints);
+		return $state->toResult();
 	}
 
 	/**
diff --git a/turbo-ext/src/StatementsHandler.cpp b/turbo-ext/src/StatementsHandler.cpp
index cd0cbe3f9ba..520182d5a9f 100644
--- a/turbo-ext/src/StatementsHandler.cpp
+++ b/turbo-ext/src/StatementsHandler.cpp
@@ -48,6 +48,10 @@ zend_class_entry *pt_ce_statements_handler = nullptr;
 /* NodeScopeResolver::LOOP_SCOPE_ITERATIONS / ::GENERALIZE_AFTER_ITERATION */
 #define PT_SH_LOOP_SCOPE_ITERATIONS_LIMIT 3
 #define PT_SH_GENERALIZE_AFTER_ITERATION_LIMIT 1
+/* the twin's STATIC_WALK_* kinds of the last static-variable walk's log */
+#define PT_SH_STATIC_WALK_WALKED 0
+#define PT_SH_STATIC_WALK_CARRIED 1
+#define PT_SH_STATIC_WALK_REST 2
 
 namespace {
 
@@ -1391,6 +1395,7 @@ class StatementsHandler
 		zv::Val staticVariableTypes = zv::Val(zv::Arr::empty());
 		zv::Val staticVariableConditionalExpressions = zv::Val(zv::Arr::empty());
 		zv::Arr staticStatementIndexes = zv::Arr::empty();
+		zv::Val staticWalk = zv::Val::null();
 		if (staticSites.ref().isArray() && zend_hash_num_elements(Z_ARRVAL_P(staticSites.raw())) > 0) {
 			for (auto entry : zv::ArrRef(staticSites.raw())) {
 				zval *index = zend_hash_index_find(Z_ARRVAL_P(entry.value().deref().raw()), 1);
@@ -1405,6 +1410,7 @@ class StatementsHandler
 			staticVariableTypes = zv::Val::copyOf(zv::Ref(zend_hash_index_find(Z_ARRVAL_P(inferred.raw()), 0)));
 			staticVariableConditionalExpressions = zv::Val::copyOf(zv::Ref(zend_hash_index_find(Z_ARRVAL_P(inferred.raw()), 1)));
 			finalConstraints = zv::Val::copyOf(zv::Ref(zend_hash_index_find(Z_ARRVAL_P(inferred.raw()), 2)));
+			staticWalk = zv::Val::copyOf(zv::Ref(zend_hash_index_find(Z_ARRVAL_P(inferred.raw()), 3)));
 		}
 		zv::Val frame = templateArgumentResolverResolve(OBJ_PROP_NUM(self, slots::templateArgumentResolver), finalConstraints.raw(), parentFrame.raw(), statementStartTokenPositions.raw(), parentNode, stmts);
 		if (UNEXPECTED(frame.isUndef())) return zv::Val();
@@ -1412,6 +1418,18 @@ class StatementsHandler
 			frame = pt_template_argument_frame_with_static_variable_types(frame.raw(), staticVariableTypes.raw(), staticStatementIndexes.raw(), staticVariableConditionalExpressions.raw());
 			if (UNEXPECTED(frame.isUndef())) return zv::Val();
 		}
+		if (staticWalk.ref().isArray()) {
+			bool constraintsEmpty;
+			if (UNEXPECTED(!pt_template_argument_constraints_is_empty(finalConstraints.raw(), constraintsEmpty))) return zv::Val();
+			if (constraintsEmpty) {
+				bool hasFunctionLike;
+				zend_long start = zval_get_long(zend_hash_index_find(Z_ARRVAL_P(staticWalk.raw()), 0));
+				if (UNEXPECTED(!pt_static_variable_inference_has_function_like_from(OBJ_PROP_NUM(self, slots::staticVariableInference), parentNode, stmts, start, hasFunctionLike))) return zv::Val();
+				if (!hasFunctionLike) {
+					return replayStaticVariableWalk(nodeScopeResolver, stmts, entries.raw(), recording.raw(), staticWalk.raw(), frame.raw(), parentFrame.raw(), parentConstraints.raw(), storage, nodeCallback, scope.raw(), statsEnabled);
+				}
+			}
+		}
 		{
 			bool observingClosures;
 			if (UNEXPECTED(!pt_template_argument_frame_is_observing_closures(frame.raw(), observingClosures))) return zv::Val();
@@ -1635,6 +1653,7 @@ class StatementsHandler
 		zend_long count = 0;
 		zend_long conditionalExpressionsCount = 0;
 		zv::Val constraints;
+		zv::Val lastWalk;
 		for (;;) {
 			zv::Val siteTypes = staticSiteTypes(staticSites, types.raw());
 			if (UNEXPECTED(siteTypes.isUndef())) return zv::Val();
@@ -1659,6 +1678,7 @@ class StatementsHandler
 			if (UNEXPECTED(walkRecording.isUndef())) return zv::Val();
 			zv::Arr replayedScopes = zv::Arr::empty();
 			zv::Arr carriedOverScopes = zv::Arr::empty();
+			zv::Arr walkLog = zv::Arr::empty();
 			zv::Val suspendedGatherers = pt_node_scope_resolver_suspend_node_gatherers(nodeScopeResolver);
 			if (UNEXPECTED(suspendedGatherers.isUndef())) return zv::Val();
 			zv::Val pushedScope = zv::Val::copyOf(zv::Ref(OBJ_PROP_NUM(Z_OBJ_P(state.raw()), stateSlots::scope)));
@@ -1666,7 +1686,7 @@ class StatementsHandler
 				(void) pt_node_scope_resolver_restore_node_gatherers(nodeScopeResolver, suspendedGatherers.raw());
 				return zv::Val();
 			}
-			(void) observeStaticVariablesFrom(nodeScopeResolver, parentNode, stmts, stmtsTable, frame.raw(), entries, state.raw(), walkStorage.raw(), walkRecording.raw(), context, start, stmtCount, hasLabels, replayedScopes, carriedOverScopes);
+			(void) observeStaticVariablesFrom(nodeScopeResolver, parentNode, stmts, stmtsTable, frame.raw(), entries, state.raw(), walkStorage.raw(), walkRecording.raw(), context, start, stmtCount, hasLabels, replayedScopes, carriedOverScopes, walkLog);
 			pt_finally([&]() {
 				(void) pt_mutating_scope_pop_expression_result_storage(Z_OBJ_P(pushedScope.raw()));
 				(void) pt_node_scope_resolver_restore_node_gatherers(nodeScopeResolver, suspendedGatherers.raw());
@@ -1680,6 +1700,15 @@ class StatementsHandler
 				constraints = templateArgumentConstraintsCreateEmpty();
 				if (UNEXPECTED(constraints.isUndef())) return zv::Val();
 			}
+			{
+				zv::Arr walk = zv::Arr::create(5);
+				walk.push(zv::Val::integer(start));
+				walk.push(zv::Val::copyOf(zv::Ref(state.raw())));
+				walk.push(zv::Val::copyOf(zv::Ref(walkRecording.raw())));
+				walk.push(zv::Val::copyOf(zv::Ref(walkStorage.raw())));
+				walk.push(std::move(walkLog));
+				lastWalk = zv::Val(std::move(walk));
+			}
 
 			zv::Val walkTypes = collectStaticVariableTypes(bodyScope.raw(), names.raw(), walkRecording.raw(), state.raw(), replayedScopes.raw());
 			if (UNEXPECTED(walkTypes.isUndef())) return zv::Val();
@@ -1744,18 +1773,82 @@ class StatementsHandler
 
 		zv::Val siteTypes = staticSiteTypes(staticSites, types.raw());
 		if (UNEXPECTED(siteTypes.isUndef())) return zv::Val();
-		zv::Arr result = zv::Arr::create(3);
+		// every way out of the loop leaves the last walk made with the types
+		// and conditional expressions returned
+		zv::Arr result = zv::Arr::create(4);
 		result.push(std::move(siteTypes));
 		result.push(std::move(conditionalExpressions));
 		result.push(std::move(constraints));
+		result.push(std::move(lastWalk));
 		return zv::Val(std::move(result));
 	}
 
+	/* [kind, a, b] of the last static-variable walk's log */
+	static zv::Val staticWalkLogEntry(zend_long kind, zend_long a, zend_long b)
+	{
+		zv::Arr entry = zv::Arr::create(3);
+		entry.push(zv::Val::integer(kind));
+		entry.push(zv::Val::integer(a));
+		entry.push(zv::Val::integer(b));
+		return zv::Val(std::move(entry));
+	}
+
+	/* Mirrors the private replayStaticVariableWalk() */
+	zv::Val replayStaticVariableWalk(zval *nodeScopeResolver, zval *stmts, zval *entries, zval *recording, zval *staticWalk, zval *frame, zval *parentFrame, zval *parentConstraints, zval *storage, zval *nodeCallback, zval *scope, bool statsEnabled)
+	{
+		HashTable *walk = Z_ARRVAL_P(staticWalk);
+		zend_long start = zval_get_long(zend_hash_index_find(walk, 0));
+		zval *state = zend_hash_index_find(walk, 1);
+		zval *walkRecording = zend_hash_index_find(walk, 2);
+		zval *walkStorage = zend_hash_index_find(walk, 3);
+		zval *walkLog = zend_hash_index_find(walk, 4);
+		if (UNEXPECTED(state == NULL || walkRecording == NULL || walkStorage == NULL || walkLog == NULL)) return zv::Val();
+		zend_long stmtCount = zend_hash_num_elements(Z_ARRVAL_P(stmts));
+		if (statsEnabled) {
+			if (UNEXPECTED(!templateArgumentStatsIncrement(PT_LC("bodiesWithSites"), 1))) return zv::Val();
+			if (UNEXPECTED(!templateArgumentStatsIncrement(PT_LC("staticVariableWalksReplayed"), 1))) return zv::Val();
+		}
+		zval *startEntry = entryAt(entries, start);
+		if (UNEXPECTED(startEntry == NULL)) return zv::Val();
+		if (UNEXPECTED(!pt_node_scope_resolver_replay_recording_range(nodeScopeResolver, recording, 0, zval_get_long(entryOffset(startEntry)), nodeCallback, storage, scope))) return zv::Val();
+		if (UNEXPECTED(!pt_expression_result_storage_merge_results(storage, walkStorage))) return zv::Val();
+		zv::Val stateHold = zv::Val::copyOf(zv::Ref(state));
+		zv::Val logHold = zv::Val::copyOf(zv::Ref(walkLog));
+		for (zv::ArrayEntry entry : zv::ArrRef(logHold.raw())) {
+			HashTable *op = Z_ARRVAL_P(entry.value().deref().raw());
+			zend_long kind = zval_get_long(zend_hash_index_find(op, 0));
+			zend_long a = zval_get_long(zend_hash_index_find(op, 1));
+			zend_long b = zval_get_long(zend_hash_index_find(op, 2));
+			if (kind == PT_SH_STATIC_WALK_WALKED) {
+				if (UNEXPECTED(!pt_node_scope_resolver_replay_recording_range(nodeScopeResolver, walkRecording, a, b, nodeCallback, storage, scope))) return zv::Val();
+				continue;
+			}
+			zval *entryPair = entryAt(entries, a);
+			if (UNEXPECTED(entryPair == NULL)) return zv::Val();
+			if (kind == PT_SH_STATIC_WALK_CARRIED) {
+				zval *exitPair = entryAt(entries, a + 1);
+				if (UNEXPECTED(exitPair == NULL)) return zv::Val();
+				if (UNEXPECTED(!pt_node_scope_resolver_replay_recording_range(nodeScopeResolver, recording, zval_get_long(entryOffset(entryPair)), zval_get_long(entryOffset(exitPair)), nodeCallback, storage, scope))) return zv::Val();
+				continue;
+			}
+			zend_long recorded;
+			if (UNEXPECTED(!recordingNodeCallbackCount(recording, recorded))) return zv::Val();
+			if (UNEXPECTED(!pt_node_scope_resolver_replay_recording_range(nodeScopeResolver, recording, zval_get_long(entryOffset(entryPair)), recorded, nodeCallback, storage, scope))) return zv::Val();
+			// the recorded end scope, as the second pass takes it
+			zval *finalPair = entryAt(entries, stmtCount);
+			if (UNEXPECTED(finalPair == NULL)) return zv::Val();
+			zv::Ref(OBJ_PROP_NUM(Z_OBJ_P(stateHold.raw()), stateSlots::scope)).assign(zv::Val::copyOf(zv::Ref(OBJ_PROP_NUM(Z_OBJ_P(entryState(finalPair)), stateSlots::scope))));
+		}
+		if (UNEXPECTED(!processDeferredByRefClosureBodies(nodeScopeResolver, frame, stateHold.raw(), storage, nodeCallback))) return zv::Val();
+		if (UNEXPECTED(!restoreParentFrame(stateHold.raw(), parentFrame, parentConstraints))) return zv::Val();
+		return pt_statement_list_walk_state_to_result(stateHold.raw());
+	}
+
 	/* inferStaticVariableTypes()'s try block: the statements from $start on,
 	 * walked or carried over, each walked exit scope and carried-over entry
 	 * scope into $replayedScopes, each carried-over entry scope into
 	 * $carriedOverScopes; false = pending exception */
-	bool observeStaticVariablesFrom(zval *nodeScopeResolver, zval *parentNode, zval *stmts, HashTable *stmtsTable, zval *frame, zval *entries, zval *state, zval *storage, zval *nodeCallback, zval *context, zend_long start, zend_long stmtCount, bool hasLabels, zv::Arr &replayedScopes, zv::Arr &carriedOverScopes)
+	bool observeStaticVariablesFrom(zval *nodeScopeResolver, zval *parentNode, zval *stmts, HashTable *stmtsTable, zval *frame, zval *entries, zval *state, zval *storage, zval *nodeCallback, zval *context, zend_long start, zend_long stmtCount, bool hasLabels, zv::Arr &replayedScopes, zv::Arr &carriedOverScopes, zv::Arr &walkLog)
 	{
 		for (zend_long i = start; i < stmtCount; i++) {
 			zval *recordedEntryPair = entryAt(entries, i);
@@ -1781,7 +1874,9 @@ class StatementsHandler
 					zv::Val carried = withRecordedConstraints(OBJ_PROP_NUM(stateObject, stateSlots::scope), OBJ_PROP_NUM(recordedEntryObject, stateSlots::scope), OBJ_PROP_NUM(Z_OBJ_P(finalState), stateSlots::scope));
 					if (UNEXPECTED(carried.isUndef())) return false;
 					zv::Ref(OBJ_PROP_NUM(stateObject, stateSlots::scope)).assign(std::move(carried));
-					return appendRecordedStatementResults(state, recordedEntry, finalState);
+					if (UNEXPECTED(!appendRecordedStatementResults(state, recordedEntry, finalState))) return false;
+					walkLog.push(staticWalkLogEntry(PT_SH_STATIC_WALK_REST, i, 0));
+					return true;
 				}
 			}
 
@@ -1795,13 +1890,19 @@ class StatementsHandler
 			if (!reWalk && UNEXPECTED(!frameOwnsSiteInStatement(frame, i, reWalk))) return false;
 			if (!reWalk && UNEXPECTED(!statementMentionsAnyVariable(stmt, differingRoots.raw(), reWalk))) return false;
 			if (reWalk) {
+				zend_long from;
+				if (UNEXPECTED(!recordingNodeCallbackCount(nodeCallback, from))) return false;
 				if (UNEXPECTED(!processStatementStep(nodeScopeResolver, parentNode, stmts, i, stmt, state, storage, nodeCallback, context, true))) return false;
+				zend_long to;
+				if (UNEXPECTED(!recordingNodeCallbackCount(nodeCallback, to))) return false;
+				walkLog.push(staticWalkLogEntry(PT_SH_STATIC_WALK_WALKED, from, to));
 				replayedScopes.push(zv::Ref(OBJ_PROP_NUM(Z_OBJ_P(state), stateSlots::scope)));
 				continue;
 			}
 
 			// the statement does not read what changed: the variables keep
 			// their types through it
+			walkLog.push(staticWalkLogEntry(PT_SH_STATIC_WALK_CARRIED, i, 0));
 			replayedScopes.push(zv::Ref(OBJ_PROP_NUM(Z_OBJ_P(state), stateSlots::scope)));
 			carriedOverScopes.push(zv::Ref(OBJ_PROP_NUM(Z_OBJ_P(state), stateSlots::scope)));
 			zval *recordedExitPair = entryAt(entries, i + 1);
@@ -3075,6 +3176,9 @@ PT_MINIT_REGISTRATION(pt_register_statements_handler)
 {
 	reg::Class cls("PHPStan\\Analyser\\StatementsHandler");
 	ptdecl::StatementsHandler::declareClass(cls);
+	cls.privateClassConstantLong("STATIC_WALK_WALKED", PT_SH_STATIC_WALK_WALKED);
+	cls.privateClassConstantLong("STATIC_WALK_CARRIED", PT_SH_STATIC_WALK_CARRIED);
+	cls.privateClassConstantLong("STATIC_WALK_REST", PT_SH_STATIC_WALK_REST);
 	cls.privateClassConstantString("MENTIONED_VARIABLES_ATTRIBUTE", "templateArgumentMentionedVariables");
 	ptdecl::StatementsHandler::declareProperties(cls);
 
diff --git a/turbo-ext/src/StaticVariableInference.cpp b/turbo-ext/src/StaticVariableInference.cpp
index 695acf66ba4..7f7d38f6c4a 100644
--- a/turbo-ext/src/StaticVariableInference.cpp
+++ b/turbo-ext/src/StaticVariableInference.cpp
@@ -29,6 +29,8 @@ namespace {
 
 /* the twin's SITES_ATTRIBUTE, a permanent interned string (module startup) */
 zend_string *pt_svi_sites_attribute = nullptr;
+/* the twin's LAST_FUNCTION_LIKE_ATTRIBUTE, a permanent interned string (module startup) */
+zend_string *pt_svi_last_function_like_attribute = nullptr;
 
 pt_method_site pt_svi_get_sub_node_names_site;
 pt_method_site pt_svi_to_lower_string_site;
@@ -325,6 +327,32 @@ zv::Val scanSites(zval *stmts)
 	return zv::Val(std::move(sites));
 }
 
+/* Mirrors the private static findLastFunctionLikeStatement(); false =
+ * pending exception */
+[[nodiscard]] bool findLastFunctionLikeStatement(zval *stmts, zend_long &last)
+{
+	last = -1;
+	if (Z_TYPE_P(stmts) != IS_ARRAY) return true;
+	for (auto stmtEntry : zv::ArrRef(stmts)) {
+		zend_long index = stmtEntry.stringKeyOrNull() == NULL ? (zend_long) stmtEntry.indexKey() : 0;
+		zv::Arr stack = zv::Arr::create(0);
+		stack.push(zv::Val::copyOf(stmtEntry.value().deref()));
+		for (;;) {
+			zv::Val node = popNode(stack);
+			if (node.isUndef()) break;
+			bool is;
+			if (UNEXPECTED(!isA(node.raw(), PT_CLASS_FUNCTION_LIKE, is))) return false;
+			if (!is && UNEXPECTED(!isA(node.raw(), PT_CLASS_CLASS_LIKE_STMT, is))) return false;
+			if (is) {
+				last = index;
+				break;
+			}
+			if (UNEXPECTED(!pushSubNodes(node.raw(), stack))) return false;
+		}
+	}
+	return true;
+}
+
 } // namespace
 
 namespace phpstanturbo {
@@ -360,6 +388,24 @@ class StaticVariableInference
 		return sites;
 	}
 
+	/* Mirrors hasFunctionLikeFrom(); false = pending exception */
+	[[nodiscard]] bool hasFunctionLikeFrom(zval *functionLike, zval *stmts, zend_long index, bool &out) const
+	{
+		zv::Val cached = pt_engine_node_get_attribute(Z_OBJ_P(functionLike), ZSTR_VAL(pt_svi_last_function_like_attribute), ZSTR_LEN(pt_svi_last_function_like_attribute));
+		if (UNEXPECTED(cached.isUndef())) return false;
+		zend_long last;
+		if (cached.isNull()) {
+			if (UNEXPECTED(!findLastFunctionLikeStatement(stmts, last))) return false;
+			zval lastZv;
+			ZVAL_LONG(&lastZv, last);
+			if (UNEXPECTED(!pt_engine_node_set_attribute(Z_OBJ_P(functionLike), ZSTR_VAL(pt_svi_last_function_like_attribute), ZSTR_LEN(pt_svi_last_function_like_attribute), &lastZv))) return false;
+		} else {
+			last = zval_get_long(cached.raw());
+		}
+		out = last >= index;
+		return true;
+	}
+
 	/* Mirrors isInferred(); false = pending exception */
 	[[nodiscard]] bool isInferred(zval *scope, zval *var, bool &out) const
 	{
@@ -546,6 +592,18 @@ zv::Val pt_static_variable_inference_get_sites(zval *inference, zval *functionLi
 	return pt_type_call(Z_OBJ_P(inference), PT_LC("getsites"), 2, argv);
 }
 
+bool pt_static_variable_inference_has_function_like_from(zval *inference, zval *functionLike, zval *stmts, zend_long index, bool &out)
+{
+	if (isNative(inference)) return StaticVariableInference(Z_OBJ_P(inference)).hasFunctionLikeFrom(functionLike, stmts, index, out);
+	zval indexZv;
+	ZVAL_LONG(&indexZv, index);
+	zv::Args argv{functionLike, stmts, &indexZv};
+	zv::Val result = pt_type_call(Z_OBJ_P(inference), PT_LC("hasfunctionlikefrom"), 3, argv);
+	if (UNEXPECTED(result.isUndef())) return false;
+	out = zend_is_true(result.raw());
+	return true;
+}
+
 bool pt_static_variable_inference_is_inferred(zval *inference, zval *scope, zval *var, bool &out)
 {
 	if (isNative(inference)) return StaticVariableInference(Z_OBJ_P(inference)).isInferred(scope, var, out);
@@ -596,11 +654,13 @@ bool pt_static_variable_inference_can_run_user_code(zval *inference, zval *node,
 PT_MINIT_REGISTRATION(pt_register_static_variable_inference)
 {
 	pt_svi_sites_attribute = zend_string_init_interned(PT_LC("staticVariableInferenceSites"), 1);
+	pt_svi_last_function_like_attribute = zend_string_init_interned(PT_LC("staticVariableInferenceLastFunctionLike"), 1);
 
 	reg::Class cls("PHPStan\\Analyser\\Generics\\StaticVariableInference");
 	ptdecl::StaticVariableInference::declareClass(cls);
 	ptdecl::StaticVariableInference::declareProperties(cls);
 	cls.privateClassConstantString("SITES_ATTRIBUTE", "staticVariableInferenceSites");
+	cls.privateClassConstantString("LAST_FUNCTION_LIKE_ATTRIBUTE", "staticVariableInferenceLastFunctionLike");
 
 	/* the real parameter types: the DI container autowires the service by
 	 * reflecting the constructor */
@@ -646,6 +706,19 @@ PT_MINIT_REGISTRATION(pt_register_static_variable_inference)
 		PT_RETURN_VAL(StaticVariableInference(Z_OBJ_P(ZEND_THIS)).getSites(functionLike, stmts));
 	});
 
+	cls.method(sigs::hasFunctionLikeFrom, [](INTERNAL_FUNCTION_PARAMETERS) {
+		zval *functionLike, *stmts;
+		zend_long index;
+		ZEND_PARSE_PARAMETERS_START(3, 3)
+			Z_PARAM_OBJECT(functionLike)
+			Z_PARAM_ARRAY(stmts)
+			Z_PARAM_LONG(index)
+		ZEND_PARSE_PARAMETERS_END();
+		bool out;
+		if (UNEXPECTED(!StaticVariableInference(Z_OBJ_P(ZEND_THIS)).hasFunctionLikeFrom(functionLike, stmts, index, out))) RETURN_THROWS();
+		RETURN_BOOL(out);
+	});
+
 	cls.method(sigs::isInferred, [](INTERNAL_FUNCTION_PARAMETERS) {
 		zval *scope, *var;
 		if (!zp::parse<zp::Obj, zp::Obj>(execute_data, scope, var)) RETURN_THROWS();
diff --git a/turbo-ext/src/generated/StatementsHandler.h b/turbo-ext/src/generated/StatementsHandler.h
index 45e6a03a74b..804e3ef1442 100644
--- a/turbo-ext/src/generated/StatementsHandler.h
+++ b/turbo-ext/src/generated/StatementsHandler.h
@@ -100,58 +100,61 @@ inline constexpr char strings[] =
 	"recording\0" /* 1242 */
 	"PHPStan\\Analyser\\RecordingNodeCallback\0" /* 1252 */
 	"inferStaticVariableTypes\0" /* 1291 */
-	"bodyScope\0" /* 1316 */
-	"endState\0" /* 1326 */
-	"moreScopes\0" /* 1335 */
-	"collectStaticVariableScopes\0" /* 1346 */
-	"collectStaticVariableStateScopes\0" /* 1374 */
-	"names\0" /* 1407 */
-	"scopes\0" /* 1413 */
-	"collectStaticVariableTypes\0" /* 1420 */
-	"runs\0" /* 1447 */
-	"types\0" /* 1452 */
-	"walkedConditionalExpressions\0" /* 1458 */
-	"enteredTypes\0" /* 1487 */
-	"collectStaticVariableConditionalExpressions\0" /* 1500 */
-	"isWalkedStaticVariableState\0" /* 1544 */
-	"a\0" /* 1572 */
-	"b\0" /* 1574 */
-	"equalStaticVariableStates\0" /* 1576 */
-	"equalStaticVariableConditionalExpressions\0" /* 1602 */
-	"PHPStan\\Analyser\\ConditionalExpressionHolder\0" /* 1644 */
-	"equalConditionalExpressionHolders\0" /* 1689 */
-	"walkTypes\0" /* 1723 */
-	"generalize\0" /* 1733 */
-	"joinStaticVariableTypes\0" /* 1744 */
-	"PHPStan\\Analyser\\ClosureProcessor\0" /* 1768 */
-	"getClosureProcessor\0" /* 1802 */
-	"frame\0" /* 1822 */
-	"processDeferredByRefClosureBodies\0" /* 1828 */
-	"statementStartTokenPositions\0" /* 1862 */
-	"observeClosureSignatures\0" /* 1891 */
-	"recordedEntry\0" /* 1916 */
-	"recordedExit\0" /* 1930 */
-	"withRecordedConstraints\0" /* 1943 */
-	"containsLabels\0" /* 1967 */
-	"from\0" /* 1982 */
-	"to\0" /* 1987 */
-	"appendRecordedStatementResults\0" /* 1990 */
-	"PHPStan\\Analyser\\VariableFlow\0" /* 2021 */
-	"getVariableMentionFlow\0" /* 2051 */
-	"variableNames\0" /* 2074 */
-	"statementMentionsAnyVariable\0" /* 2088 */
-	"node\0" /* 2117 */
-	"mentionsEverything\0" /* 2122 */
-	"collectMentionedVariables\0" /* 2141 */
-	"statement\0" /* 2167 */
-	"getOverridingThrowPoints\0" /* 2177 */
-	"defaultExpr\0" /* 2202 */
-	"PhpParser\\Node\\Expr\0" /* 2214 */
-	"processStmtVarAnnotation\0" /* 2234 */
-	"PHPStan\\PhpDoc\\Tag\\VarTag\0" /* 2259 */
-	"findSingleVariableLessVarTag\0" /* 2285 */
-	"PHPStan\\Analyser\\Generics\\TemplateArgumentConstraints\0" /* 2314 */
-	"emitVarTagChangedNode"; /* 2368 */
+	"staticWalk\0" /* 1316 */
+	"frame\0" /* 1327 */
+	"parentConstraints\0" /* 1333 */
+	"PHPStan\\Analyser\\Generics\\TemplateArgumentConstraints\0" /* 1351 */
+	"replayStaticVariableWalk\0" /* 1405 */
+	"bodyScope\0" /* 1430 */
+	"endState\0" /* 1440 */
+	"moreScopes\0" /* 1449 */
+	"collectStaticVariableScopes\0" /* 1460 */
+	"collectStaticVariableStateScopes\0" /* 1488 */
+	"names\0" /* 1521 */
+	"scopes\0" /* 1527 */
+	"collectStaticVariableTypes\0" /* 1534 */
+	"runs\0" /* 1561 */
+	"types\0" /* 1566 */
+	"walkedConditionalExpressions\0" /* 1572 */
+	"enteredTypes\0" /* 1601 */
+	"collectStaticVariableConditionalExpressions\0" /* 1614 */
+	"isWalkedStaticVariableState\0" /* 1658 */
+	"a\0" /* 1686 */
+	"b\0" /* 1688 */
+	"equalStaticVariableStates\0" /* 1690 */
+	"equalStaticVariableConditionalExpressions\0" /* 1716 */
+	"PHPStan\\Analyser\\ConditionalExpressionHolder\0" /* 1758 */
+	"equalConditionalExpressionHolders\0" /* 1803 */
+	"walkTypes\0" /* 1837 */
+	"generalize\0" /* 1847 */
+	"joinStaticVariableTypes\0" /* 1858 */
+	"PHPStan\\Analyser\\ClosureProcessor\0" /* 1882 */
+	"getClosureProcessor\0" /* 1916 */
+	"processDeferredByRefClosureBodies\0" /* 1936 */
+	"statementStartTokenPositions\0" /* 1970 */
+	"observeClosureSignatures\0" /* 1999 */
+	"recordedEntry\0" /* 2024 */
+	"recordedExit\0" /* 2038 */
+	"withRecordedConstraints\0" /* 2051 */
+	"containsLabels\0" /* 2075 */
+	"from\0" /* 2090 */
+	"to\0" /* 2095 */
+	"appendRecordedStatementResults\0" /* 2098 */
+	"PHPStan\\Analyser\\VariableFlow\0" /* 2129 */
+	"getVariableMentionFlow\0" /* 2159 */
+	"variableNames\0" /* 2182 */
+	"statementMentionsAnyVariable\0" /* 2196 */
+	"node\0" /* 2225 */
+	"mentionsEverything\0" /* 2230 */
+	"collectMentionedVariables\0" /* 2249 */
+	"statement\0" /* 2275 */
+	"getOverridingThrowPoints\0" /* 2285 */
+	"defaultExpr\0" /* 2310 */
+	"PhpParser\\Node\\Expr\0" /* 2322 */
+	"processStmtVarAnnotation\0" /* 2342 */
+	"PHPStan\\PhpDoc\\Tag\\VarTag\0" /* 2367 */
+	"findSingleVariableLessVarTag\0" /* 2393 */
+	"emitVarTagChangedNode"; /* 2422 */
 inline constexpr reg::PackedArg args[] = {
 	reg::packed(0, 0, 15), /* __construct $fileTypeMapper */
 	reg::packed(43, 0, 68), /* __construct $templateArgumentObserver */
@@ -229,49 +232,61 @@ inline constexpr reg::PackedArg args[] = {
 	reg::packed(592, 0, 477), /* inferStaticVariableTypes $storage */
 	reg::packed(600, 0, 608), /* inferStaticVariableTypes $context */
 	reg::packed(531, MAY_BE_ARRAY), /* inferStaticVariableTypes return */
-	reg::packed(1316, 0, 422), /* collectStaticVariableScopes $bodyScope */
+	reg::packed(357, 0, 375), /* replayStaticVariableWalk $nodeScopeResolver */
+	reg::packed(865, MAY_BE_ARRAY), /* replayStaticVariableWalk $stmts */
+	reg::packed(1234, MAY_BE_ARRAY), /* replayStaticVariableWalk $entries */
+	reg::packed(1242, 0, 1252), /* replayStaticVariableWalk $recording */
+	reg::packed(1316, MAY_BE_ARRAY), /* replayStaticVariableWalk $staticWalk */
+	reg::packed(1327, 0, 1186), /* replayStaticVariableWalk $frame */
+	reg::packed(1174, MAY_BE_NULL, 1186), /* replayStaticVariableWalk $parentFrame */
+	reg::packed(1333, MAY_BE_NULL, 1351), /* replayStaticVariableWalk $parentConstraints */
+	reg::packed(592, 0, 477), /* replayStaticVariableWalk $storage */
+	reg::packed(518, MAY_BE_CALLABLE), /* replayStaticVariableWalk $nodeCallback */
+	reg::packed(416, 0, 422), /* replayStaticVariableWalk $scope */
+	reg::packed(531, 0, 871), /* replayStaticVariableWalk return */
+	reg::packed(1430, 0, 422), /* collectStaticVariableScopes $bodyScope */
 	reg::packed(1242, 0, 1252), /* collectStaticVariableScopes $recording */
-	reg::packed(1326, 0, 964), /* collectStaticVariableScopes $endState */
-	reg::packed(1335, MAY_BE_ARRAY), /* collectStaticVariableScopes $moreScopes */
+	reg::packed(1440, 0, 964), /* collectStaticVariableScopes $endState */
+	reg::packed(1449, MAY_BE_ARRAY), /* collectStaticVariableScopes $moreScopes */
 	reg::packed(531, MAY_BE_ARRAY), /* collectStaticVariableScopes return */
-	reg::packed(1316, 0, 422), /* collectStaticVariableStateScopes $bodyScope */
+	reg::packed(1430, 0, 422), /* collectStaticVariableStateScopes $bodyScope */
 	reg::packed(1242, 0, 1252), /* collectStaticVariableStateScopes $recording */
-	reg::packed(1326, 0, 964), /* collectStaticVariableStateScopes $endState */
-	reg::packed(1335, MAY_BE_ARRAY), /* collectStaticVariableStateScopes $moreScopes */
+	reg::packed(1440, 0, 964), /* collectStaticVariableStateScopes $endState */
+	reg::packed(1449, MAY_BE_ARRAY), /* collectStaticVariableStateScopes $moreScopes */
 	reg::packed(531, MAY_BE_ARRAY), /* collectStaticVariableStateScopes return */
-	reg::packed(1407, MAY_BE_ARRAY), /* collectStaticVariableTypes $names */
-	reg::packed(1413, MAY_BE_ARRAY), /* collectStaticVariableTypes $scopes */
+	reg::packed(1521, MAY_BE_ARRAY), /* collectStaticVariableTypes $names */
+	reg::packed(1527, MAY_BE_ARRAY), /* collectStaticVariableTypes $scopes */
 	reg::packed(531, MAY_BE_ARRAY), /* collectStaticVariableTypes return */
-	reg::packed(1447, MAY_BE_ARRAY), /* collectStaticVariableConditionalExpressions $runs */
-	reg::packed(1413, MAY_BE_ARRAY), /* collectStaticVariableConditionalExpressions $scopes */
+	reg::packed(1561, MAY_BE_ARRAY), /* collectStaticVariableConditionalExpressions $runs */
+	reg::packed(1527, MAY_BE_ARRAY), /* collectStaticVariableConditionalExpressions $scopes */
 	reg::packed(592, 0, 477), /* collectStaticVariableConditionalExpressions $storage */
-	reg::packed(1452, MAY_BE_NULL | MAY_BE_ARRAY), /* collectStaticVariableConditionalExpressions $types */
-	reg::packed(1458, MAY_BE_ARRAY), /* collectStaticVariableConditionalExpressions $walkedConditionalExpressions */
-	reg::packed(1487, MAY_BE_ARRAY), /* collectStaticVariableConditionalExpressions $enteredTypes */
+	reg::packed(1566, MAY_BE_NULL | MAY_BE_ARRAY), /* collectStaticVariableConditionalExpressions $types */
+	reg::packed(1572, MAY_BE_ARRAY), /* collectStaticVariableConditionalExpressions $walkedConditionalExpressions */
+	reg::packed(1601, MAY_BE_ARRAY), /* collectStaticVariableConditionalExpressions $enteredTypes */
 	reg::packed(531, MAY_BE_ARRAY), /* collectStaticVariableConditionalExpressions return */
 	reg::packed(958, MAY_BE_ARRAY), /* isWalkedStaticVariableState $state */
-	reg::packed(1452, MAY_BE_ARRAY), /* isWalkedStaticVariableState $types */
+	reg::packed(1566, MAY_BE_ARRAY), /* isWalkedStaticVariableState $types */
 	reg::packed(416, 0, 422), /* isWalkedStaticVariableState $scope */
-	reg::packed(1458, MAY_BE_ARRAY), /* isWalkedStaticVariableState $walkedConditionalExpressions */
+	reg::packed(1572, MAY_BE_ARRAY), /* isWalkedStaticVariableState $walkedConditionalExpressions */
 	reg::packed(531, MAY_BE_BOOL), /* isWalkedStaticVariableState return */
-	reg::packed(1572, MAY_BE_ARRAY), /* equalStaticVariableStates $a */
-	reg::packed(1574, MAY_BE_ARRAY), /* equalStaticVariableStates $b */
+	reg::packed(1686, MAY_BE_ARRAY), /* equalStaticVariableStates $a */
+	reg::packed(1688, MAY_BE_ARRAY), /* equalStaticVariableStates $b */
 	reg::packed(531, MAY_BE_BOOL), /* equalStaticVariableStates return */
-	reg::packed(1572, MAY_BE_ARRAY), /* equalStaticVariableConditionalExpressions $a */
-	reg::packed(1574, MAY_BE_ARRAY), /* equalStaticVariableConditionalExpressions $b */
+	reg::packed(1686, MAY_BE_ARRAY), /* equalStaticVariableConditionalExpressions $a */
+	reg::packed(1688, MAY_BE_ARRAY), /* equalStaticVariableConditionalExpressions $b */
 	reg::packed(531, MAY_BE_BOOL), /* equalStaticVariableConditionalExpressions return */
-	reg::packed(1572, 0, 1644), /* equalConditionalExpressionHolders $a */
-	reg::packed(1574, 0, 1644), /* equalConditionalExpressionHolders $b */
+	reg::packed(1686, 0, 1758), /* equalConditionalExpressionHolders $a */
+	reg::packed(1688, 0, 1758), /* equalConditionalExpressionHolders $b */
 	reg::packed(531, MAY_BE_BOOL), /* equalConditionalExpressionHolders return */
-	reg::packed(1316, 0, 422), /* joinStaticVariableTypes $bodyScope */
-	reg::packed(1407, MAY_BE_ARRAY), /* joinStaticVariableTypes $names */
-	reg::packed(1452, MAY_BE_ARRAY), /* joinStaticVariableTypes $types */
-	reg::packed(1723, MAY_BE_ARRAY), /* joinStaticVariableTypes $walkTypes */
-	reg::packed(1733, MAY_BE_BOOL), /* joinStaticVariableTypes $generalize */
+	reg::packed(1430, 0, 422), /* joinStaticVariableTypes $bodyScope */
+	reg::packed(1521, MAY_BE_ARRAY), /* joinStaticVariableTypes $names */
+	reg::packed(1566, MAY_BE_ARRAY), /* joinStaticVariableTypes $types */
+	reg::packed(1837, MAY_BE_ARRAY), /* joinStaticVariableTypes $walkTypes */
+	reg::packed(1847, MAY_BE_BOOL), /* joinStaticVariableTypes $generalize */
 	reg::packed(531, MAY_BE_ARRAY), /* joinStaticVariableTypes return */
-	reg::packed(531, 0, 1768), /* getClosureProcessor return */
+	reg::packed(531, 0, 1882), /* getClosureProcessor return */
 	reg::packed(357, 0, 375), /* processDeferredByRefClosureBodies $nodeScopeResolver */
-	reg::packed(1822, 0, 1186), /* processDeferredByRefClosureBodies $frame */
+	reg::packed(1327, 0, 1186), /* processDeferredByRefClosureBodies $frame */
 	reg::packed(958, 0, 964), /* processDeferredByRefClosureBodies $state */
 	reg::packed(592, 0, 477), /* processDeferredByRefClosureBodies $storage */
 	reg::packed(518, MAY_BE_CALLABLE), /* processDeferredByRefClosureBodies $nodeCallback */
@@ -279,51 +294,51 @@ inline constexpr reg::PackedArg args[] = {
 	reg::packed(357, 0, 375), /* observeClosureSignatures $nodeScopeResolver */
 	reg::packed(556, 0, 567), /* observeClosureSignatures $parentNode */
 	reg::packed(865, MAY_BE_ARRAY), /* observeClosureSignatures $stmts */
-	reg::packed(1822, 0, 1186), /* observeClosureSignatures $frame */
+	reg::packed(1327, 0, 1186), /* observeClosureSignatures $frame */
 	reg::packed(1234, MAY_BE_ARRAY), /* observeClosureSignatures $entries */
 	reg::packed(592, 0, 477), /* observeClosureSignatures $storage */
 	reg::packed(600, 0, 608), /* observeClosureSignatures $context */
-	reg::packed(1862, MAY_BE_ARRAY), /* observeClosureSignatures $statementStartTokenPositions */
+	reg::packed(1970, MAY_BE_ARRAY), /* observeClosureSignatures $statementStartTokenPositions */
 	reg::packed(531, 0, 1186), /* observeClosureSignatures return */
 	reg::packed(416, 0, 422), /* withRecordedConstraints $scope */
-	reg::packed(1916, 0, 422), /* withRecordedConstraints $recordedEntry */
-	reg::packed(1930, 0, 422), /* withRecordedConstraints $recordedExit */
+	reg::packed(2024, 0, 422), /* withRecordedConstraints $recordedEntry */
+	reg::packed(2038, 0, 422), /* withRecordedConstraints $recordedExit */
 	reg::packed(531, 0, 422), /* withRecordedConstraints return */
 	reg::packed(865, MAY_BE_ARRAY), /* containsLabels $stmts */
 	reg::packed(531, MAY_BE_BOOL), /* containsLabels return */
 	reg::packed(958, 0, 964), /* appendRecordedStatementResults $state */
-	reg::packed(1982, 0, 964), /* appendRecordedStatementResults $from */
-	reg::packed(1987, 0, 964), /* appendRecordedStatementResults $to */
+	reg::packed(2090, 0, 964), /* appendRecordedStatementResults $from */
+	reg::packed(2095, 0, 964), /* appendRecordedStatementResults $to */
 	reg::packed(531, MAY_BE_VOID), /* appendRecordedStatementResults return */
 	reg::packed(933, 0, 938), /* getVariableMentionFlow $stmt */
-	reg::packed(531, MAY_BE_NULL, 2021), /* getVariableMentionFlow return */
+	reg::packed(531, MAY_BE_NULL, 2129), /* getVariableMentionFlow return */
 	reg::packed(933, 0, 938), /* statementMentionsAnyVariable $stmt */
-	reg::packed(2074, MAY_BE_ARRAY), /* statementMentionsAnyVariable $variableNames */
+	reg::packed(2182, MAY_BE_ARRAY), /* statementMentionsAnyVariable $variableNames */
 	reg::packed(531, MAY_BE_BOOL), /* statementMentionsAnyVariable return */
-	reg::packed(2117, 0, 567), /* collectMentionedVariables $node */
-	reg::packed(1407, MAY_BE_ARRAY, reg::NoString, true, false), /* collectMentionedVariables $names */
-	reg::packed(2122, MAY_BE_BOOL, reg::NoString, true, false), /* collectMentionedVariables $mentionsEverything */
+	reg::packed(2225, 0, 567), /* collectMentionedVariables $node */
+	reg::packed(1521, MAY_BE_ARRAY, reg::NoString, true, false), /* collectMentionedVariables $names */
+	reg::packed(2230, MAY_BE_BOOL, reg::NoString, true, false), /* collectMentionedVariables $mentionsEverything */
 	reg::packed(531, MAY_BE_VOID), /* collectMentionedVariables return */
-	reg::packed(2167, 0, 938), /* getOverridingThrowPoints $statement */
+	reg::packed(2275, 0, 938), /* getOverridingThrowPoints $statement */
 	reg::packed(416, 0, 422), /* getOverridingThrowPoints $scope */
 	reg::packed(531, MAY_BE_NULL | MAY_BE_ARRAY), /* getOverridingThrowPoints return */
 	reg::packed(357, 0, 375), /* processStmtVarAnnotation $nodeScopeResolver */
 	reg::packed(416, 0, 422), /* processStmtVarAnnotation $scope */
 	reg::packed(592, 0, 477), /* processStmtVarAnnotation $storage */
 	reg::packed(933, 0, 938), /* processStmtVarAnnotation $stmt */
-	reg::packed(2202, MAY_BE_NULL, 2214), /* processStmtVarAnnotation $defaultExpr */
+	reg::packed(2310, MAY_BE_NULL, 2322), /* processStmtVarAnnotation $defaultExpr */
 	reg::packed(518, MAY_BE_CALLABLE), /* processStmtVarAnnotation $nodeCallback */
 	reg::packed(531, 0, 422), /* processStmtVarAnnotation return */
 	reg::packed(416, 0, 422), /* findSingleVariableLessVarTag $scope */
 	reg::packed(933, 0, 938), /* findSingleVariableLessVarTag $stmt */
-	reg::packed(531, MAY_BE_NULL, 2259), /* findSingleVariableLessVarTag return */
+	reg::packed(531, MAY_BE_NULL, 2367), /* findSingleVariableLessVarTag return */
 	reg::packed(357, 0, 375), /* emitVarTagChangedNode $nodeScopeResolver */
 	reg::packed(416, 0, 422), /* emitVarTagChangedNode $scope */
 	reg::packed(592, 0, 477), /* emitVarTagChangedNode $storage */
 	reg::packed(933, 0, 938), /* emitVarTagChangedNode $stmt */
-	reg::packed(2202, 0, 2214), /* emitVarTagChangedNode $defaultExpr */
+	reg::packed(2310, 0, 2322), /* emitVarTagChangedNode $defaultExpr */
 	reg::packed(518, MAY_BE_CALLABLE), /* emitVarTagChangedNode $nodeCallback */
-	reg::packed(531, 0, 2314), /* emitVarTagChangedNode return */
+	reg::packed(531, 0, 1351), /* emitVarTagChangedNode return */
 };
 using Sig = reg::Sig<strings, args>;
 } // namespace sigtab
@@ -341,28 +356,29 @@ inline constexpr sigtab::Sig processStatementStep = { { 1029 /* processStatement
 inline constexpr sigtab::Sig readEndStatementExprResult = { { 1084 /* readEndStatementExprResult */, 2, 54, 2, 56, ZEND_ACC_PRIVATE } };
 inline constexpr sigtab::Sig processBodyStmtNodesTwoPass = { { 1111 /* processBodyStmtNodesTwoPass */, 7, 57, 7, 64, ZEND_ACC_PRIVATE } };
 inline constexpr sigtab::Sig inferStaticVariableTypes = { { 1291 /* inferStaticVariableTypes */, 10, 65, 10, 75, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig collectStaticVariableScopes = { { 1346 /* collectStaticVariableScopes */, 4, 76, 4, 80, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig collectStaticVariableStateScopes = { { 1374 /* collectStaticVariableStateScopes */, 4, 81, 4, 85, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig collectStaticVariableTypes = { { 1420 /* collectStaticVariableTypes */, 2, 86, 2, 88, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig collectStaticVariableConditionalExpressions = { { 1500 /* collectStaticVariableConditionalExpressions */, 6, 89, 6, 95, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig isWalkedStaticVariableState = { { 1544 /* isWalkedStaticVariableState */, 4, 96, 4, 100, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig equalStaticVariableStates = { { 1576 /* equalStaticVariableStates */, 2, 101, 2, 103, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig equalStaticVariableConditionalExpressions = { { 1602 /* equalStaticVariableConditionalExpressions */, 2, 104, 2, 106, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig equalConditionalExpressionHolders = { { 1689 /* equalConditionalExpressionHolders */, 2, 107, 2, 109, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig joinStaticVariableTypes = { { 1744 /* joinStaticVariableTypes */, 5, 110, 5, 115, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig getClosureProcessor = { { 1802 /* getClosureProcessor */, 0, 116, 0, 116, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig processDeferredByRefClosureBodies = { { 1828 /* processDeferredByRefClosureBodies */, 5, 117, 5, 122, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig observeClosureSignatures = { { 1891 /* observeClosureSignatures */, 8, 123, 8, 131, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig withRecordedConstraints = { { 1943 /* withRecordedConstraints */, 3, 132, 3, 135, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig containsLabels = { { 1967 /* containsLabels */, 1, 136, 1, 137, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig appendRecordedStatementResults = { { 1990 /* appendRecordedStatementResults */, 3, 138, 3, 141, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig getVariableMentionFlow = { { 2051 /* getVariableMentionFlow */, 1, 142, 1, 143, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig statementMentionsAnyVariable = { { 2088 /* statementMentionsAnyVariable */, 2, 144, 2, 146, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig collectMentionedVariables = { { 2141 /* collectMentionedVariables */, 3, 147, 3, 150, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig getOverridingThrowPoints = { { 2177 /* getOverridingThrowPoints */, 2, 151, 2, 153, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig processStmtVarAnnotation = { { 2234 /* processStmtVarAnnotation */, 6, 154, 6, 160, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig findSingleVariableLessVarTag = { { 2285 /* findSingleVariableLessVarTag */, 2, 161, 2, 163, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig emitVarTagChangedNode = { { 2368 /* emitVarTagChangedNode */, 6, 164, 6, 170, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig replayStaticVariableWalk = { { 1405 /* replayStaticVariableWalk */, 11, 76, 11, 87, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig collectStaticVariableScopes = { { 1460 /* collectStaticVariableScopes */, 4, 88, 4, 92, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig collectStaticVariableStateScopes = { { 1488 /* collectStaticVariableStateScopes */, 4, 93, 4, 97, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig collectStaticVariableTypes = { { 1534 /* collectStaticVariableTypes */, 2, 98, 2, 100, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig collectStaticVariableConditionalExpressions = { { 1614 /* collectStaticVariableConditionalExpressions */, 6, 101, 6, 107, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig isWalkedStaticVariableState = { { 1658 /* isWalkedStaticVariableState */, 4, 108, 4, 112, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig equalStaticVariableStates = { { 1690 /* equalStaticVariableStates */, 2, 113, 2, 115, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig equalStaticVariableConditionalExpressions = { { 1716 /* equalStaticVariableConditionalExpressions */, 2, 116, 2, 118, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig equalConditionalExpressionHolders = { { 1803 /* equalConditionalExpressionHolders */, 2, 119, 2, 121, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig joinStaticVariableTypes = { { 1858 /* joinStaticVariableTypes */, 5, 122, 5, 127, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig getClosureProcessor = { { 1916 /* getClosureProcessor */, 0, 128, 0, 128, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig processDeferredByRefClosureBodies = { { 1936 /* processDeferredByRefClosureBodies */, 5, 129, 5, 134, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig observeClosureSignatures = { { 1999 /* observeClosureSignatures */, 8, 135, 8, 143, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig withRecordedConstraints = { { 2051 /* withRecordedConstraints */, 3, 144, 3, 147, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig containsLabels = { { 2075 /* containsLabels */, 1, 148, 1, 149, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig appendRecordedStatementResults = { { 2098 /* appendRecordedStatementResults */, 3, 150, 3, 153, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig getVariableMentionFlow = { { 2159 /* getVariableMentionFlow */, 1, 154, 1, 155, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig statementMentionsAnyVariable = { { 2196 /* statementMentionsAnyVariable */, 2, 156, 2, 158, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig collectMentionedVariables = { { 2249 /* collectMentionedVariables */, 3, 159, 3, 162, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig getOverridingThrowPoints = { { 2285 /* getOverridingThrowPoints */, 2, 163, 2, 165, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig processStmtVarAnnotation = { { 2342 /* processStmtVarAnnotation */, 6, 166, 6, 172, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig findSingleVariableLessVarTag = { { 2393 /* findSingleVariableLessVarTag */, 2, 173, 2, 175, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig emitVarTagChangedNode = { { 2422 /* emitVarTagChangedNode */, 6, 176, 6, 182, ZEND_ACC_PUBLIC } };
 } // namespace sig
 
 } // namespace ptdecl::StatementsHandler
diff --git a/turbo-ext/src/generated/StaticVariableInference.h b/turbo-ext/src/generated/StaticVariableInference.h
index 43b593ce60c..0ec6ce6026c 100644
--- a/turbo-ext/src/generated/StaticVariableInference.h
+++ b/turbo-ext/src/generated/StaticVariableInference.h
@@ -38,56 +38,65 @@ inline constexpr char strings[] =
 	"stmts\0" /* 105 */
 	"\0" /* 111 */
 	"getSites\0" /* 112 */
-	"scope\0" /* 121 */
-	"PHPStan\\Analyser\\MutatingScope\0" /* 127 */
-	"var\0" /* 158 */
-	"PhpParser\\Node\\Expr\\Variable\0" /* 162 */
-	"isInferred\0" /* 191 */
-	"getResolvedTypes\0" /* 202 */
-	"getRuns\0" /* 219 */
-	"stmt\0" /* 227 */
-	"PhpParser\\Node\\Stmt\\Static_\0" /* 232 */
-	"getResolvedConditionalExpressions\0" /* 260 */
-	"node\0" /* 294 */
-	"canRunUserCode\0" /* 299 */
-	"siteIds\0" /* 314 */
-	"declaresOnlySites\0" /* 322 */
-	"scanSites\0" /* 340 */
-	"expr\0" /* 350 */
-	"PhpParser\\Node\\Expr\0" /* 355 */
-	"names\0" /* 375 */
-	"collectRootNames\0" /* 381 */
-	"hasVarTag"; /* 398 */
+	"index\0" /* 121 */
+	"hasFunctionLikeFrom\0" /* 127 */
+	"scope\0" /* 147 */
+	"PHPStan\\Analyser\\MutatingScope\0" /* 153 */
+	"var\0" /* 184 */
+	"PhpParser\\Node\\Expr\\Variable\0" /* 188 */
+	"isInferred\0" /* 217 */
+	"getResolvedTypes\0" /* 228 */
+	"getRuns\0" /* 245 */
+	"stmt\0" /* 253 */
+	"PhpParser\\Node\\Stmt\\Static_\0" /* 258 */
+	"getResolvedConditionalExpressions\0" /* 286 */
+	"node\0" /* 320 */
+	"canRunUserCode\0" /* 325 */
+	"siteIds\0" /* 340 */
+	"declaresOnlySites\0" /* 348 */
+	"scanSites\0" /* 366 */
+	"findLastFunctionLikeStatement\0" /* 376 */
+	"expr\0" /* 406 */
+	"PhpParser\\Node\\Expr\0" /* 411 */
+	"names\0" /* 431 */
+	"collectRootNames\0" /* 437 */
+	"hasVarTag"; /* 454 */
 inline constexpr reg::PackedArg args[] = {
 	reg::packed(0, 0, 19), /* __construct $reflectionProvider */
 	reg::packed(57, MAY_BE_BOOL), /* __construct $enabled */
 	reg::packed(77, 0, 90), /* getSites $functionLike */
 	reg::packed(105, MAY_BE_ARRAY), /* getSites $stmts */
 	reg::packed(111, MAY_BE_ARRAY), /* getSites return */
-	reg::packed(121, 0, 127), /* isInferred $scope */
-	reg::packed(158, 0, 162), /* isInferred $var */
+	reg::packed(77, 0, 90), /* hasFunctionLikeFrom $functionLike */
+	reg::packed(105, MAY_BE_ARRAY), /* hasFunctionLikeFrom $stmts */
+	reg::packed(121, MAY_BE_LONG), /* hasFunctionLikeFrom $index */
+	reg::packed(111, MAY_BE_BOOL), /* hasFunctionLikeFrom return */
+	reg::packed(147, 0, 153), /* isInferred $scope */
+	reg::packed(184, 0, 188), /* isInferred $var */
 	reg::packed(111, MAY_BE_BOOL), /* isInferred return */
-	reg::packed(121, 0, 127), /* getResolvedTypes $scope */
-	reg::packed(158, 0, 162), /* getResolvedTypes $var */
+	reg::packed(147, 0, 153), /* getResolvedTypes $scope */
+	reg::packed(184, 0, 188), /* getResolvedTypes $var */
 	reg::packed(111, MAY_BE_NULL | MAY_BE_ARRAY), /* getResolvedTypes return */
 	reg::packed(77, 0, 90), /* getRuns $functionLike */
 	reg::packed(105, MAY_BE_ARRAY), /* getRuns $stmts */
 	reg::packed(111, MAY_BE_ARRAY), /* getRuns return */
-	reg::packed(121, 0, 127), /* getResolvedConditionalExpressions $scope */
-	reg::packed(227, 0, 232), /* getResolvedConditionalExpressions $stmt */
+	reg::packed(147, 0, 153), /* getResolvedConditionalExpressions $scope */
+	reg::packed(253, 0, 258), /* getResolvedConditionalExpressions $stmt */
 	reg::packed(111, MAY_BE_ARRAY), /* getResolvedConditionalExpressions return */
-	reg::packed(294, 0, 90), /* canRunUserCode $node */
-	reg::packed(121, 0, 127), /* canRunUserCode $scope */
+	reg::packed(320, 0, 90), /* canRunUserCode $node */
+	reg::packed(147, 0, 153), /* canRunUserCode $scope */
 	reg::packed(111, MAY_BE_BOOL), /* canRunUserCode return */
-	reg::packed(227, 0, 232), /* declaresOnlySites $stmt */
-	reg::packed(314, MAY_BE_ARRAY), /* declaresOnlySites $siteIds */
+	reg::packed(253, 0, 258), /* declaresOnlySites $stmt */
+	reg::packed(340, MAY_BE_ARRAY), /* declaresOnlySites $siteIds */
 	reg::packed(111, MAY_BE_BOOL), /* declaresOnlySites return */
 	reg::packed(105, MAY_BE_ARRAY), /* scanSites $stmts */
 	reg::packed(111, MAY_BE_ARRAY), /* scanSites return */
-	reg::packed(350, 0, 355), /* collectRootNames $expr */
-	reg::packed(375, MAY_BE_ARRAY, reg::NoString, true, false), /* collectRootNames $names */
+	reg::packed(105, MAY_BE_ARRAY), /* findLastFunctionLikeStatement $stmts */
+	reg::packed(111, MAY_BE_LONG), /* findLastFunctionLikeStatement return */
+	reg::packed(406, 0, 411), /* collectRootNames $expr */
+	reg::packed(431, MAY_BE_ARRAY, reg::NoString, true, false), /* collectRootNames $names */
 	reg::packed(111, MAY_BE_VOID), /* collectRootNames return */
-	reg::packed(227, 0, 232), /* hasVarTag $stmt */
+	reg::packed(253, 0, 258), /* hasVarTag $stmt */
 	reg::packed(111, MAY_BE_BOOL), /* hasVarTag return */
 };
 using Sig = reg::Sig<strings, args>;
@@ -97,15 +106,17 @@ using Sig = reg::Sig<strings, args>;
 namespace sig {
 inline constexpr sigtab::Sig __construct = { { 65 /* __construct */, 2, 0, 2, reg::NoArg, ZEND_ACC_PUBLIC } };
 inline constexpr sigtab::Sig getSites = { { 112 /* getSites */, 2, 2, 2, 4, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig isInferred = { { 191 /* isInferred */, 2, 5, 2, 7, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getResolvedTypes = { { 202 /* getResolvedTypes */, 2, 8, 2, 10, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getRuns = { { 219 /* getRuns */, 2, 11, 2, 13, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getResolvedConditionalExpressions = { { 260 /* getResolvedConditionalExpressions */, 2, 14, 2, 16, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig canRunUserCode = { { 299 /* canRunUserCode */, 2, 17, 2, 19, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig declaresOnlySites = { { 322 /* declaresOnlySites */, 2, 20, 2, 22, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig scanSites = { { 340 /* scanSites */, 1, 23, 1, 24, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig collectRootNames = { { 381 /* collectRootNames */, 2, 25, 2, 27, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig hasVarTag = { { 398 /* hasVarTag */, 1, 28, 1, 29, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig hasFunctionLikeFrom = { { 127 /* hasFunctionLikeFrom */, 3, 5, 3, 8, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig isInferred = { { 217 /* isInferred */, 2, 9, 2, 11, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getResolvedTypes = { { 228 /* getResolvedTypes */, 2, 12, 2, 14, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getRuns = { { 245 /* getRuns */, 2, 15, 2, 17, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getResolvedConditionalExpressions = { { 286 /* getResolvedConditionalExpressions */, 2, 18, 2, 20, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig canRunUserCode = { { 325 /* canRunUserCode */, 2, 21, 2, 23, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig declaresOnlySites = { { 348 /* declaresOnlySites */, 2, 24, 2, 26, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig scanSites = { { 366 /* scanSites */, 1, 27, 1, 28, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig findLastFunctionLikeStatement = { { 376 /* findLastFunctionLikeStatement */, 1, 29, 1, 30, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig collectRootNames = { { 437 /* collectRootNames */, 2, 31, 2, 33, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig hasVarTag = { { 454 /* hasVarTag */, 1, 34, 1, 35, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
 } // namespace sig
 
 } // namespace ptdecl::StaticVariableInference
diff --git a/turbo-ext/src/support.h b/turbo-ext/src/support.h
index 01a4d3f63a2..a9928e8412f 100644
--- a/turbo-ext/src/support.h
+++ b/turbo-ext/src/support.h
@@ -2025,6 +2025,7 @@ zv::Val pt_template_argument_frame_get_static_variable_conditional_expressions(z
 extern zend_class_entry *pt_ce_static_variable_inference;
 zv::Val pt_static_variable_inference_get_sites(zval *inference, zval *functionLike, zval *stmts);
 [[nodiscard]] bool pt_static_variable_inference_is_inferred(zval *inference, zval *scope, zval *var, bool &out);
+[[nodiscard]] bool pt_static_variable_inference_has_function_like_from(zval *inference, zval *functionLike, zval *stmts, zend_long index, bool &out);
 zv::Val pt_static_variable_inference_get_resolved_types(zval *inference, zval *scope, zval *var);
 zv::Val pt_static_variable_inference_get_runs(zval *inference, zval *functionLike, zval *stmts);
 zv::Val pt_static_variable_inference_get_resolved_conditional_expressions(zval *inference, zval *scope, zval *stmt);

From 38d90eab972b8eccf8b5f449b62ed33e4e197d1a Mon Sep 17 00:00:00 2001
From: Ondrej Mirtes <ondrej@mirtes.cz>
Date: Mon, 28 Sep 2026 12:36:14 +0200
Subject: [PATCH 5/9] Run the benchmark on PHP 8.5 only again

Reverts the PHP 7.4 leg of the benchmark (#6121). PHP 7.4 and 8.5 run the
same code paths again since the fibers were replaced by NodeCallbackScope,
so the downgraded run measured nothing the 8.5 one does not. The benchmark
is back to one Baseline and one Test job on PHP 8.5 comparing against
tests/bench/storage/baseline.xml, with the PHPBench attributes.

The container cache change of #6121 stays, and so do the `// lint` comments
on the data files, which RequiredPhpVersionCommentTest asks of them.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y5roddukgqaSAB2BT765UX
---
 .github/workflows/bench.yml                   |  83 +--
 Makefile                                      |   1 +
 tests/bench/BenchCase.php                     |  48 --
 tests/bench/RegressionBench.php               |  33 +-
 tests/bench/storage/baseline-7.4.xml          | 690 ------------------
 .../{baseline-8.5.xml => baseline.xml}        |   0
 6 files changed, 21 insertions(+), 834 deletions(-)
 delete mode 100644 tests/bench/storage/baseline-7.4.xml
 rename tests/bench/storage/{baseline-8.5.xml => baseline.xml} (100%)

diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index 7d770b8e505..2345376754c 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -23,17 +23,10 @@ permissions:
 
 jobs:
   baseline:
-    name: "Baseline (PHP ${{ matrix.php-version }})"
+    name: "Baseline"
     runs-on: ubuntu-latest
     timeout-minutes: 60
 
-    strategy:
-      fail-fast: false
-      matrix:
-        php-version:
-          - "7.4"
-          - "8.5"
-
     steps:
       - name: Harden the runner (Audit all outbound calls)
         uses: step-security/harden-runner@bf7454d06d71f1098171f2acdf0cd4708d7b5920 # v2.20.0
@@ -47,65 +40,31 @@ jobs:
         uses: "shivammathur/setup-php@f3e473d116dcccaddc5834248c87452386958240" # 2.37.2
         with:
           coverage: "none"
-          php-version: "${{ matrix.php-version }}"
+          php-version: "8.5"
           tools: pecl
           extensions: ds,mbstring
           ini-file: development
           ini-values: memory_limit=-1
 
-      - name: "Downgrade PHPUnit"
-        if: matrix.php-version == '7.4'
-        run: "composer require --dev phpunit/phpunit:^9.6 sebastian/diff:^4.0 doctrine/instantiator:^1.0 --update-with-dependencies --ignore-platform-reqs"
-
       - uses: "ramsey/composer-install@65e4f84970763564f46a70b8a54b90d033b3bdda" # v4.0.0
-
-      # tests/composer.json pins the Composer platform to PHP 8.2, which would make
-      # Composer resolve PHPBench's Symfony dependencies to versions that cannot
-      # even be parsed on PHP 7.4. Unsetting it resolves against the real PHP version.
-      - name: "Downgrade PHPBench"
-        if: matrix.php-version == '7.4'
-        run: |
-          composer config --unset platform.php --working-dir=tests
-          composer require --dev phpbench/phpbench:1.2.14 phpunit/phpunit:^9.6 brianium/paratest:^6.5 --update-with-all-dependencies --working-dir=tests
-
       - uses: "ramsey/composer-install@65e4f84970763564f46a70b8a54b90d033b3bdda" # v4.0.0
-        if: matrix.php-version != '7.4'
         with:
           working-directory: "tests/"
 
-      - uses: ./.github/actions/downgrade-code
-        with:
-          php-version: "${{ matrix.php-version }}"
-
       - name: "Run phpbench baseline"
-        run: "tests/vendor/bin/phpbench run --dump-file=tests/bench/storage/baseline-${{ matrix.php-version }}.xml --ansi"
+        run: "tests/vendor/bin/phpbench run --dump-file=tests/bench/storage/baseline.xml --ansi"
 
-      # Before committing an artifact as the new baseline, compare the <baseline-machine>
-      # values (md5, file_rw) in it with the ones in the currently committed baseline.
-      # GitHub runners differ in speed by up to 2x, and a baseline recorded on a fast
-      # runner makes every later run look like a regression.
       - name: "Upload baseline artifact"
         uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
         with:
-          name: phpbench-baseline-${{ matrix.php-version }}
-          path: tests/bench/storage/baseline-${{ matrix.php-version }}.xml
+          name: phpbench-baseline
+          path: tests/bench/storage/baseline.xml
 
   test:
-    name: "Test (PHP ${{ matrix.php-version }})"
+    name: "Test"
     runs-on: ubuntu-latest
     timeout-minutes: 60
 
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          # phpbench 1.2.14 is the last version supporting PHP 7.4
-          # and it does not have the aggregate-preview report 'my-report' extends
-          - php-version: "7.4"
-            report: "aggregate"
-          - php-version: "8.5"
-            report: "my-report"
-
     steps:
       - name: Harden the runner (Audit all outbound calls)
         uses: step-security/harden-runner@bf7454d06d71f1098171f2acdf0cd4708d7b5920 # v2.20.0
@@ -119,42 +78,16 @@ jobs:
         uses: "shivammathur/setup-php@f3e473d116dcccaddc5834248c87452386958240" # 2.37.2
         with:
           coverage: "none"
-          php-version: "${{ matrix.php-version }}"
+          php-version: "8.5"
           tools: pecl
           extensions: ds,mbstring
           ini-file: development
           ini-values: memory_limit=-1
 
-      - name: "Downgrade PHPUnit"
-        if: matrix.php-version == '7.4'
-        run: "composer require --dev phpunit/phpunit:^9.6 sebastian/diff:^4.0 doctrine/instantiator:^1.0 --update-with-dependencies --ignore-platform-reqs"
-
       - uses: "ramsey/composer-install@65e4f84970763564f46a70b8a54b90d033b3bdda" # v4.0.0
-
-      # tests/composer.json pins the Composer platform to PHP 8.2, which would make
-      # Composer resolve PHPBench's Symfony dependencies to versions that cannot
-      # even be parsed on PHP 7.4. Unsetting it resolves against the real PHP version.
-      - name: "Downgrade PHPBench"
-        if: matrix.php-version == '7.4'
-        run: |
-          composer config --unset platform.php --working-dir=tests
-          composer require --dev phpbench/phpbench:1.2.14 phpunit/phpunit:^9.6 brianium/paratest:^6.5 --update-with-all-dependencies --working-dir=tests
-
       - uses: "ramsey/composer-install@65e4f84970763564f46a70b8a54b90d033b3bdda" # v4.0.0
-        if: matrix.php-version != '7.4'
         with:
           working-directory: "tests/"
 
-      - uses: ./.github/actions/downgrade-code
-        with:
-          php-version: "${{ matrix.php-version }}"
-
-      # PHPBench does not fail when the baseline file is missing, it just runs
-      # with an empty baseline and every assertion passes
-      - name: "Check that the baseline exists"
-        run: |
-          test -f tests/bench/storage/baseline-${{ matrix.php-version }}.xml \
-            || (echo "Missing tests/bench/storage/baseline-${{ matrix.php-version }}.xml, download it from the phpbench-baseline-${{ matrix.php-version }} artifact of the Baseline job and commit it." && exit 1)
-
       - name: "Run phpbench test"
-        run: "tests/vendor/bin/phpbench run --file=tests/bench/storage/baseline-${{ matrix.php-version }}.xml --report=${{ matrix.report }} --ansi"
+        run: "tests/vendor/bin/phpbench run --file=tests/bench/storage/baseline.xml --report=my-report --ansi"
diff --git a/Makefile b/Makefile
index a49c12e6af3..ea78ec2e2cb 100644
--- a/Makefile
+++ b/Makefile
@@ -15,6 +15,7 @@ lint:
 	XDEBUG_MODE=off php vendor/bin/parallel-lint --colors \
 		--exclude tests/PHPStan/Analyser/data \
 		--exclude tests/bench/data \
+		--exclude tests/bench/RegressionBench.php \
 		--exclude tests/PHPStan/Analyser/nsrt \
 		--exclude tests/PHPStan/Rules/Methods/data \
 		--exclude tests/PHPStan/Rules/Functions/data \
diff --git a/tests/bench/BenchCase.php b/tests/bench/BenchCase.php
index 755b3f3532d..779718d72a8 100644
--- a/tests/bench/BenchCase.php
+++ b/tests/bench/BenchCase.php
@@ -2,20 +2,10 @@
 
 namespace PHPStan\Benchmark;
 
-use LogicException;
 use PHPStan\Analyser\Analyser;
 use PHPStan\Analyser\AnalyserResultFinalizer;
 use PHPStan\Analyser\Error;
 use PHPStan\Testing\PHPStanTestCaseTrait;
-use function fclose;
-use function fgets;
-use function fopen;
-use function preg_match;
-use function sprintf;
-use function str_contains;
-use function str_starts_with;
-use function version_compare;
-use const PHP_VERSION;
 
 abstract class BenchCase
 {
@@ -29,44 +19,6 @@ public static function getAdditionalConfigFiles(): array
 		];
 	}
 
-	/**
-	 * Data files that cannot be parsed on the current PHP version are not worth
-	 * benchmarking - the analysis stops at the syntax error.
-	 *
-	 * Copy of TypeInferenceTestCase::isFileLintSkipped(), originally from
-	 * https://github.com/php-parallel-lint/PHP-Parallel-Lint/blob/0c2706086ac36dce31967cb36062ff8915fe03f7/bin/skip-linting.php
-	 *
-	 * Copyright (c) 2012, Jakub Onderka
-	 */
-	protected static function isFileLintSkipped(string $file): bool
-	{
-		$f = @fopen($file, 'r');
-		if ($f !== false) {
-			$firstLine = fgets($f);
-			if ($firstLine === false) {
-				return false;
-			}
-
-			// ignore shebang line
-			if (str_starts_with($firstLine, '#!')) {
-				$firstLine = fgets($f);
-				if ($firstLine === false) {
-					return false;
-				}
-			}
-
-			@fclose($f);
-
-			if (preg_match('~<?php\\s*\\/\\/\s*lint\s*([^\d\s]+)\s*([^\s]+)\s*~i', $firstLine, $m) === 1) {
-				return version_compare(PHP_VERSION, $m[2], $m[1]) === false;
-			} elseif (str_contains($firstLine, 'lint')) {
-				throw new LogicException(sprintf("'// lint' comment must immediately follow the php starting tag in %s on line 1", $file));
-			}
-		}
-
-		return false;
-	}
-
 	/**
 	 * @param string[]|null $allAnalysedFiles
 	 * @return list<Error>
diff --git a/tests/bench/RegressionBench.php b/tests/bench/RegressionBench.php
index a8929c0bcbe..bef98a0789f 100644
--- a/tests/bench/RegressionBench.php
+++ b/tests/bench/RegressionBench.php
@@ -2,31 +2,26 @@
 
 namespace PHPStan\Benchmark;
 
+use PhpBench\Attributes as Bench;
 use Symfony\Component\Finder\Finder;
 
-/**
- * PHPBench annotations are used instead of attributes so that the benchmark
- * also runs on PHP 7.4 with the downgraded source code, where attributes
- * are just comments.
- *
- * The assertion expression has to stay on a single line - an annotation value
- * cannot span multiple lines. Annotation names must not be mentioned anywhere
- * else in this docblock either, the annotation reader tries to parse them.
- *
- * @Revs(1)
- * @Iterations(5)
- * @Warmup(1)
- * @RetryThreshold(10.0)
- * @Assert("(mode(baseline.time.avg) < 100 milliseconds and mode(variant.time.avg) < mode(baseline.time.avg) +/- 50%) or (mode(baseline.time.avg) >= 100 milliseconds and mode(baseline.time.avg) < 500 milliseconds and mode(variant.time.avg) < mode(baseline.time.avg) +/- 25%) or (mode(baseline.time.avg) >= 500 milliseconds and mode(baseline.time.avg) < 2000 milliseconds and mode(variant.time.avg) < mode(baseline.time.avg) +/- 20%) or (mode(baseline.time.avg) >= 2000 milliseconds and mode(variant.time.avg) < mode(baseline.time.avg) +/- 10%)")
- */
+#[Bench\Revs(revs: 1)]
+#[Bench\Iterations(iterations: 5)]
+#[Bench\Warmup(revs: 1)]
+#[Bench\RetryThreshold(retryThreshold: 10.0)]
+#[Bench\Assert(expression: '
+    (mode(baseline.time.avg) < 100 milliseconds and mode(variant.time.avg) < mode(baseline.time.avg) +/- 50%)
+    or (mode(baseline.time.avg) >= 100 milliseconds and mode(baseline.time.avg) < 500 milliseconds and mode(variant.time.avg) < mode(baseline.time.avg) +/- 25%)
+    or (mode(baseline.time.avg) >= 500 milliseconds and mode(baseline.time.avg) < 2000 milliseconds and mode(variant.time.avg) < mode(baseline.time.avg) +/- 20%)
+    or (mode(baseline.time.avg) >= 2000 milliseconds and mode(variant.time.avg) < mode(baseline.time.avg) +/- 10%)
+')]
 class RegressionBench extends BenchCase
 {
 
 	/**
-	 * @ParamProviders({"provideFiles"})
-	 *
 	 * @param array{string} $params
 	 */
+	#[Bench\ParamProviders(['provideFiles'])]
 	public function benchRunAnalyse(array $params): void
 	{
 		$this->runAnalyse($params[0]);
@@ -47,10 +42,6 @@ private static function findTestDataFilesFromDirectory(string $directory): array
 		$finder->sortByName(true);
 		$files = [];
 		foreach ($finder->files()->name('*.php')->in($directory) as $fileInfo) {
-			if (self::isFileLintSkipped($fileInfo->getPathname())) {
-				continue;
-			}
-
 			$files[$fileInfo->getBasename()] = [$fileInfo->getPathname()];
 		}
 
diff --git a/tests/bench/storage/baseline-7.4.xml b/tests/bench/storage/baseline-7.4.xml
deleted file mode 100644
index 4c733cfe030..00000000000
--- a/tests/bench/storage/baseline-7.4.xml
+++ /dev/null
@@ -1,690 +0,0 @@
-<?xml version="1.0"?>
-<phpbench xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.2.14">
-  <suite tag="" context="" date="2026-08-08T13:22:01+00:00" config-path="/home/runner/work/phpstan-src/phpstan-src/phpbench.json" uuid="13527c88e62675244f2c8e746a8a5690c5988d8f">
-    <env>
-      <uname>
-        <value name="os" type="string">Linux</value>
-        <value name="host" type="string">runnervmvrwv9</value>
-        <value name="release" type="string">6.17.0-1020-azure</value>
-        <value name="version" type="string">#20~24.04.1-Ubuntu SMP Fri Jun 19 20:09:14 UTC 2026</value>
-        <value name="machine" type="string">x86_64</value>
-      </uname>
-      <php>
-        <value name="xdebug" type="boolean"></value>
-        <value name="version" type="string">7.4.33</value>
-        <value name="ini" type="string">/etc/php/7.4/cli/php.ini</value>
-        <value name="extensions" type="string">Core, date, libxml, openssl, pcre, zlib, filter, hash, pcntl, Reflection, SPL, session, standard, sodium, mysqlnd, PDO, xml, amqp, apcu, ast, bcmath, bz2, calendar, ctype, curl, dba, dom, enchant, mbstring, FFI, fileinfo, ftp, gd, gettext, gmp, iconv, igbinary, imagick, imap, intl, json, ldap, exif, memcache, mongodb, msgpack, mysqli, odbc, pdo_dblib, PDO_Firebird, pdo_mysql, PDO_ODBC, pdo_pgsql, pdo_sqlite, pdo_sqlsrv, pgsql, Phar, posix, pspell, readline, shmop, SimpleXML, snmp, soap, sockets, sqlite3, sqlsrv, sysvmsg, sysvsem, sysvshm, tidy, tokenizer, xmlreader, xmlrpc, xmlwriter, xsl, yaml, zip, zmq, memcached, redis, ds, Zend OPcache</value>
-      </php>
-      <opcache>
-        <value name="extension_loaded" type="boolean">1</value>
-        <value name="enabled" type="boolean"></value>
-      </opcache>
-      <unix-sysload>
-        <value name="l1" type="double">1.572265625</value>
-        <value name="l5" type="double">0.69873046875</value>
-        <value name="l15" type="double">0.2646484375</value>
-      </unix-sysload>
-      <vcs>
-        <value name="system" type="string">git</value>
-        <value name="branch" type="string">2.2.x</value>
-        <value name="version" type="string">81e06a5839991d8d3f3b17c97f6e92eb0a6f5906</value>
-      </vcs>
-      <sampler>
-        <value name="nothing" type="double">0.0090599060058594</value>
-        <value name="md5" type="double">0.1530647277832</value>
-        <value name="file_rw" type="double">1.8279552459717</value>
-      </sampler>
-    </env>
-    <benchmark class="\PHPStan\Benchmark\RegressionBench">
-      <subject name="benchRunAnalyse">
-        <executor name="remote">
-          <parameter name="php_config" type="collection"/>
-          <parameter name="safe_parameters" value="1" type="boolean"/>
-          <parameter name="executor" value="remote" type="string"/>
-        </executor>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="and-chain-truthy-blowup.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/and-chain-truthy-blowup.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="271460" time-revs="1" time-avg="271460" mem-peak="71262168" mem-real="76021760" mem-final="69379472" comp-z-value="-0.0058404317640918" comp-deviation="-0.0034626370412368"/>
-          <iteration time-net="274077" time-revs="1" time-avg="274077" mem-peak="61692712" mem-real="65011712" mem-final="59810016" comp-z-value="1.6201606242562" comp-deviation="0.96055024986241"/>
-          <iteration time-net="271245" time-revs="1" time-avg="271245" mem-peak="61692712" mem-real="65011712" mem-final="59810016" comp-z-value="-0.13942477530416" comp-deviation="-0.082661250218265"/>
-          <iteration time-net="269001" time-revs="1" time-avg="269001" mem-peak="61692712" mem-real="65011712" mem-final="59810016" comp-z-value="-1.5336725283456" comp-deviation="-0.90927375240083"/>
-          <iteration time-net="271564" time-revs="1" time-avg="271564" mem-peak="61692712" mem-real="65011712" mem-final="59810016" comp-z-value="0.058777111157615" comp-deviation="0.034847389797884"/>
-          <stats max="274077" mean="271469.4" min="269001" mode="271375.09784735" rstdev="0.5928734691373" stdev="1609.4700494262" sum="1357347" variance="2590393.84"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="big-constant-int-union.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/big-constant-int-union.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="1179869" time-revs="1" time-avg="1179869" mem-peak="64926056" mem-real="69206016" mem-final="60038440" comp-z-value="0.98319959535713" comp-deviation="0.6812096057125"/>
-          <iteration time-net="1175060" time-revs="1" time-avg="1175060" mem-peak="64917744" mem-real="69206016" mem-final="60030128" comp-z-value="0.39091513411794" comp-deviation="0.27084545766397"/>
-          <iteration time-net="1162028" time-revs="1" time-avg="1162028" mem-peak="64917744" mem-real="69206016" mem-final="60030128" comp-z-value="-1.2141277227898" comp-deviation="-0.84120810385993"/>
-          <iteration time-net="1162354" time-revs="1" time-avg="1162354" mem-peak="64917744" mem-real="69206016" mem-final="60030128" comp-z-value="-1.1739770190335" comp-deviation="-0.81338969831537"/>
-          <iteration time-net="1180119" time-revs="1" time-avg="1180119" mem-peak="64917744" mem-real="69206016" mem-final="60030128" comp-z-value="1.0139900123481" comp-deviation="0.70254273879883"/>
-          <stats max="1180119" mean="1171886" min="1162028" mode="1177676.183953" rstdev="0.69284976207203" stdev="8119.4093627554" sum="5859430" variance="65924808.4"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="big-constant-string-union.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/big-constant-string-union.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="296326" time-revs="1" time-avg="296326" mem-peak="79462640" mem-real="81788928" mem-final="77645208" comp-z-value="-0.55921304113995" comp-deviation="-0.32144606326122"/>
-          <iteration time-net="295606" time-revs="1" time-avg="295606" mem-peak="78608248" mem-real="79691776" mem-final="76790816" comp-z-value="-0.98055396790928" comp-deviation="-0.56364066931824"/>
-          <iteration time-net="299554" time-revs="1" time-avg="299554" mem-peak="78608248" mem-real="79691776" mem-final="76790816" comp-z-value="1.3297987805426" comp-deviation="0.76439308722774"/>
-          <iteration time-net="295780" time-revs="1" time-avg="295780" mem-peak="78608248" mem-real="79691776" mem-final="76790816" comp-z-value="-0.87872991060669" comp-deviation="-0.5051103061878"/>
-          <iteration time-net="299142" time-revs="1" time-avg="299142" mem-peak="78608248" mem-real="79691776" mem-final="76790816" comp-z-value="1.0886981391134" comp-deviation="0.62580395153956"/>
-          <stats max="299554" mean="297281.6" min="295606" mode="296038.65753425" rstdev="0.57481861046366" stdev="1708.8299622841" sum="1486408" variance="2920099.84"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-1388.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-1388.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="89888" time-revs="1" time-avg="89888" mem-peak="82017120" mem-real="83886080" mem-final="80366616" comp-z-value="-0.63732976052432" comp-deviation="-0.70718295514547"/>
-          <iteration time-net="92412" time-revs="1" time-avg="92412" mem-peak="80886984" mem-real="83886080" mem-final="78670768" comp-z-value="1.8753542687843" comp-deviation="2.0808985487395"/>
-          <iteration time-net="89945" time-revs="1" time-avg="89945" mem-peak="80886984" mem-real="83886080" mem-final="78670768" comp-z-value="-0.58058531136798" comp-deviation="-0.64421914939212"/>
-          <iteration time-net="90712" time-revs="1" time-avg="90712" mem-peak="80886984" mem-real="83886080" mem-final="78670768" comp-z-value="0.18297596061289" comp-deviation="0.20303065785026"/>
-          <iteration time-net="89684" time-revs="1" time-avg="89684" mem-peak="80886984" mem-real="83886080" mem-final="78670768" comp-z-value="-0.84041515750489" comp-deviation="-0.93252710205218"/>
-          <stats max="92412" mean="90528.2" min="89684" mode="90020.328767123" rstdev="1.1096029072355" stdev="1004.5035390679" sum="452641" variance="1009027.36"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-1447.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-1447.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="19216" time-revs="1" time-avg="19216" mem-peak="79474088" mem-real="81788928" mem-final="76609080" comp-z-value="-1.4923747906178" comp-deviation="-1.3218030749638"/>
-          <iteration time-net="19366" time-revs="1" time-avg="19366" mem-peak="79461568" mem-real="81788928" mem-final="76596440" comp-z-value="-0.62269251170301" comp-deviation="-0.55152156274714"/>
-          <iteration time-net="19575" time-revs="1" time-avg="19575" mem-peak="79461568" mem-real="81788928" mem-final="76596440" comp-z-value="0.58906479691828" comp-deviation="0.52173734427475"/>
-          <iteration time-net="19491" time-revs="1" time-avg="19491" mem-peak="79461568" mem-real="81788928" mem-final="76596440" comp-z-value="0.10204272072599" comp-deviation="0.090379697433415"/>
-          <iteration time-net="19719" time-revs="1" time-avg="19719" mem-peak="79461568" mem-real="81788928" mem-final="76596440" comp-z-value="1.4239597846765" comp-deviation="1.2612075960027"/>
-          <stats max="19719" mean="19473.4" min="19216" mode="19499.491193738" rstdev="0.88570450484265" stdev="172.47678104603" sum="97367" variance="29748.24"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-3686.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-3686.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="10385" time-revs="1" time-avg="10385" mem-peak="78892224" mem-real="79691776" mem-final="77253584" comp-z-value="-1.8846668193129" comp-deviation="-1.0500038112661"/>
-          <iteration time-net="10535" time-revs="1" time-avg="10535" mem-peak="78778488" mem-real="79691776" mem-final="77220136" comp-z-value="0.6806691416393" comp-deviation="0.37922097720862"/>
-          <iteration time-net="10550" time-revs="1" time-avg="10550" mem-peak="78778488" mem-real="79691776" mem-final="77220136" comp-z-value="0.93720273773452" comp-deviation="0.52214345605609"/>
-          <iteration time-net="10492" time-revs="1" time-avg="10492" mem-peak="78778488" mem-real="79691776" mem-final="77220136" comp-z-value="-0.054727167166992" comp-deviation="-0.030490128820801"/>
-          <iteration time-net="10514" time-revs="1" time-avg="10514" mem-peak="78778488" mem-real="79691776" mem-final="77220136" comp-z-value="0.32152210710599" comp-deviation="0.17912950682216"/>
-          <stats max="10550" mean="10495.2" min="10385" mode="10522.553816047" rstdev="0.55712967433094" stdev="58.471873580381" sum="52476" variance="3418.96"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-4300.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-4300.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="5028" time-revs="1" time-avg="5028" mem-peak="78662368" mem-real="81788928" mem-final="78326584" comp-z-value="1.5398901145676" comp-deviation="2.3407286790149"/>
-          <iteration time-net="4888" time-revs="1" time-avg="4888" mem-peak="78584032" mem-real="81788928" mem-final="78248248" comp-z-value="-0.33475872055817" comp-deviation="-0.5088540606554"/>
-          <iteration time-net="4949" time-revs="1" time-avg="4949" mem-peak="78584032" mem-real="81788928" mem-final="78248248" comp-z-value="0.48205255760377" comp-deviation="0.73274984734378"/>
-          <iteration time-net="4801" time-revs="1" time-avg="4801" mem-peak="78584032" mem-real="81788928" mem-final="78248248" comp-z-value="-1.4997190681006" comp-deviation="-2.2796661917362"/>
-          <iteration time-net="4899" time-revs="1" time-avg="4899" mem-peak="78584032" mem-real="81788928" mem-final="78248248" comp-z-value="-0.18746488351258" comp-deviation="-0.28495827396703"/>
-          <stats max="5028" mean="4913" min="4801" mode="4907.1702544031" rstdev="1.5200621504556" stdev="74.680653451881" sum="24565" variance="5577.2"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-5081.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-5081.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="713350" time-revs="1" time-avg="713350" mem-peak="77741392" mem-real="79691776" mem-final="76056408" comp-z-value="0.46413355327799" comp-deviation="0.35612461463445"/>
-          <iteration time-net="712543" time-revs="1" time-avg="712543" mem-peak="78550784" mem-real="79691776" mem-final="76865800" comp-z-value="0.31616966867053" comp-deviation="0.2425935393362"/>
-          <iteration time-net="704612" time-revs="1" time-avg="704612" mem-peak="78550784" mem-real="79691776" mem-final="76865800" comp-z-value="-1.1379834525461" comp-deviation="-0.87316229485272"/>
-          <iteration time-net="718827" time-revs="1" time-avg="718827" mem-peak="78550784" mem-real="79691776" mem-final="76865800" comp-z-value="1.4683444529002" comp-deviation="1.126644688251"/>
-          <iteration time-net="704761" time-revs="1" time-avg="704761" mem-peak="78550784" mem-real="79691776" mem-final="76865800" comp-z-value="-1.1106642223026" comp-deviation="-0.8522005473689"/>
-          <stats max="718827" mean="710818.6" min="704612" mode="712317.58708414" rstdev="0.76728909625104" stdev="5454.0336119243" sum="3554093" variance="29746482.64"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-5231.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-5231.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="14511" time-revs="1" time-avg="14511" mem-peak="99635424" mem-real="104857600" mem-final="97811504" comp-z-value="0.36321990087906" comp-deviation="0.45273301212826"/>
-          <iteration time-net="14456" time-revs="1" time-avg="14456" mem-peak="96909208" mem-real="101187584" mem-final="94640024" comp-z-value="0.057759739589329" comp-deviation="0.071994240460761"/>
-          <iteration time-net="14225" time-revs="1" time-avg="14225" mem-peak="96909208" mem-real="101187584" mem-final="94640024" comp-z-value="-1.2251729378276" comp-deviation="-1.5271086005427"/>
-          <iteration time-net="14740" time-revs="1" time-avg="14740" mem-peak="96909208" mem-real="101187584" mem-final="94640024" comp-z-value="1.6350449360672" comp-deviation="2.0379908068893"/>
-          <iteration time-net="14296" time-revs="1" time-avg="14296" mem-peak="96909208" mem-real="101187584" mem-final="94640024" comp-z-value="-0.83085163870808" comp-deviation="-1.0356094589356"/>
-          <stats max="14740" mean="14445.6" min="14225" mode="14391.291585127" rstdev="1.2464433006907" stdev="180.05621344458" sum="72228" variance="32420.24"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-5231_2.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-5231_2.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="13297" time-revs="1" time-avg="13297" mem-peak="83530984" mem-real="85983232" mem-final="83189584" comp-z-value="-1.8477054802063" comp-deviation="-5.3607777825227"/>
-          <iteration time-net="14256" time-revs="1" time-avg="14256" mem-peak="82892576" mem-real="85983232" mem-final="82551176" comp-z-value="0.50485633009354" comp-deviation="1.4647478327711"/>
-          <iteration time-net="13957" time-revs="1" time-avg="13957" mem-peak="82892576" mem-real="85983232" mem-final="82551176" comp-z-value="-0.22863270148065" comp-deviation="-0.66333575322772"/>
-          <iteration time-net="14431" time-revs="1" time-avg="14431" mem-peak="82892576" mem-real="85983232" mem-final="82551176" comp-z-value="0.93415593051322" comp-deviation="2.710281704175"/>
-          <iteration time-net="14310" time-revs="1" time-avg="14310" mem-peak="82892576" mem-real="85983232" mem-final="82551176" comp-z-value="0.63732592108019" comp-deviation="1.8490839988043"/>
-          <stats max="14431" mean="14050.2" min="13297" mode="14253.465753425" rstdev="2.9013161675118" stdev="407.64072416774" sum="70251" variance="166170.96"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-5390.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-5390.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="1261" time-revs="1" time-avg="1261" mem-peak="67418176" mem-real="69206016" mem-final="67327864" comp-z-value="0.56499401858988" comp-deviation="1.1226944667201"/>
-          <iteration time-net="1286" time-revs="1" time-avg="1286" mem-peak="67404952" mem-real="69206016" mem-final="67314640" comp-z-value="1.573911908929" comp-deviation="3.1275060144346"/>
-          <iteration time-net="1221" time-revs="1" time-avg="1221" mem-peak="67404952" mem-real="69206016" mem-final="67314640" comp-z-value="-1.0492746059526" comp-deviation="-2.0850040096231"/>
-          <iteration time-net="1221" time-revs="1" time-avg="1221" mem-peak="67404952" mem-real="69206016" mem-final="67314640" comp-z-value="-1.0492746059526" comp-deviation="-2.0850040096231"/>
-          <iteration time-net="1246" time-revs="1" time-avg="1246" mem-peak="67404952" mem-real="69206016" mem-final="67314640" comp-z-value="-0.040356715613563" comp-deviation="-0.080192461908581"/>
-          <stats max="1286" mean="1247" min="1221" mode="1235.8825831703" rstdev="1.987090889072" stdev="24.779023386728" sum="6235" variance="614"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-6265.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-6265.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="120121" time-revs="1" time-avg="120121" mem-peak="81712920" mem-real="83886080" mem-final="79683272" comp-z-value="-0.69204587934243" comp-deviation="-0.52947820643191"/>
-          <iteration time-net="121737" time-revs="1" time-avg="121737" mem-peak="81703552" mem-real="83886080" mem-final="79673904" comp-z-value="1.0570097056081" comp-deviation="0.80870881514139"/>
-          <iteration time-net="119274" time-revs="1" time-avg="119274" mem-peak="81703552" mem-real="83886080" mem-final="79673904" comp-z-value="-1.6087847905139" comp-deviation="-1.2308670723184"/>
-          <iteration time-net="121469" time-revs="1" time-avg="121469" mem-peak="81703552" mem-real="83886080" mem-final="79673904" comp-z-value="0.76694355661879" comp-deviation="0.58678175958344"/>
-          <iteration time-net="121201" time-revs="1" time-avg="121201" mem-peak="81703552" mem-real="83886080" mem-final="79673904" comp-z-value="0.47687740762947" comp-deviation="0.3648547040255"/>
-          <stats max="121737" mean="120760.4" min="119274" mode="121322.48336595" rstdev="0.76509119154788" stdev="923.92718327799" sum="603802" variance="853641.44"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-6442.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-6442.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="2719" time-revs="1" time-avg="2719" mem-peak="74415600" mem-real="75497472" mem-final="74085744" comp-z-value="0.3798343334002" comp-deviation="0.29509406123202"/>
-          <iteration time-net="2721" time-revs="1" time-avg="2721" mem-peak="74302344" mem-real="75497472" mem-final="73972488" comp-z-value="0.47479291675025" comp-deviation="0.36886757654002"/>
-          <iteration time-net="2722" time-revs="1" time-avg="2722" mem-peak="74302344" mem-real="75497472" mem-final="73972488" comp-z-value="0.52227220842528" comp-deviation="0.40575433419402"/>
-          <iteration time-net="2669" time-revs="1" time-avg="2669" mem-peak="74302344" mem-real="75497472" mem-final="73972488" comp-z-value="-1.9941302503511" comp-deviation="-1.5492438214681"/>
-          <iteration time-net="2724" time-revs="1" time-avg="2724" mem-peak="74302344" mem-real="75497472" mem-final="73972488" comp-z-value="0.61723079177533" comp-deviation="0.47952784950203"/>
-          <stats max="2724" mean="2711" min="2669" mode="2721.4168297455" rstdev="0.77690202091631" stdev="21.061813787041" sum="13555" variance="443.6"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-6936.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-6936.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="71270" time-revs="1" time-avg="71270" mem-peak="83450840" mem-real="83886080" mem-final="79931304" comp-z-value="-0.43888521133939" comp-deviation="-0.67203514317331"/>
-          <iteration time-net="71630" time-revs="1" time-avg="71630" mem-peak="83433416" mem-real="83886080" mem-final="79913880" comp-z-value="-0.11122308756879" comp-deviation="-0.17030836685147"/>
-          <iteration time-net="73679" time-revs="1" time-avg="73679" mem-peak="83433416" mem-real="83886080" mem-final="79913880" comp-z-value="1.7537205002255" comp-deviation="2.6853532017137"/>
-          <iteration time-net="70316" time-revs="1" time-avg="70316" mem-peak="83433416" mem-real="83886080" mem-final="79913880" comp-z-value="-1.3071898393315" comp-deviation="-2.0016111004262"/>
-          <iteration time-net="71866" time-revs="1" time-avg="71866" mem-peak="83433416" mem-real="83886080" mem-final="79913880" comp-z-value="0.10357763801415" comp-deviation="0.1586014087373"/>
-          <stats max="73679" mean="71752.2" min="70316" mode="71434.806262232" rstdev="1.5312321441007" stdev="1098.6927504994" sum="358761" variance="1207125.76"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-6948.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-6948.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="44448" time-revs="1" time-avg="44448" mem-peak="75030008" mem-real="77594624" mem-final="74197376" comp-z-value="-1.9589114231437" comp-deviation="-0.97668781635418"/>
-          <iteration time-net="45068" time-revs="1" time-avg="45068" mem-peak="74746984" mem-real="77594624" mem-final="73914352" comp-z-value="0.81144688513433" comp-deviation="0.40457688743138"/>
-          <iteration time-net="44942" time-revs="1" time-avg="44942" mem-peak="74746984" mem-real="77594624" mem-final="73914352" comp-z-value="0.2484385837746" comp-deviation="0.12386825408141"/>
-          <iteration time-net="44956" time-revs="1" time-avg="44956" mem-peak="74746984" mem-real="77594624" mem-final="73914352" comp-z-value="0.31099506170346" comp-deviation="0.15505810223141"/>
-          <iteration time-net="45018" time-revs="1" time-avg="45018" mem-peak="74746984" mem-real="77594624" mem-final="73914352" comp-z-value="0.58803089253126" comp-deviation="0.29318457260996"/>
-          <stats max="45068" mean="44886.4" min="44448" mode="44993.988258316" rstdev="0.49858702380058" stdev="223.79776585123" sum="224432" variance="50085.44"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-7140.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-7140.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="24260" time-revs="1" time-avg="24260" mem-peak="66666416" mem-real="69206016" mem-final="66332424" comp-z-value="-1.4778929944336" comp-deviation="-1.0337203325528"/>
-          <iteration time-net="24561" time-revs="1" time-avg="24561" mem-peak="66659400" mem-real="69206016" mem-final="66325408" comp-z-value="0.27761525862287" comp-deviation="0.19417950998229"/>
-          <iteration time-net="24405" time-revs="1" time-avg="24405" mem-peak="66659400" mem-real="69206016" mem-final="66325408" comp-z-value="-0.63221626123362" comp-deviation="-0.44220711937145"/>
-          <iteration time-net="24769" time-revs="1" time-avg="24769" mem-peak="66659400" mem-real="69206016" mem-final="66325408" comp-z-value="1.4907239517649" comp-deviation="1.0426950157873"/>
-          <iteration time-net="24572" time-revs="1" time-avg="24572" mem-peak="66659400" mem-real="69206016" mem-final="66325408" comp-z-value="0.34177004527942" comp-deviation="0.23905292615467"/>
-          <stats max="24769" mean="24513.4" min="24260" mode="24530.935420744" rstdev="0.69945546561645" stdev="171.46031610842" sum="122567" variance="29398.64"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-7214.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-7214.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="2781" time-revs="1" time-avg="2781" mem-peak="77765672" mem-real="81788928" mem-final="77443976" comp-z-value="-1.4797895154549" comp-deviation="-3.4777176176593" reject-count="1"/>
-          <iteration time-net="2985" time-revs="1" time-avg="2985" mem-peak="77765672" mem-real="81788928" mem-final="77443976" comp-z-value="1.5329556058305" comp-deviation="3.6026655560183"/>
-          <iteration time-net="2871" time-revs="1" time-avg="2871" mem-peak="77765672" mem-real="81788928" mem-final="77443976" comp-z-value="-0.15063725606427" comp-deviation="-0.35401915868388"/>
-          <iteration time-net="2853" time-revs="1" time-avg="2853" mem-peak="77765672" mem-real="81788928" mem-final="77443976" comp-z-value="-0.41646770794239" comp-deviation="-0.97875885047896"/>
-          <iteration time-net="2916" time-revs="1" time-avg="2916" mem-peak="77765672" mem-real="81788928" mem-final="77443976" comp-z-value="0.51393887363105" comp-deviation="1.2078300708038"/>
-          <stats max="2985" mean="2881.2" min="2781" mode="2874.8160469668" rstdev="2.3501434368456" stdev="67.712332702396" sum="14406" variance="4584.96"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-7581.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-7581.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="448814" time-revs="1" time-avg="448814" mem-peak="81859784" mem-real="85983232" mem-final="75745704" comp-z-value="-0.63363033875593" comp-deviation="-0.53128113841146"/>
-          <iteration time-net="456737" time-revs="1" time-avg="456737" mem-peak="81851488" mem-real="85983232" mem-final="75737408" comp-z-value="1.4605850683704" comp-deviation="1.2246593169673"/>
-          <iteration time-net="453648" time-revs="1" time-avg="453648" mem-peak="81851488" mem-real="85983232" mem-final="75737408" comp-z-value="0.64409745097632" comp-deviation="0.54005751630278"/>
-          <iteration time-net="451061" time-revs="1" time-avg="451061" mem-peak="81851488" mem-real="85983232" mem-final="75737408" comp-z-value="-0.039701016553123" comp-deviation="-0.033288180789841"/>
-          <iteration time-net="445796" time-revs="1" time-avg="445796" mem-peak="81851488" mem-real="85983232" mem-final="75737408" comp-z-value="-1.4313511640377" comp-deviation="-1.2001475140688"/>
-          <stats max="456737" mean="451211.2" min="445796" mode="450934.63013699" rstdev="0.8384717490873" stdev="3783.2784407178" sum="2256056" variance="14313195.76"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-7637.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-7637.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="16449" time-revs="1" time-avg="16449" mem-peak="84172672" mem-real="88080384" mem-final="83444928" comp-z-value="-1.6058578007041" comp-deviation="-1.3411225603685"/>
-          <iteration time-net="16840" time-revs="1" time-avg="16840" mem-peak="82169200" mem-real="85983232" mem-final="81381480" comp-z-value="1.2022388007061" comp-deviation="1.0040425608483"/>
-          <iteration time-net="16658" time-revs="1" time-avg="16658" mem-peak="82169200" mem-real="85983232" mem-final="81381480" comp-z-value="-0.10485475800661" comp-deviation="-0.087568825498114"/>
-          <iteration time-net="16798" time-revs="1" time-avg="16798" mem-peak="82169200" mem-real="85983232" mem-final="81381480" comp-z-value="0.90060182561852" comp-deviation="0.75213224092224"/>
-          <iteration time-net="16618" time-revs="1" time-avg="16618" mem-peak="82169200" mem-real="85983232" mem-final="81381480" comp-z-value="-0.39212806761379" comp-deviation="-0.32748341590393"/>
-          <stats max="16840" mean="16672.6" min="16449" mode="16711.452054794" rstdev="0.83514403316436" stdev="139.24022407336" sum="83363" variance="19387.84"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-7901.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-7901.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="617662" time-revs="1" time-avg="617662" mem-peak="103987520" mem-real="106958848" mem-final="92428856" comp-z-value="-0.010181696899731" comp-deviation="-0.0054395725014031"/>
-          <iteration time-net="612755" time-revs="1" time-avg="612755" mem-peak="120778056" mem-real="127930368" mem-final="109219392" comp-z-value="-1.4971336816323" comp-deviation="-0.79984380656103"/>
-          <iteration time-net="620450" time-revs="1" time-avg="620450" mem-peak="120778056" mem-real="127930368" mem-final="109219392" comp-z-value="0.83465672442375" comp-deviation="0.44591543148438"/>
-          <iteration time-net="621967" time-revs="1" time-avg="621967" mem-peak="120778056" mem-real="127930368" mem-final="109219392" comp-z-value="1.2943482183792" comp-deviation="0.69150565424135"/>
-          <iteration time-net="615644" time-revs="1" time-avg="615644" mem-peak="120778056" mem-real="127930368" mem-final="109219392" comp-z-value="-0.62168956427089" comp-deviation="-0.33213770666328"/>
-          <stats max="621967" mean="617695.6" min="612755" mode="618505.73972604" rstdev="0.53425009160771" stdev="3300.0393088568" sum="3088478" variance="10890259.44"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-7903.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-7903.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="1937327" time-revs="1" time-avg="1937327" mem-peak="86944096" mem-real="90177536" mem-final="83630520" comp-z-value="-1.650626290697" comp-deviation="-0.76360707505205"/>
-          <iteration time-net="1947849" time-revs="1" time-avg="1947849" mem-peak="86363184" mem-real="88080384" mem-final="83049608" comp-z-value="-0.48557471693406" comp-deviation="-0.22463491064392"/>
-          <iteration time-net="1958039" time-revs="1" time-avg="1958039" mem-peak="86363184" mem-real="88080384" mem-final="83049608" comp-z-value="0.64271605826504" comp-deviation="0.29733109917539"/>
-          <iteration time-net="1963545" time-revs="1" time-avg="1963545" mem-peak="86363184" mem-real="88080384" mem-final="83049608" comp-z-value="1.2523695428819" comp-deviation="0.57936690389228"/>
-          <iteration time-net="1954412" time-revs="1" time-avg="1954412" mem-peak="86363184" mem-real="88080384" mem-final="83049608" comp-z-value="0.24111540648417" comp-deviation="0.11154398262832"/>
-          <stats max="1963545" mean="1952234.4" min="1937327" mode="1955797.6066536" rstdev="0.46261657127101" stdev="9031.3598444531" sum="9761172" variance="81565460.64"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-8146a.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-8146a.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="142622" time-revs="1" time-avg="142622" mem-peak="80423432" mem-real="81788928" mem-final="77013456" comp-z-value="1.470673458744" comp-deviation="1.001788858091"/>
-          <iteration time-net="141014" time-revs="1" time-avg="141014" mem-peak="80403048" mem-real="81788928" mem-final="76993080" comp-z-value="-0.20106620028353" comp-deviation="-0.13696166064951"/>
-          <iteration time-net="141882" time-revs="1" time-avg="141882" mem-peak="80403048" mem-real="81788928" mem-final="76993080" comp-z-value="0.7013405310821" comp-deviation="0.47773700245172"/>
-          <iteration time-net="139850" time-revs="1" time-avg="139850" mem-peak="80403048" mem-real="81788928" mem-final="76993080" comp-z-value="-1.4112061027139" comp-deviation="-0.96128106600645"/>
-          <iteration time-net="140669" time-revs="1" time-avg="140669" mem-peak="80403048" mem-real="81788928" mem-final="76993080" comp-z-value="-0.55974168682863" comp-deviation="-0.38128313388675"/>
-          <stats max="142622" mean="141207.4" min="139850" mode="140972.90410959" rstdev="0.68117694797222" stdev="961.87225763092" sum="706037" variance="925198.24"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-8146b.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-8146b.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="1012969" time-revs="1" time-avg="1012969" mem-peak="100086312" mem-real="102764544" mem-final="93538712" comp-z-value="-0.91800773367084" comp-deviation="-0.56242357895134"/>
-          <iteration time-net="1010310" time-revs="1" time-avg="1010310" mem-peak="99606904" mem-real="102764544" mem-final="93059304" comp-z-value="-1.3440527931589" comp-deviation="-0.8234429346311"/>
-          <iteration time-net="1019420" time-revs="1" time-avg="1019420" mem-peak="99606904" mem-real="102764544" mem-final="93059304" comp-z-value="0.11562020117584" comp-deviation="0.070835489679769"/>
-          <iteration time-net="1026208" time-revs="1" time-avg="1026208" mem-peak="99606904" mem-real="102764544" mem-final="93059304" comp-z-value="1.2032448208843" comp-deviation="0.73717598849669"/>
-          <iteration time-net="1024585" time-revs="1" time-avg="1024585" mem-peak="99606904" mem-real="102764544" mem-final="93059304" comp-z-value="0.94319550476956" comp-deviation="0.57785503540596"/>
-          <stats max="1026208" mean="1018698.4" min="1010310" mode="1022412.3913894" rstdev="0.61265668939669" stdev="6241.1238923771" sum="5093492" variance="38951627.44"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-8147.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-8147.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="277255" time-revs="1" time-avg="277255" mem-peak="98823648" mem-real="102760448" mem-final="95305496" comp-z-value="-0.8093838011202" comp-deviation="-1.2220808222165"/>
-          <iteration time-net="284772" time-revs="1" time-avg="284772" mem-peak="104943784" mem-real="111149056" mem-final="101425632" comp-z-value="0.96431395207802" comp-deviation="1.4560083680935"/>
-          <iteration time-net="286422" time-revs="1" time-avg="286422" mem-peak="104943784" mem-real="111149056" mem-final="101425632" comp-z-value="1.3536449741316" comp-deviation="2.0438555363803"/>
-          <iteration time-net="279487" time-revs="1" time-avg="279487" mem-peak="104943784" mem-real="111149056" mem-final="101425632" comp-z-value="-0.28272510946949" comp-deviation="-0.42688392547951"/>
-          <iteration time-net="275490" time-revs="1" time-avg="275490" mem-peak="104943784" mem-real="111149056" mem-final="101425632" comp-z-value="-1.22585001562" comp-deviation="-1.8508991567778"/>
-          <stats max="286422" mean="280685.2" min="275490" mode="278057.20156556" rstdev="1.5098903888676" stdev="4238.0388577737" sum="1403426" variance="17960973.36"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-8215.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-8215.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="462077" time-revs="1" time-avg="462077" mem-peak="129767320" mem-real="140513280" mem-final="121470808" comp-z-value="-0.11265076245939" comp-deviation="-0.15523058353649"/>
-          <iteration time-net="474254" time-revs="1" time-avg="474254" mem-peak="158709032" mem-real="159387648" mem-final="140797560" comp-z-value="1.7967984781697" comp-deviation="2.4759537367917"/>
-          <iteration time-net="459457" time-revs="1" time-avg="459457" mem-peak="158709032" mem-real="159387648" mem-final="140797560" comp-z-value="-0.52348734047107" comp-deviation="-0.72135548451865"/>
-          <iteration time-net="455033" time-revs="1" time-avg="455033" mem-peak="158709032" mem-real="159387648" mem-final="140797560" comp-z-value="-1.2172052874648" comp-deviation="-1.6772854699939"/>
-          <iteration time-net="463156" time-revs="1" time-avg="463156" mem-peak="158709032" mem-real="159387648" mem-final="140797560" comp-z-value="0.056544912225573" comp-deviation="0.077917801257311"/>
-          <stats max="474254" mean="462795.4" min="455033" mode="460524.71428572" rstdev="1.3779807623801" stdev="6377.23158118" sum="2313977" variance="40669082.64"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-8503.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-8503.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="186981" time-revs="1" time-avg="186981" mem-peak="87905960" mem-real="90177536" mem-final="83662832" comp-z-value="-0.7327560694794" comp-deviation="-0.77625265463761"/>
-          <iteration time-net="189110" time-revs="1" time-avg="189110" mem-peak="85593080" mem-real="88080384" mem-final="81349952" comp-z-value="0.33371759193819" comp-deviation="0.35352715239239"/>
-          <iteration time-net="185343" time-revs="1" time-avg="185343" mem-peak="85593080" mem-real="88080384" mem-final="81349952" comp-z-value="-1.553274555812" comp-deviation="-1.6454773253352"/>
-          <iteration time-net="190650" time-revs="1" time-avg="190650" mem-peak="85593080" mem-real="88080384" mem-final="81349952" comp-z-value="1.1051452286611" comp-deviation="1.1707469282619"/>
-          <iteration time-net="190135" time-revs="1" time-avg="190135" mem-peak="85593080" mem-real="88080384" mem-final="81349952" comp-z-value="0.84716780469208" comp-deviation="0.89745589931853"/>
-          <stats max="190650" mean="188443.8" min="185343" mode="189632.21917809" rstdev="1.0593602522994" stdev="1996.2987151226" sum="942219" variance="3985208.56"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-9690.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-9690.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="282450" time-revs="1" time-avg="282450" mem-peak="78952320" mem-real="81788928" mem-final="77059576" comp-z-value="0.22060208608377" comp-deviation="0.12648302050528"/>
-          <iteration time-net="283564" time-revs="1" time-avg="283564" mem-peak="78693168" mem-real="81788928" mem-final="76800424" comp-z-value="0.90936532570634" comp-deviation="0.5213879668138"/>
-          <iteration time-net="282556" time-revs="1" time-avg="282556" mem-peak="78693168" mem-real="81788928" mem-final="76800424" comp-z-value="0.28613970134409" comp-deviation="0.16405925417557"/>
-          <iteration time-net="282942" time-revs="1" time-avg="282942" mem-peak="78693168" mem-real="81788928" mem-final="76800424" comp-z-value="0.52479554559392" comp-deviation="0.3008934635787"/>
-          <iteration time-net="278954" time-revs="1" time-avg="278954" mem-peak="78693168" mem-real="81788928" mem-final="76800424" comp-z-value="-1.9409026587281" comp-deviation="-1.1128237050734"/>
-          <stats max="283564" mean="282093.2" min="278954" mode="282851.29941292" rstdev="0.57335369193764" stdev="1617.391776905" sum="1410466" variance="2615956.16"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-10147.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-10147.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="580" time-revs="1" time-avg="580" mem-peak="61194064" mem-real="62914560" mem-final="61124752" comp-z-value="1.0987038278899" comp-deviation="2.4373013069587"/>
-          <iteration time-net="560" time-revs="1" time-avg="560" mem-peak="61206760" mem-real="62914560" mem-final="61117216" comp-z-value="-0.49362056035633" comp-deviation="-1.095019427764"/>
-          <iteration time-net="545" time-revs="1" time-avg="545" mem-peak="61206760" mem-real="62914560" mem-final="61117216" comp-z-value="-1.687863851541" comp-deviation="-3.7442599788061"/>
-          <iteration time-net="576" time-revs="1" time-avg="576" mem-peak="61206760" mem-real="62914560" mem-final="61117216" comp-z-value="0.78023895024064" comp-deviation="1.7308371600141"/>
-          <iteration time-net="570" time-revs="1" time-avg="570" mem-peak="61206760" mem-real="62914560" mem-final="61117216" comp-z-value="0.30254163376678" comp-deviation="0.67114093959731"/>
-          <stats max="580" mean="566.2" min="545" mode="572.46575342467" rstdev="2.2183424186659" stdev="12.560254774486" sum="2831" variance="157.76"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-10538.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-10538.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="2036965" time-revs="1" time-avg="2036965" mem-peak="90269432" mem-real="94371840" mem-final="86796808" comp-z-value="1.5356097046607" comp-deviation="1.0181234685846"/>
-          <iteration time-net="2022837" time-revs="1" time-avg="2022837" mem-peak="92357512" mem-real="96468992" mem-final="88884888" comp-z-value="0.47884861066823" comp-deviation="0.31748106757906"/>
-          <iteration time-net="2018455" time-revs="1" time-avg="2018455" mem-peak="92357512" mem-real="96468992" mem-final="88884888" comp-z-value="0.1510791377156" comp-deviation="0.10016686873945"/>
-          <iteration time-net="1999954" time-revs="1" time-avg="1999954" mem-peak="92357512" mem-real="96468992" mem-final="88884888" comp-z-value="-1.2327782377058" comp-deviation="-0.81734339888532"/>
-          <iteration time-net="2003965" time-revs="1" time-avg="2003965" mem-peak="92357512" mem-real="96468992" mem-final="88884888" comp-z-value="-0.93275921533864" comp-deviation="-0.61842800601775"/>
-          <stats max="2036965" mean="2016435.2" min="1999954" mode="2014584.5714286" rstdev="0.66300926953933" stdev="13369.152290254" sum="10082176" variance="178734232.96"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-11913.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-11913.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="163591" time-revs="1" time-avg="163591" mem-peak="83934560" mem-real="85983232" mem-final="82637768" comp-z-value="-1.3330744744928" comp-deviation="-1.1120070893777"/>
-          <iteration time-net="165727" time-revs="1" time-avg="165727" mem-peak="83901968" mem-real="85983232" mem-final="82605176" comp-z-value="0.21478760287" comp-deviation="0.17916878739483"/>
-          <iteration time-net="164789" time-revs="1" time-avg="164789" mem-peak="83901968" mem-real="85983232" mem-final="82605176" comp-z-value="-0.46493834683331" comp-deviation="-0.38783634950245"/>
-          <iteration time-net="167798" time-revs="1" time-avg="167798" mem-peak="83901968" mem-real="85983232" mem-final="82605176" comp-z-value="1.7155471357437" comp-deviation="1.4310532634228"/>
-          <iteration time-net="165248" time-revs="1" time-avg="165248" mem-peak="83901968" mem-real="85983232" mem-final="82605176" comp-z-value="-0.13232191728766" comp-deviation="-0.11037861193758"/>
-          <stats max="167798" mean="165430.6" min="163591" mode="165056.4520548" rstdev="0.83416726571169" stdev="1379.9679126704" sum="827153" variance="1904311.44"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-12671.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-12671.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="380151" time-revs="1" time-avg="380151" mem-peak="97073120" mem-real="100663296" mem-final="92221880" comp-z-value="1.1030431904629" comp-deviation="1.4070237550297"/>
-          <iteration time-net="371935" time-revs="1" time-avg="371935" mem-peak="101658752" mem-real="104857600" mem-final="96807512" comp-z-value="-0.61511607333783" comp-deviation="-0.78463194802341"/>
-          <iteration time-net="381005" time-revs="1" time-avg="381005" mem-peak="101658752" mem-real="104857600" mem-final="96807512" comp-z-value="1.281634720561" comp-deviation="1.6348321740179"/>
-          <iteration time-net="372145" time-revs="1" time-avg="372145" mem-peak="101658752" mem-real="104857600" mem-final="96807512" comp-z-value="-0.57120012331371" comp-deviation="-0.72861348433778"/>
-          <iteration time-net="369146" time-revs="1" time-avg="369146" mem-peak="101658752" mem-real="104857600" mem-final="96807512" comp-z-value="-1.1983617143724" comp-deviation="-1.5286104966864"/>
-          <stats max="381005" mean="374876.4" min="369146" mode="371652.40313112" rstdev="1.2755835557438" stdev="4781.8617127642" sum="1874382" variance="22866201.44"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-12787.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-12787.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="6731" time-revs="1" time-avg="6731" mem-peak="80215792" mem-real="81788928" mem-final="78755936" comp-z-value="-0.66782720225863" comp-deviation="-1.1948799248429"/>
-          <iteration time-net="6889" time-revs="1" time-avg="6889" mem-peak="80208768" mem-real="81788928" mem-final="78748912" comp-z-value="0.62844672841538" comp-deviation="1.1244201749751"/>
-          <iteration time-net="6803" time-revs="1" time-avg="6803" mem-peak="80208768" mem-real="81788928" mem-final="78748912" comp-z-value="-0.077120094609716" comp-deviation="-0.13798367682461"/>
-          <iteration time-net="6644" time-revs="1" time-avg="6644" mem-peak="80208768" mem-real="81788928" mem-final="78748912" comp-z-value="-1.3815982906677" comp-deviation="-2.4719628911984"/>
-          <iteration time-net="6995" time-revs="1" time-avg="6995" mem-peak="80208768" mem-real="81788928" mem-final="78748912" comp-z-value="1.4980988591207" comp-deviation="2.6804063178909"/>
-          <stats max="6995" mean="6812.4" min="6644" mode="6787.5596868885" rstdev="1.7892052327335" stdev="121.88781727474" sum="34062" variance="14856.64"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-12800.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-12800.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="2002336" time-revs="1" time-avg="2002336" mem-peak="84280432" mem-real="85983232" mem-final="79543648" comp-z-value="0.44475358124" comp-deviation="0.34238976065991"/>
-          <iteration time-net="1978591" time-revs="1" time-avg="1978591" mem-peak="83984328" mem-real="85983232" mem-final="79247544" comp-z-value="-1.1009219919911" comp-deviation="-0.84753542915182"/>
-          <iteration time-net="2002331" time-revs="1" time-avg="2002331" mem-peak="83984328" mem-real="85983232" mem-final="79247544" comp-z-value="0.44442810733534" comp-deviation="0.34213919734346"/>
-          <iteration time-net="2017072" time-revs="1" time-avg="2017072" mem-peak="83984328" mem-real="85983232" mem-final="79247544" comp-z-value="1.4039902730544" comp-deviation="1.0808499668956"/>
-          <iteration time-net="1977188" time-revs="1" time-avg="1977188" mem-peak="83984328" mem-real="85983232" mem-final="79247544" comp-z-value="-1.1922499696387" comp-deviation="-0.91784349574714"/>
-          <stats max="2017072" mean="1995503.6" min="1977188" mode="2002554.5362036" rstdev="0.7698414922378" stdev="15362.214691899" sum="9977518" variance="235997640.24"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-13310.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-13310.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="53627" time-revs="1" time-avg="53627" mem-peak="77676496" mem-real="79691776" mem-final="76623120" comp-z-value="0.76426618048281" comp-deviation="0.54974518972958"/>
-          <iteration time-net="53285" time-revs="1" time-avg="53285" mem-peak="77654520" mem-real="79691776" mem-final="76535608" comp-z-value="-0.12720392089892" comp-deviation="-0.091499199382011"/>
-          <iteration time-net="53897" time-revs="1" time-avg="53897" mem-peak="77654520" mem-real="79691776" mem-final="76535608" comp-z-value="1.4680583657842" comp-deviation="1.0559907600808"/>
-          <iteration time-net="52976" time-revs="1" time-avg="52976" mem-peak="77654520" mem-real="79691776" mem-final="76535608" comp-z-value="-0.93265497741049" comp-deviation="-0.67086912989512"/>
-          <iteration time-net="52884" time-revs="1" time-avg="52884" mem-peak="77654520" mem-real="79691776" mem-final="76535608" comp-z-value="-1.1724656479576" comp-deviation="-0.84336762053333"/>
-          <stats max="53897" mean="53333.8" min="52884" mode="53125.851272016" rstdev="0.71931115594084" stdev="383.63597328718" sum="266669" variance="147176.56"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-13685.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-13685.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="15102" time-revs="1" time-avg="15102" mem-peak="81311688" mem-real="81788928" mem-final="77786936" comp-z-value="-0.41441563600596" comp-deviation="-0.81830480869006"/>
-          <iteration time-net="15822" time-revs="1" time-avg="15822" mem-peak="81240648" mem-real="81788928" mem-final="77759064" comp-z-value="1.9802814580895" comp-deviation="3.9102623041257"/>
-          <iteration time-net="15030" time-revs="1" time-avg="15030" mem-peak="81240648" mem-real="81788928" mem-final="77759064" comp-z-value="-0.6538853454155" comp-deviation="-1.2911615199716"/>
-          <iteration time-net="15143" time-revs="1" time-avg="15143" mem-peak="81240648" mem-real="81788928" mem-final="77759064" comp-z-value="-0.27805094036997" comp-deviation="-0.5490391814325"/>
-          <iteration time-net="15036" time-revs="1" time-avg="15036" mem-peak="81240648" mem-real="81788928" mem-final="77759064" comp-z-value="-0.63392953629804" comp-deviation="-1.2517567940315"/>
-          <stats max="15822" mean="15226.6" min="15030" mode="15079.596868885" rstdev="1.9745992612071" stdev="300.66433110697" sum="76133" variance="90399.04"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-13933.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-13933.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="262436" time-revs="1" time-avg="262436" mem-peak="81792224" mem-real="83886080" mem-final="79373880" comp-z-value="1.8065638044122" comp-deviation="0.92706327920273"/>
-          <iteration time-net="258714" time-revs="1" time-avg="258714" mem-peak="81407104" mem-real="81788928" mem-final="78176760" comp-z-value="-0.98279589027884" comp-deviation="-0.50433534570084"/>
-          <iteration time-net="260178" time-revs="1" time-avg="260178" mem-peak="81407104" mem-real="81788928" mem-final="78176760" comp-z-value="0.11436224863242" comp-deviation="0.05868657446542"/>
-          <iteration time-net="258868" time-revs="1" time-avg="258868" mem-peak="81407104" mem-real="81788928" mem-final="78176760" comp-z-value="-0.86738444670484" comp-deviation="-0.44511036229537"/>
-          <iteration time-net="259931" time-revs="1" time-avg="259931" mem-peak="81407104" mem-real="81788928" mem-final="78176760" comp-z-value="-0.07074571606094" comp-deviation="-0.036304145671921"/>
-          <stats max="262436" mean="260025.4" min="258714" mode="259449.65949119" rstdev="0.51316387328172" stdev="1334.3564141563" sum="1300127" variance="1780507.04"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-14207-and.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-14207-and.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="353780" time-revs="1" time-avg="353780" mem-peak="78193632" mem-real="79691776" mem-final="74546968" comp-z-value="-0.1212224090497" comp-deviation="-0.052152107866147" reject-count="1"/>
-          <iteration time-net="351541" time-revs="1" time-avg="351541" mem-peak="78193632" mem-real="79691776" mem-final="74546968" comp-z-value="-1.5915202089538" comp-deviation="-0.68470123848542"/>
-          <iteration time-net="356074" time-revs="1" time-avg="356074" mem-peak="78193632" mem-real="79691776" mem-final="74546968" comp-z-value="1.3851925766493" comp-deviation="0.59593529974467"/>
-          <iteration time-net="354960" time-revs="1" time-avg="354960" mem-peak="78193632" mem-real="79691776" mem-final="74546968" comp-z-value="0.65365539527674" comp-deviation="0.28121456213419"/>
-          <iteration time-net="353468" time-revs="1" time-avg="353468" mem-peak="78193632" mem-real="79691776" mem-final="74546968" comp-z-value="-0.32610535392245" comp-deviation="-0.14029651552725"/>
-          <stats max="356074" mean="353964.6" min="351541" mode="354157.89823874" rstdev="0.43021837525739" stdev="1522.8207511063" sum="1769823" variance="2318983.04"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-14207.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-14207.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="87866" time-revs="1" time-avg="87866" mem-peak="81839088" mem-real="83886080" mem-final="80227336" comp-z-value="0.18747614307312" comp-deviation="0.036887933547064"/>
-          <iteration time-net="87725" time-revs="1" time-avg="87725" mem-peak="81811240" mem-real="83886080" mem-final="80199488" comp-z-value="-0.62839225733784" comp-deviation="-0.12364288837074"/>
-          <iteration time-net="87684" time-revs="1" time-avg="87684" mem-peak="81811240" mem-real="83886080" mem-final="80199488" comp-z-value="-0.86563058653535" comp-deviation="-0.17032206353833"/>
-          <iteration time-net="88157" time-revs="1" time-avg="88157" mem-peak="81811240" mem-real="83886080" mem-final="80199488" comp-z-value="1.8712896503043" comp-deviation="0.3681962255902"/>
-          <iteration time-net="87736" time-revs="1" time-avg="87736" mem-peak="81811240" mem-real="83886080" mem-final="80199488" comp-z-value="-0.56474294950436" comp-deviation="-0.11111920722822"/>
-          <stats max="88157" mean="87833.6" min="87684" mode="87746.943248532" rstdev="0.19676068081194" stdev="172.82198934163" sum="439168" variance="29867.44"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-14452.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-14452.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="25019" time-revs="1" time-avg="25019" mem-peak="80338184" mem-real="81788928" mem-final="79308032" comp-z-value="-0.78090688426766" comp-deviation="-0.26628610608392"/>
-          <iteration time-net="25084" time-revs="1" time-avg="25084" mem-peak="79032520" mem-real="81788928" mem-final="78002368" comp-z-value="-0.021042401073072" comp-deviation="-0.0071753741160309"/>
-          <iteration time-net="25061" time-revs="1" time-avg="25061" mem-peak="79032520" mem-real="81788928" mem-final="78002368" comp-z-value="-0.28991752589577" comp-deviation="-0.098860710043129"/>
-          <iteration time-net="25016" time-revs="1" time-avg="25016" mem-peak="79032520" mem-real="81788928" mem-final="78002368" comp-z-value="-0.8159775527228" comp-deviation="-0.27824506294397"/>
-          <iteration time-net="25249" time-revs="1" time-avg="25249" mem-peak="79032520" mem-real="81788928" mem-final="78002368" comp-z-value="1.9078443639593" comp-deviation="0.65056725318706"/>
-          <stats max="25249" mean="25085.8" min="25016" mode="25045.181996086" rstdev="0.34099597717549" stdev="85.541568842289" sum="125429" variance="7317.36"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-14462.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-14462.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="146754" time-revs="1" time-avg="146754" mem-peak="77157568" mem-real="79691776" mem-final="75512440" comp-z-value="0.21513428501531" comp-deviation="0.1103742218208"/>
-          <iteration time-net="145448" time-revs="1" time-avg="145448" mem-peak="77135176" mem-real="79691776" mem-final="75490048" comp-z-value="-1.5213637139341" comp-deviation="-0.7805326613558"/>
-          <iteration time-net="146593" time-revs="1" time-avg="146593" mem-peak="77135176" mem-real="79691776" mem-final="75490048" comp-z-value="0.001063704746661" comp-deviation="0.00054573162827787"/>
-          <iteration time-net="146372" time-revs="1" time-avg="146372" mem-peak="77135176" mem-real="79691776" mem-final="75490048" comp-z-value="-0.29278473152272" comp-deviation="-0.15021263068568"/>
-          <iteration time-net="147794" time-revs="1" time-avg="147794" mem-peak="77135176" mem-real="79691776" mem-final="75490048" comp-z-value="1.5979504556947" comp-deviation="0.81982533859236"/>
-          <stats max="147794" mean="146592.2" min="145448" mode="146554.43052837" rstdev="0.51304803329207" stdev="752.08839905958" sum="732961" variance="565636.96"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-14475.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-14475.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="24216" time-revs="1" time-avg="24216" mem-peak="79298128" mem-real="79691776" mem-final="75009504" comp-z-value="-0.78112570214357" comp-deviation="-0.48001052077853"/>
-          <iteration time-net="24343" time-revs="1" time-avg="24343" mem-peak="79295136" mem-real="79691776" mem-final="75006600" comp-z-value="0.068214744536515" comp-deviation="0.0419187269858"/>
-          <iteration time-net="24241" time-revs="1" time-avg="24241" mem-peak="79295136" mem-real="79691776" mem-final="75006600" comp-z-value="-0.61393270082859" comp-deviation="-0.37726854287217"/>
-          <iteration time-net="24245" time-revs="1" time-avg="24245" mem-peak="79295136" mem-real="79691776" mem-final="75006600" comp-z-value="-0.58718182061819" comp-deviation="-0.36082982640715"/>
-          <iteration time-net="24619" time-revs="1" time-avg="24619" mem-peak="79295136" mem-real="79691776" mem-final="75006600" comp-z-value="1.9140254790539" comp-deviation="1.1761901630721"/>
-          <stats max="24619" mean="24332.8" min="24216" mode="24258.587084149" rstdev="0.61451123610616" stdev="149.52779005924" sum="121664" variance="22358.56"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-14590.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-14590.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="265743" time-revs="1" time-avg="265743" mem-peak="61264056" mem-real="65011712" mem-final="59972672" comp-z-value="-1.2659256460038" comp-deviation="-0.84482804939569"/>
-          <iteration time-net="269359" time-revs="1" time-avg="269359" mem-peak="61264056" mem-real="65011712" mem-final="59972672" comp-z-value="0.75579820169062" comp-deviation="0.5043894343137"/>
-          <iteration time-net="268803" time-revs="1" time-avg="268803" mem-peak="61264056" mem-real="65011712" mem-final="59972672" comp-z-value="0.44493579590575" comp-deviation="0.29693232122122"/>
-          <iteration time-net="270115" time-revs="1" time-avg="270115" mem-peak="61264056" mem-real="65011712" mem-final="59972672" comp-z-value="1.1784816167506" comp-deviation="0.78647140823082"/>
-          <iteration time-net="266016" time-revs="1" time-avg="266016" mem-peak="61264056" mem-real="65011712" mem-final="59972672" comp-z-value="-1.1132899683432" comp-deviation="-0.74296511437007"/>
-          <stats max="270115" mean="268007.2" min="265743" mode="269225.19960861" rstdev="0.66735992912586" stdev="1788.5726599722" sum="1340036" variance="3198992.16"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-14624.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-14624.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="2855228" time-revs="1" time-avg="2855228" mem-peak="106032296" mem-real="111673344" mem-final="100754384" comp-z-value="1.4017153774234" comp-deviation="0.55205183408848"/>
-          <iteration time-net="2843784" time-revs="1" time-avg="2843784" mem-peak="102528536" mem-real="107479040" mem-final="97250624" comp-z-value="0.37840359880708" comp-deviation="0.14903054080146"/>
-          <iteration time-net="2836367" time-revs="1" time-avg="2836367" mem-peak="102528536" mem-real="107479040" mem-final="97250624" comp-z-value="-0.28481760549186" comp-deviation="-0.11217261651327"/>
-          <iteration time-net="2841480" time-revs="1" time-avg="2841480" mem-peak="102528536" mem-real="107479040" mem-final="97250624" comp-z-value="0.17238207329747" comp-deviation="0.067890986473142"/>
-          <iteration time-net="2820902" time-revs="1" time-avg="2820902" mem-peak="102528536" mem-real="107479040" mem-final="97250624" comp-z-value="-1.6676834440361" comp-deviation="-0.65680074484985"/>
-          <stats max="2855228" mean="2839552.2" min="2820902" mode="2841860.3405088" rstdev="0.39384017824165" stdev="11183.297445745" sum="14197761" variance="125066141.76"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-14674.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-14674.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="1724849" time-revs="1" time-avg="1724849" mem-peak="94574128" mem-real="96468992" mem-final="90319184" comp-z-value="-1.4455612572795" comp-deviation="-0.42599468130123"/>
-          <iteration time-net="1740244" time-revs="1" time-avg="1740244" mem-peak="83975008" mem-real="88080384" mem-final="81223384" comp-z-value="1.5702691248511" comp-deviation="0.46274503555594"/>
-          <iteration time-net="1734354" time-revs="1" time-avg="1734354" mem-peak="83975008" mem-real="88080384" mem-final="81223384" comp-z-value="0.41643729953447" comp-deviation="0.12272055148392"/>
-          <iteration time-net="1729572" time-revs="1" time-avg="1729572" mem-peak="83975008" mem-real="88080384" mem-final="81223384" comp-z-value="-0.52034093283631" comp-deviation="-0.15334007378473"/>
-          <iteration time-net="1732122" time-revs="1" time-avg="1732122" mem-peak="83975008" mem-real="88080384" mem-final="81223384" comp-z-value="-0.020804234269706" comp-deviation="-0.0061308319538935"/>
-          <stats max="1740244" mean="1732228.2" min="1724849" mode="1731687.8747554" rstdev="0.29469154569274" stdev="5104.7300575055" sum="8661141" variance="26058268.96"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-14869.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-14869.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="321398" time-revs="1" time-avg="321398" mem-peak="65365664" mem-real="67108864" mem-final="62479832" comp-z-value="1.444784069892" comp-deviation="1.5569208912797"/>
-          <iteration time-net="316357" time-revs="1" time-avg="316357" mem-peak="65356920" mem-real="67108864" mem-final="62471088" comp-z-value="-0.033369140110751" comp-deviation="-0.035959083744847"/>
-          <iteration time-net="312649" time-revs="1" time-avg="312649" mem-peak="65356920" mem-real="67108864" mem-final="62471088" comp-z-value="-1.1206518424893" comp-deviation="-1.2076311621799"/>
-          <iteration time-net="312912" time-revs="1" time-avg="312912" mem-peak="65356920" mem-real="67108864" mem-final="62471088" comp-z-value="-1.0435333552386" comp-deviation="-1.1245271285692"/>
-          <iteration time-net="319038" time-revs="1" time-avg="319038" mem-peak="65356920" mem-real="67108864" mem-final="62471088" comp-z-value="0.75277026794665" comp-deviation="0.81119648321425"/>
-          <stats max="321398" mean="316470.8" min="312649" mode="314703.55968689" rstdev="1.0776149348021" stdev="3410.3366050875" sum="1582354" variance="11630395.76"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-14972-concat.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-14972-concat.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="1756857" time-revs="1" time-avg="1756857" mem-peak="128241624" mem-real="130023424" mem-final="96231992" comp-z-value="-0.48270652703122" comp-deviation="-0.27668235918369"/>
-          <iteration time-net="1776319" time-revs="1" time-avg="1776319" mem-peak="128241624" mem-real="130023424" mem-final="96231992" comp-z-value="1.4445941518384" comp-deviation="0.82802633818073"/>
-          <iteration time-net="1767783" time-revs="1" time-avg="1767783" mem-peak="128241624" mem-real="130023424" mem-final="96231992" comp-z-value="0.59928336184602" comp-deviation="0.34350298802644"/>
-          <iteration time-net="1746352" time-revs="1" time-avg="1746352" mem-peak="128241624" mem-real="130023424" mem-final="96231992" comp-z-value="-1.5230052440965" comp-deviation="-0.87297076046893"/>
-          <iteration time-net="1761346" time-revs="1" time-avg="1761346" mem-peak="128241624" mem-real="130023424" mem-final="96231992" comp-z-value="-0.03816574255658" comp-deviation="-0.021876206554524"/>
-          <stats max="1776319" mean="1761731.4" min="1746352" mode="1762185.8356165" rstdev="0.57318959593392" stdev="10098.061093101" sum="8808657" variance="101970837.84"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-14972.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-14972.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="2503201" time-revs="1" time-avg="2503201" mem-peak="90330000" mem-real="92274688" mem-final="64459264" comp-z-value="1.2414645477495" comp-deviation="1.5777824903704"/>
-          <iteration time-net="2429511" time-revs="1" time-avg="2429511" mem-peak="90330000" mem-real="92274688" mem-final="64459264" comp-z-value="-1.1114098844668" comp-deviation="-1.4124954744097"/>
-          <iteration time-net="2433368" time-revs="1" time-avg="2433368" mem-peak="90330000" mem-real="92274688" mem-final="64459264" comp-z-value="-0.98825834850456" comp-deviation="-1.2559816718563"/>
-          <iteration time-net="2457000" time-revs="1" time-avg="2457000" mem-peak="90330000" mem-real="92274688" mem-final="64459264" comp-z-value="-0.2337037470371" comp-deviation="-0.2970150703679"/>
-          <iteration time-net="2498517" time-revs="1" time-avg="2498517" mem-peak="90330000" mem-real="92274688" mem-final="64459264" comp-z-value="1.091907432259" comp-deviation="1.3877097262636"/>
-          <stats max="2503201" mean="2464319.4" min="2429511" mode="2443066.4990215" rstdev="1.2709041858912" stdev="31319.138408328" sum="12321597" variance="980888430.64"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-14996.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-14996.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="1523183" time-revs="1" time-avg="1523183" mem-peak="85193120" mem-real="88080384" mem-final="80167024" comp-z-value="1.9599908010154" comp-deviation="0.94841671854866"/>
-          <iteration time-net="1507424" time-revs="1" time-avg="1507424" mem-peak="84975728" mem-real="88080384" mem-final="79949632" comp-z-value="-0.19840414484229" comp-deviation="-0.096005454668611"/>
-          <iteration time-net="1504848" time-revs="1" time-avg="1504848" mem-peak="84975728" mem-real="88080384" mem-final="79949632" comp-z-value="-0.55122002024868" comp-deviation="-0.26672894716228"/>
-          <iteration time-net="1505939" time-revs="1" time-avg="1505939" mem-peak="84975728" mem-real="88080384" mem-final="79949632" comp-z-value="-0.40179373140226" comp-deviation="-0.19442330651376"/>
-          <iteration time-net="1502969" time-revs="1" time-avg="1502969" mem-peak="84975728" mem-real="88080384" mem-final="79949632" comp-z-value="-0.8085729045222" comp-deviation="-0.39125901020405"/>
-          <stats max="1523183" mean="1508872.6" min="1502969" mode="1505342.4637965" rstdev="0.48388835195417" stdev="7301.2587572281" sum="7544363" variance="53308379.44"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="bug-15061.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/bug-15061.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="714395" time-revs="1" time-avg="714395" mem-peak="92698080" mem-real="96468992" mem-final="90608544" comp-z-value="-0.7770457957573" comp-deviation="-0.27252148120352"/>
-          <iteration time-net="714939" time-revs="1" time-avg="714939" mem-peak="92683384" mem-real="96468992" mem-final="90593848" comp-z-value="-0.56051423500944" comp-deviation="-0.1965806525104"/>
-          <iteration time-net="713639" time-revs="1" time-avg="713639" mem-peak="92683384" mem-real="96468992" mem-final="90593848" comp-z-value="-1.0779609794437" comp-deviation="-0.37805689754911"/>
-          <iteration time-net="719290" time-revs="1" time-avg="719290" mem-peak="92683384" mem-real="96468992" mem-final="90593848" comp-z-value="1.1713402150162" comp-deviation="0.41080637992304"/>
-          <iteration time-net="719473" time-revs="1" time-avg="719473" mem-peak="92683384" mem-real="96468992" mem-final="90593848" comp-z-value="1.2441807951943" comp-deviation="0.43635265134003"/>
-          <stats max="719473" mean="716347.2" min="713639" mode="714540.92954991" rstdev="0.35071482619364" stdev="2512.335837423" sum="3581736" variance="6311831.36"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="finite-types-optional-keys-blowup.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/finite-types-optional-keys-blowup.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="7316" time-revs="1" time-avg="7316" mem-peak="59818096" mem-real="62914560" mem-final="59463064" comp-z-value="0.13045694482644" comp-deviation="0.12865080885774"/>
-          <iteration time-net="7270" time-revs="1" time-avg="7270" mem-peak="59809640" mem-real="62914560" mem-final="59454608" comp-z-value="-0.50794938091999" comp-deviation="-0.50091697916952"/>
-          <iteration time-net="7441" time-revs="1" time-avg="7441" mem-peak="59809640" mem-real="62914560" mem-final="59454608" comp-z-value="1.8652567430504" comp-deviation="1.8394328415405"/>
-          <iteration time-net="7234" time-revs="1" time-avg="7234" mem-peak="59809640" mem-real="62914560" mem-final="59454608" comp-z-value="-1.0075717228085" comp-deviation="-0.99362220458216"/>
-          <iteration time-net="7272" time-revs="1" time-avg="7272" mem-peak="59809640" mem-real="62914560" mem-final="59454608" comp-z-value="-0.48019258414841" comp-deviation="-0.4735444666466"/>
-          <stats max="7441" mean="7306.6" min="7234" mode="7273.2935420743" rstdev="0.98615530992925" stdev="72.05442387529" sum="36533" variance="5191.84"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="flatten-types-optional-keys-blowup.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/flatten-types-optional-keys-blowup.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="2094" time-revs="1" time-avg="2094" mem-peak="60183216" mem-real="62914560" mem-final="59953784" comp-z-value="0.45816212899272" comp-deviation="0.34502587694076"/>
-          <iteration time-net="2111" time-revs="1" time-avg="2111" mem-peak="60174760" mem-real="62914560" mem-final="59945328" comp-z-value="1.5399338224478" comp-deviation="1.1596703086065"/>
-          <iteration time-net="2084" time-revs="1" time-avg="2084" mem-peak="60174760" mem-real="62914560" mem-final="59945328" comp-z-value="-0.17817416127496" comp-deviation="-0.13417672992142"/>
-          <iteration time-net="2063" time-revs="1" time-avg="2063" mem-peak="60174760" mem-real="62914560" mem-final="59945328" comp-z-value="-1.5144803708371" comp-deviation="-1.140502204332"/>
-          <iteration time-net="2082" time-revs="1" time-avg="2082" mem-peak="60174760" mem-real="62914560" mem-final="59945328" comp-z-value="-0.3054414193285" comp-deviation="-0.23001725129386"/>
-          <stats max="2111" mean="2086.8" min="2063" mode="2085.9197651663" rstdev="0.75306502896543" stdev="15.714961024451" sum="10434" variance="246.96"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="implode-optional-keys-blowup.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/implode-optional-keys-blowup.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="2583" time-revs="1" time-avg="2583" mem-peak="74680176" mem-real="77594624" mem-final="74438464" comp-z-value="1.9001030270236" comp-deviation="2.7936962750716"/>
-          <iteration time-net="2479" time-revs="1" time-avg="2479" mem-peak="74673224" mem-real="77594624" mem-final="74431512" comp-z-value="-0.9148644204188" comp-deviation="-1.3451130213308"/>
-          <iteration time-net="2492" time-revs="1" time-avg="2492" mem-peak="74673224" mem-real="77594624" mem-final="74431512" comp-z-value="-0.56299348948849" comp-deviation="-0.82776185928049"/>
-          <iteration time-net="2515" time-revs="1" time-avg="2515" mem-peak="74673224" mem-real="77594624" mem-final="74431512" comp-z-value="0.059547388311277" comp-deviation="0.087551735116198"/>
-          <iteration time-net="2495" time-revs="1" time-avg="2495" mem-peak="74673224" mem-real="77594624" mem-final="74431512" comp-z-value="-0.48179250542765" comp-deviation="-0.70837312957658"/>
-          <stats max="2583" mean="2512.8" min="2479" mode="2495.0782778865" rstdev="1.4702867346345" stdev="36.945365067895" sum="12564" variance="1364.96"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="nullsafe-chain-walk.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/nullsafe-chain-walk.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="2210486" time-revs="1" time-avg="2210486" mem-peak="108893824" mem-real="113246208" mem-final="91395072" comp-z-value="1.3088911025551" comp-deviation="1.4151599121433"/>
-          <iteration time-net="2196703" time-revs="1" time-avg="2196703" mem-peak="108853624" mem-real="113246208" mem-final="91354872" comp-z-value="0.7240244428095" comp-deviation="0.78280795466922"/>
-          <iteration time-net="2177950" time-revs="1" time-avg="2177950" mem-peak="108853624" mem-real="113246208" mem-final="91354872" comp-z-value="-0.071738777839801" comp-deviation="-0.077563245977346"/>
-          <iteration time-net="2171753" time-revs="1" time-avg="2171753" mem-peak="108853624" mem-real="113246208" mem-final="91354872" comp-z-value="-0.33470175327646" comp-deviation="-0.36187617353063"/>
-          <iteration time-net="2141311" time-revs="1" time-avg="2141311" mem-peak="108853624" mem-real="113246208" mem-final="91354872" comp-z-value="-1.6264750142484" comp-deviation="-1.7585284473046"/>
-          <stats max="2210486" mean="2179640.6" min="2141311" mode="2185036.0978474" rstdev="1.0811899549021" stdev="23566.055220168" sum="10898203" variance="555358958.64"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="or-chain-falsey-blowup.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/or-chain-falsey-blowup.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="31201" time-revs="1" time-avg="31201" mem-peak="61200824" mem-real="65011712" mem-final="59813088" comp-z-value="-1.6935127469172" comp-deviation="-0.91586375097652"/>
-          <iteration time-net="31528" time-revs="1" time-avg="31528" mem-peak="61192432" mem-real="65011712" mem-final="59804600" comp-z-value="0.2266629404681" comp-deviation="0.12258093199616"/>
-          <iteration time-net="31413" time-revs="1" time-avg="31413" mem-peak="61192432" mem-real="65011712" mem-final="59804600" comp-z-value="-0.44862820341358" comp-deviation="-0.24262132654163"/>
-          <iteration time-net="31627" time-revs="1" time-avg="31627" mem-peak="61192432" mem-real="65011712" mem-final="59804600" comp-z-value="0.80800053389668" comp-deviation="0.43697244152"/>
-          <iteration time-net="31678" time-revs="1" time-avg="31678" mem-peak="61192432" mem-real="65011712" mem-final="59804600" comp-z-value="1.1074774759659" comp-deviation="0.59893170400198"/>
-          <stats max="31678" mean="31489.4" min="31201" mode="31569.718199609" rstdev="0.54080711978326" stdev="170.29691717703" sum="157447" variance="29001.04"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="or-chain-resolve-type-blowup.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/or-chain-resolve-type-blowup.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="2293663" time-revs="1" time-avg="2293663" mem-peak="74898376" mem-real="79691776" mem-final="68749352" comp-z-value="-0.4424320816707" comp-deviation="-0.39948540568595"/>
-          <iteration time-net="2331233" time-revs="1" time-avg="2331233" mem-peak="74114040" mem-real="77594624" mem-final="67965016" comp-z-value="1.36440444474" comp-deviation="1.2319623411314"/>
-          <iteration time-net="2279830" time-revs="1" time-avg="2279830" mem-peak="74114040" mem-real="77594624" mem-final="67965016" comp-z-value="-1.1076961133406" comp-deviation="-1.0001725678293"/>
-          <iteration time-net="2323955" time-revs="1" time-avg="2323955" mem-peak="74114040" mem-real="77594624" mem-final="67965016" comp-z-value="1.0143869776328" comp-deviation="0.91592090644053"/>
-          <iteration time-net="2285632" time-revs="1" time-avg="2285632" mem-peak="74114040" mem-real="77594624" mem-final="67965016" comp-z-value="-0.82866322736153" comp-deviation="-0.74822527405674"/>
-          <stats max="2331233" mean="2302862.6" min="2279830" mode="2288581.5870841" rstdev="0.90293046602188" stdev="20793.248006023" sum="11514313" variance="432359162.64"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="phpdoc-inheritance-speedup.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/phpdoc-inheritance-speedup.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="373099" time-revs="1" time-avg="373099" mem-peak="95025544" mem-real="96468992" mem-final="89596024" comp-z-value="-1.6424018956061" comp-deviation="-1.7660049962297"/>
-          <iteration time-net="379698" time-revs="1" time-avg="379698" mem-peak="92341288" mem-real="94371840" mem-final="86910488" comp-z-value="-0.026543275409807" comp-deviation="-0.028540856604845"/>
-          <iteration time-net="385522" time-revs="1" time-avg="385522" mem-peak="92341288" mem-real="94371840" mem-final="86910488" comp-z-value="1.3995456174563" comp-deviation="1.5048719558175"/>
-          <iteration time-net="381956" time-revs="1" time-avg="381956" mem-peak="92341288" mem-real="94371840" mem-final="86910488" comp-z-value="0.52636000757295" comp-deviation="0.56597255865093"/>
-          <iteration time-net="378757" time-revs="1" time-avg="378757" mem-peak="92341288" mem-real="94371840" mem-final="86910488" comp-z-value="-0.25696045401334" comp-deviation="-0.27629866163393"/>
-          <stats max="385522" mean="379806.4" min="373099" mode="380513.90215264" rstdev="1.0752575243333" stdev="4083.8968938993" sum="1899032" variance="16678213.84"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="phpdoc-intersection-blowup.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/phpdoc-intersection-blowup.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="4974" time-revs="1" time-avg="4974" mem-peak="63948304" mem-real="65011712" mem-final="63581888" comp-z-value="0.48524747941549" comp-deviation="0.25396057564398"/>
-          <iteration time-net="5000" time-revs="1" time-avg="5000" mem-peak="63924888" mem-real="65011712" mem-final="63558472" comp-z-value="1.4865518020188" comp-deviation="0.77800620792519"/>
-          <iteration time-net="4925" time-revs="1" time-avg="4925" mem-peak="63924888" mem-real="65011712" mem-final="63558472" comp-z-value="-1.4018260516447" comp-deviation="-0.73366388519369"/>
-          <iteration time-net="4966" time-revs="1" time-avg="4966" mem-peak="63924888" mem-real="65011712" mem-final="63558472" comp-z-value="0.17715384169138" comp-deviation="0.092715765711299"/>
-          <iteration time-net="4942" time-revs="1" time-avg="4942" mem-peak="63924888" mem-real="65011712" mem-final="63558472" comp-z-value="-0.74712707148095" comp-deviation="-0.39101866408674"/>
-          <stats max="5000" mean="4961.4" min="4925" mode="4963.3072407044" rstdev="0.52336299809304" stdev="25.966131787388" sum="24807" variance="674.24"/>
-        </variant>
-        <variant sleep="0" output-time-unit="microseconds" output-time-precision="" output-mode="time" revs="1" warmup="1" retry-threshold="10">
-          <parameter-set name="process-called-method-infinite-loop.php">
-            <parameter name="0" value="/home/runner/work/phpstan-src/phpstan-src/tests/bench/data/process-called-method-infinite-loop.php" type="string"/>
-          </parameter-set>
-          <iteration time-net="13859" time-revs="1" time-avg="13859" mem-peak="96012712" mem-real="98566144" mem-final="90815144" comp-z-value="1.1001961349928" comp-deviation="0.47996055913231"/>
-          <iteration time-net="13708" time-revs="1" time-avg="13708" mem-peak="95938112" mem-real="98566144" mem-final="90548736" comp-z-value="-1.4093146865164" comp-deviation="-0.61481352589756"/>
-          <iteration time-net="13786" time-revs="1" time-avg="13786" mem-peak="95938112" mem-real="98566144" mem-final="90548736" comp-z-value="-0.11301108335272" comp-deviation="-0.049301084623856"/>
-          <iteration time-net="13861" time-revs="1" time-avg="13861" mem-peak="95938112" mem-real="98566144" mem-final="90548736" comp-z-value="1.1334346889201" comp-deviation="0.49446087813932"/>
-          <iteration time-net="13750" time-revs="1" time-avg="13750" mem-peak="95938112" mem-real="98566144" mem-final="90548736" comp-z-value="-0.71130505404367" comp-deviation="-0.31030682675018"/>
-          <stats max="13861" mean="13792.8" min="13708" mode="13774.769080235" rstdev="0.43624999567504" stdev="60.171089403467" sum="68964" variance="3620.56"/>
-        </variant>
-      </subject>
-    </benchmark>
-    <result key="time" class="PhpBench\Model\Result\TimeResult"/>
-    <result key="mem" class="PhpBench\Model\Result\MemoryResult"/>
-    <result key="comp" class="PhpBench\Model\Result\ComputedResult"/>
-    <result key="reject" class="PhpBench\Model\Result\RejectionCountResult"/>
-  </suite>
-</phpbench>
diff --git a/tests/bench/storage/baseline-8.5.xml b/tests/bench/storage/baseline.xml
similarity index 100%
rename from tests/bench/storage/baseline-8.5.xml
rename to tests/bench/storage/baseline.xml

From b2bd56c268a948e9b29ae08500a409832cab5f8d Mon Sep 17 00:00:00 2001
From: Ondrej Mirtes <ondrej@mirtes.cz>
Date: Mon, 28 Sep 2026 13:20:51 +0200
Subject: [PATCH 6/9] Skip keys-superset checks of arrays differing in constant
 scalar values
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Since unions of constant arrays with many keys stopped degrading
(e606ca20e3), reduceArrays() asks isKeysSupersetOf() in both directions of
every pair of arrays sharing a key - a union of n same-shaped records
costs n² checks of their value types. The bench's bug-12671 made 654K of
them for a few dozen unions of state tuples, none of which merged.

Each array's keys holding a single constant scalar are collected once per
call. Two such values that differ are disjoint, and isKeysSupersetOf() of
arrays without real unsealed extras lets at most one key's values be
unrelated (only when both have the same number of keys, two or more) - a
pair differing in more is skipped without asking. Merged arrays drop their
collected values.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y5roddukgqaSAB2BT765UX
---
 src/Type/TypeCombinator.php              |  88 ++++++++++++++++++++
 turbo-ext/src/TypeCombinator.cpp         | 100 ++++++++++++++++++++++-
 turbo-ext/src/generated/TypeCombinator.h |  76 +++++++++--------
 3 files changed, 230 insertions(+), 34 deletions(-)

diff --git a/src/Type/TypeCombinator.php b/src/Type/TypeCombinator.php
index 6508e03ce58..9921d0dd991 100644
--- a/src/Type/TypeCombinator.php
+++ b/src/Type/TypeCombinator.php
@@ -1385,6 +1385,69 @@ public static function countConstantArrayValueTypes(array $types): int
 		return $constantArrayValuesCount;
 	}
 
+	/**
+	 * The value at each key of the array that is a single constant scalar, null
+	 * when the array has real unsealed extras - its keys-supersets are then not
+	 * decided by the known keys alone.
+	 *
+	 * @return array<int|string, scalar|null>|null
+	 */
+	private static function getConstantScalarValuesByKey(ConstantArrayType $array): ?array
+	{
+		$unsealed = $array->getUnsealedTypes();
+		if ($unsealed !== null && !($unsealed[0] instanceof NeverType && $unsealed[0]->isExplicit())) {
+			return null;
+		}
+
+		$values = [];
+		$valueTypes = $array->getValueTypes();
+		foreach ($array->getKeyTypes() as $i => $keyType) {
+			if (!$valueTypes[$i]->isConstantScalarValue()->yes()) {
+				continue;
+			}
+			$constantScalarValues = $valueTypes[$i]->getConstantScalarValues();
+			if (count($constantScalarValues) !== 1) {
+				continue;
+			}
+			$values[$keyType->getValue()] = $constantScalarValues[0];
+		}
+
+		return $values;
+	}
+
+	/**
+	 * Whether two arrays differ in enough keys holding different single constant
+	 * scalars that neither can be a keys-superset of the other: each such key
+	 * pairs two disjoint values, and ConstantArrayType::isKeysSupersetOf() lets
+	 * at most one key's values be unrelated - only when both arrays have the
+	 * same number of keys, two or more.
+	 *
+	 * @param array<int|string, scalar|null>|null $a
+	 * @param array<int|string, scalar|null>|null $b
+	 */
+	private static function haveDisjointConstantScalarValues(?array $a, ?array $b, bool $oneUnrelatedKeyAllowed): bool
+	{
+		if ($a === null || $b === null) {
+			return false;
+		}
+		if (count($a) > count($b)) {
+			[$a, $b] = [$b, $a];
+		}
+
+		$differing = 0;
+		foreach ($a as $key => $value) {
+			if (!array_key_exists($key, $b) || $b[$key] === $value) {
+				continue;
+			}
+			$differing++;
+			if ($differing >= 2 || !$oneUnrelatedKeyAllowed) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
 	/**
 	 * @param list<Type> $constantArrays
 	 * @return list<Type>
@@ -1431,6 +1494,15 @@ private static function reduceArrays(array $constantArrays, bool $preserveTagged
 			}
 		}
 
+		// the single constant scalar value at each key of the arrays without
+		// real unsealed extras (whose supersets the key/value shape decides)
+		$constantScalarValues = [];
+		if ($preserveTaggedUnions) {
+			foreach ($arraysToProcess as $i => $arrayToProcess) {
+				$constantScalarValues[$i] = self::getConstantScalarValuesByKey($arrayToProcess);
+			}
+		}
+
 		$eligibleCombinations = [];
 
 		foreach ($arraysToProcessPerKey as $arrays) {
@@ -1468,17 +1540,32 @@ private static function reduceArrays(array $constantArrays, bool $preserveTagged
 					$unionValueType = self::union($iValueType, $jValueType);
 					if (!$unionValueType instanceof UnionType) {
 						$arraysToProcess[$j] = $arraysToProcess[$j]->mergeWith($arraysToProcess[$i]);
+						$constantScalarValues[$j] = null;
 						unset($arraysToProcess[$i]);
 						continue 2;
 					}
 				}
 
+				if (
+					$preserveTaggedUnions
+					&& self::haveDisjointConstantScalarValues(
+						$constantScalarValues[$i] ?? null,
+						$constantScalarValues[$j] ?? null,
+						count($arraysToProcess[$i]->getKeyTypes()) === count($arraysToProcess[$j]->getKeyTypes())
+							&& count($arraysToProcess[$i]->getKeyTypes()) >= 2,
+					)
+				) {
+					// neither array is a keys-superset of the other
+					continue;
+				}
+
 				if (
 					$preserveTaggedUnions
 					&& $overlappingKeysCount === count($arraysToProcess[$i]->getKeyTypes())
 					&& $arraysToProcess[$j]->isKeysSupersetOf($arraysToProcess[$i])
 				) {
 					$arraysToProcess[$j] = $arraysToProcess[$j]->mergeWith($arraysToProcess[$i]);
+					$constantScalarValues[$j] = null;
 					unset($arraysToProcess[$i]);
 					continue 2;
 				}
@@ -1489,6 +1576,7 @@ private static function reduceArrays(array $constantArrays, bool $preserveTagged
 					&& $arraysToProcess[$i]->isKeysSupersetOf($arraysToProcess[$j])
 				) {
 					$arraysToProcess[$i] = $arraysToProcess[$i]->mergeWith($arraysToProcess[$j]);
+					$constantScalarValues[$i] = null;
 					unset($arraysToProcess[$j]);
 					continue 1;
 				}
diff --git a/turbo-ext/src/TypeCombinator.cpp b/turbo-ext/src/TypeCombinator.cpp
index 6b0a263ec42..f744bbbedb2 100644
--- a/turbo-ext/src/TypeCombinator.cpp
+++ b/turbo-ext/src/TypeCombinator.cpp
@@ -2449,6 +2449,77 @@ class TypeCombinator
 		return callBool(a, PT_LC("iskeyssupersetof"), 1, b);
 	}
 
+	/* Mirrors getConstantScalarValuesByKey(): key => the single constant
+	 * scalar value there, IS_NULL when the array has real unsealed extras;
+	 * UNDEF = pending exception */
+	static zv::Val constantScalarValuesByKey(zval *array)
+	{
+		zv::Val unsealed = call(array, PT_LC("getunsealedtypes"));
+		PT_FAIL_IF_UNDEF(unsealed);
+		if (!isNull(unsealed)) {
+			zval *unsealedKey = indexOf(unsealed.raw(), 0);
+			if (UNEXPECTED(unsealedKey == NULL)) {
+				zend_throw_error(NULL, "Undefined array key 0");
+				return zv::Val();
+			}
+			int explicitNever = isExplicitNever(unsealedKey);
+			PT_FAIL_IF_NEG(explicitNever);
+			if (!explicitNever) return zv::Val::null();
+		}
+
+		zv::Arr values = zv::Arr::create(0);
+		zv::Val valueTypes = call(array, PT_LC("getvaluetypes"));
+		PT_FAIL_IF_UNDEF(valueTypes);
+		zv::Val keyTypes = call(array, PT_LC("getkeytypes"));
+		PT_FAIL_IF_UNDEF(keyTypes);
+		for (zv::ArrayEntry keyEntry : zv::ArrRef(keyTypes.raw())) {
+			zval *valueType = zend_hash_index_find(Z_ARRVAL_P(valueTypes.raw()), keyEntry.indexKey());
+			if (UNEXPECTED(valueType == NULL)) {
+				zend_throw_error(NULL, "Undefined array key " ZEND_ULONG_FMT, keyEntry.indexKey());
+				return zv::Val();
+			}
+			zend_long isConstantScalar = callTrinary(valueType, PT_LC("isconstantscalarvalue"));
+			PT_FAIL_IF_NEG(isConstantScalar);
+			if (isConstantScalar != PT_TRI_YES) continue;
+			zv::Val constantScalarValues = call(valueType, PT_LC("getconstantscalarvalues"));
+			PT_FAIL_IF_UNDEF(constantScalarValues);
+			if (countOf(constantScalarValues.raw()) != 1) continue;
+			zv::Val keyValue = call(keyEntry.value().raw(), PT_LC("getvalue"));
+			PT_FAIL_IF_UNDEF(keyValue);
+			zval value;
+			ZVAL_COPY(&value, indexOf(constantScalarValues.raw(), 0));
+			if (UNEXPECTED(!symtableSet(values.table(), keyValue.raw(), &value))) return zv::Val();
+		}
+		return zv::Val(std::move(values));
+	}
+
+	/* Mirrors haveDisjointConstantScalarValues() */
+	static bool haveDisjointConstantScalarValues(zval *a, zval *b, bool oneUnrelatedKeyAllowed)
+	{
+		if (a == NULL || b == NULL || Z_TYPE_P(a) != IS_ARRAY || Z_TYPE_P(b) != IS_ARRAY) return false;
+		if (zend_hash_num_elements(Z_ARRVAL_P(a)) > zend_hash_num_elements(Z_ARRVAL_P(b))) std::swap(a, b);
+		int differing = 0;
+		zend_ulong index;
+		zend_string *key;
+		zval *value;
+		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(a), index, key, value) {
+			zval *other = key != NULL ? zend_hash_find(Z_ARRVAL_P(b), key) : zend_hash_index_find(Z_ARRVAL_P(b), index);
+			if (other == NULL || zend_is_identical(other, value)) continue;
+			differing++;
+			if (differing >= 2 || !oneUnrelatedKeyAllowed) return true;
+		} ZEND_HASH_FOREACH_END();
+		return false;
+	}
+
+	/* $constantScalarValues[$index] = null */
+	static void forgetConstantScalarValues(zv::Arr &constantScalarValues, zend_ulong index)
+	{
+		zval null;
+		ZVAL_NULL(&null);
+		constantScalarValues.separate();
+		zend_hash_index_update(constantScalarValues.table(), index, &null);
+	}
+
 	/* private static reduceArrays(list<Type> $constantArrays, bool $preserveTaggedUnions): list<Type> */
 	static zv::Val reduceArrays(zval *constantArrays, bool preserveTaggedUnions)
 	{
@@ -2512,6 +2583,19 @@ class TypeCombinator
 			}
 		}
 
+		/* the single constant scalar value at each key of the arrays without
+		 * real unsealed extras */
+		zv::Arr constantScalarValues = zv::Arr::create(0);
+		if (preserveTaggedUnions) {
+			for (zv::ArrayEntry entry : zv::ArrRef(arraysToProcess.raw())) {
+				zv::Val values = constantScalarValuesByKey(entry.value().raw());
+				PT_FAIL_IF_UNDEF(values);
+				zval v = values.take();
+				constantScalarValues.separate();
+				zend_hash_index_update(constantScalarValues.table(), entry.indexKey(), &v);
+			}
+		}
+
 		zv::Arr eligibleCombinations = zv::Arr::create(0);
 		for (zv::ArrayEntry entry : zv::ArrRef(arraysToProcessPerKey.raw())) {
 			HashTable *arrays = Z_ARRVAL_P(entry.value().raw());
@@ -2571,27 +2655,39 @@ class TypeCombinator
 						PT_FAIL_IF_UNDEF(unionValueType);
 						if (!isInstance(unionValueType.raw(), pt_ce_union_type)) {
 							if (UNEXPECTED(!mergeInto(arraysToProcess, j, i))) return zv::Val();
+							forgetConstantScalarValues(constantScalarValues, j);
 							break;
 						}
 					}
 				}
 
+				zend_long jKeysCount = keyTypesCount(arrayAt(arraysToProcess, j));
+				PT_FAIL_IF_NEG(jKeysCount);
+				if (preserveTaggedUnions
+					&& haveDisjointConstantScalarValues(
+						zend_hash_index_find(constantScalarValues.table(), i),
+						zend_hash_index_find(constantScalarValues.table(), j),
+						iKeysCount == jKeysCount && iKeysCount >= 2)) {
+					/* neither array is a keys-superset of the other */
+					continue;
+				}
+
 				if (preserveTaggedUnions && overlappingKeysCount == iKeysCount) {
 					int superset = isKeysSupersetOf(arrayAt(arraysToProcess, j), arrayAt(arraysToProcess, i));
 					PT_FAIL_IF_NEG(superset);
 					if (superset) {
 						if (UNEXPECTED(!mergeInto(arraysToProcess, j, i))) return zv::Val();
+						forgetConstantScalarValues(constantScalarValues, j);
 						break;
 					}
 				}
 
-				zend_long jKeysCount = keyTypesCount(arrayAt(arraysToProcess, j));
-				PT_FAIL_IF_NEG(jKeysCount);
 				if (preserveTaggedUnions && overlappingKeysCount == jKeysCount) {
 					int superset = isKeysSupersetOf(arrayAt(arraysToProcess, i), arrayAt(arraysToProcess, j));
 					PT_FAIL_IF_NEG(superset);
 					if (superset) {
 						if (UNEXPECTED(!mergeInto(arraysToProcess, i, j))) return zv::Val();
+						forgetConstantScalarValues(constantScalarValues, i);
 						continue;
 					}
 				}
diff --git a/turbo-ext/src/generated/TypeCombinator.h b/turbo-ext/src/generated/TypeCombinator.h
index 056b917e82d..613d52592e3 100644
--- a/turbo-ext/src/generated/TypeCombinator.h
+++ b/turbo-ext/src/generated/TypeCombinator.h
@@ -55,20 +55,24 @@ inline constexpr char strings[] =
 	"processArrayTypes\0" /* 472 */
 	"optimizeConstantArrays\0" /* 490 */
 	"countConstantArrayValueTypes\0" /* 513 */
-	"constantArrays\0" /* 542 */
-	"preserveTaggedUnions\0" /* 557 */
-	"reduceArrays\0" /* 578 */
-	"PHPStan\\Type\\UnionType\0" /* 591 */
-	"intersectFiniteUnions\0" /* 614 */
-	"finiteUnionMembers\0" /* 636 */
-	"intersect\0" /* 655 */
-	"doIntersect\0" /* 665 */
-	"PHPStan\\Type\\Constant\\ConstantArrayType\0" /* 677 */
-	"intersectDefiniteConstantArrays\0" /* 717 */
-	"PHPStan\\Type\\IntersectionType\0" /* 749 */
-	"mergeIntersectionsForUnion\0" /* 779 */
-	"removeFalsey\0" /* 806 */
-	"removeTruthy"; /* 819 */
+	"array\0" /* 542 */
+	"PHPStan\\Type\\Constant\\ConstantArrayType\0" /* 548 */
+	"getConstantScalarValuesByKey\0" /* 588 */
+	"oneUnrelatedKeyAllowed\0" /* 617 */
+	"haveDisjointConstantScalarValues\0" /* 640 */
+	"constantArrays\0" /* 673 */
+	"preserveTaggedUnions\0" /* 688 */
+	"reduceArrays\0" /* 709 */
+	"PHPStan\\Type\\UnionType\0" /* 722 */
+	"intersectFiniteUnions\0" /* 745 */
+	"finiteUnionMembers\0" /* 767 */
+	"intersect\0" /* 786 */
+	"doIntersect\0" /* 796 */
+	"intersectDefiniteConstantArrays\0" /* 808 */
+	"PHPStan\\Type\\IntersectionType\0" /* 840 */
+	"mergeIntersectionsForUnion\0" /* 870 */
+	"removeFalsey\0" /* 897 */
+	"removeTruthy"; /* 910 */
 inline constexpr reg::PackedArg args[] = {
 	reg::packed(0, MAY_BE_VOID), /* clearCache return */
 	reg::packed(12, 0, 17), /* addNull $type */
@@ -118,23 +122,29 @@ inline constexpr reg::PackedArg args[] = {
 	reg::packed(0, MAY_BE_ARRAY), /* optimizeConstantArrays return */
 	reg::packed(126, MAY_BE_ARRAY), /* countConstantArrayValueTypes $types */
 	reg::packed(0, MAY_BE_LONG), /* countConstantArrayValueTypes return */
-	reg::packed(542, MAY_BE_ARRAY), /* reduceArrays $constantArrays */
-	reg::packed(557, MAY_BE_BOOL), /* reduceArrays $preserveTaggedUnions */
+	reg::packed(542, 0, 548), /* getConstantScalarValuesByKey $array */
+	reg::packed(0, MAY_BE_NULL | MAY_BE_ARRAY), /* getConstantScalarValuesByKey return */
+	reg::packed(164, MAY_BE_NULL | MAY_BE_ARRAY), /* haveDisjointConstantScalarValues $a */
+	reg::packed(166, MAY_BE_NULL | MAY_BE_ARRAY), /* haveDisjointConstantScalarValues $b */
+	reg::packed(617, MAY_BE_BOOL), /* haveDisjointConstantScalarValues $oneUnrelatedKeyAllowed */
+	reg::packed(0, MAY_BE_BOOL), /* haveDisjointConstantScalarValues return */
+	reg::packed(673, MAY_BE_ARRAY), /* reduceArrays $constantArrays */
+	reg::packed(688, MAY_BE_BOOL), /* reduceArrays $preserveTaggedUnions */
 	reg::packed(0, MAY_BE_ARRAY), /* reduceArrays return */
-	reg::packed(164, 0, 591), /* intersectFiniteUnions $a */
-	reg::packed(166, 0, 591), /* intersectFiniteUnions $b */
+	reg::packed(164, 0, 722), /* intersectFiniteUnions $a */
+	reg::packed(166, 0, 722), /* intersectFiniteUnions $b */
 	reg::packed(0, MAY_BE_NULL, 17), /* intersectFiniteUnions return */
-	reg::packed(132, 0, 591), /* finiteUnionMembers $union */
+	reg::packed(132, 0, 722), /* finiteUnionMembers $union */
 	reg::packed(0, MAY_BE_NULL | MAY_BE_ARRAY), /* finiteUnionMembers return */
 	reg::packed(126, 0, 17, false, true), /* intersect $types */
 	reg::packed(0, 0, 17), /* intersect return */
 	reg::packed(126, 0, 17, false, true), /* doIntersect $types */
 	reg::packed(0, 0, 17), /* doIntersect return */
-	reg::packed(164, 0, 677), /* intersectDefiniteConstantArrays $a */
-	reg::packed(166, 0, 677), /* intersectDefiniteConstantArrays $b */
+	reg::packed(164, 0, 548), /* intersectDefiniteConstantArrays $a */
+	reg::packed(166, 0, 548), /* intersectDefiniteConstantArrays $b */
 	reg::packed(0, 0, 17), /* intersectDefiniteConstantArrays return */
-	reg::packed(164, 0, 749), /* mergeIntersectionsForUnion $a */
-	reg::packed(166, 0, 749), /* mergeIntersectionsForUnion $b */
+	reg::packed(164, 0, 840), /* mergeIntersectionsForUnion $a */
+	reg::packed(166, 0, 840), /* mergeIntersectionsForUnion $b */
 	reg::packed(0, MAY_BE_NULL, 17), /* mergeIntersectionsForUnion return */
 	reg::packed(12, 0, 17), /* removeFalsey $type */
 	reg::packed(0, 0, 17), /* removeFalsey return */
@@ -167,15 +177,17 @@ inline constexpr sigtab::Sig findEmptyArrayNextToOversizedArray = { { 437 /* fin
 inline constexpr sigtab::Sig processArrayTypes = { { 472 /* processArrayTypes */, 1, 42, 1, 43, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
 inline constexpr sigtab::Sig optimizeConstantArrays = { { 490 /* optimizeConstantArrays */, 1, 44, 1, 45, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
 inline constexpr sigtab::Sig countConstantArrayValueTypes = { { 513 /* countConstantArrayValueTypes */, 1, 46, 1, 47, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig reduceArrays = { { 578 /* reduceArrays */, 2, 48, 2, 50, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig intersectFiniteUnions = { { 614 /* intersectFiniteUnions */, 2, 51, 2, 53, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig finiteUnionMembers = { { 636 /* finiteUnionMembers */, 1, 54, 1, 55, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig intersect = { { 655 /* intersect */, 0, 56, 1, 57, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig doIntersect = { { 665 /* doIntersect */, 0, 58, 1, 59, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig intersectDefiniteConstantArrays = { { 717 /* intersectDefiniteConstantArrays */, 2, 60, 2, 62, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig mergeIntersectionsForUnion = { { 779 /* mergeIntersectionsForUnion */, 2, 63, 2, 65, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig removeFalsey = { { 806 /* removeFalsey */, 1, 66, 1, 67, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig removeTruthy = { { 819 /* removeTruthy */, 1, 68, 1, 69, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig getConstantScalarValuesByKey = { { 588 /* getConstantScalarValuesByKey */, 1, 48, 1, 49, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig haveDisjointConstantScalarValues = { { 640 /* haveDisjointConstantScalarValues */, 3, 50, 3, 53, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig reduceArrays = { { 709 /* reduceArrays */, 2, 54, 2, 56, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig intersectFiniteUnions = { { 745 /* intersectFiniteUnions */, 2, 57, 2, 59, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig finiteUnionMembers = { { 767 /* finiteUnionMembers */, 1, 60, 1, 61, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig intersect = { { 786 /* intersect */, 0, 62, 1, 63, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig doIntersect = { { 796 /* doIntersect */, 0, 64, 1, 65, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig intersectDefiniteConstantArrays = { { 808 /* intersectDefiniteConstantArrays */, 2, 66, 2, 68, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig mergeIntersectionsForUnion = { { 870 /* mergeIntersectionsForUnion */, 2, 69, 2, 71, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig removeFalsey = { { 897 /* removeFalsey */, 1, 72, 1, 73, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig removeTruthy = { { 910 /* removeTruthy */, 1, 74, 1, 75, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } };
 } // namespace sig
 
 } // namespace ptdecl::TypeCombinator

From d97ab9b9f3d3583084fee53c967150bf043b7cd2 Mon Sep 17 00:00:00 2001
From: Ondrej Mirtes <ondrej@mirtes.cz>
Date: Mon, 28 Sep 2026 13:21:08 +0200
Subject: [PATCH 7/9] Intersect finite benevolent unions by identity too

intersect() of two unions of finite, mutually disjoint values takes their
identity-keyed set intersection instead of distributing one over the other
- but only for the exact UnionType class. A benevolent union of constant
strings (the values of a large constant array read with an unknown key)
narrowed by a falsy check was distributed member by member: 890 constant
strings times the seven falsy values, then a union rebuilt from the result,
for every condition of a conditional expression holder.

A benevolent union takes the fast path too: it is the operand the
distribution walks first, so it goes first here and the result keeps the
benevolence the distribution would give it.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y5roddukgqaSAB2BT765UX
---
 src/Type/TypeCombinator.php              | 27 +++++++++----
 turbo-ext/src/TypeCombinator.cpp         | 25 +++++++++---
 turbo-ext/src/generated/TypeCombinator.h | 50 +++++++++++++-----------
 3 files changed, 66 insertions(+), 36 deletions(-)

diff --git a/src/Type/TypeCombinator.php b/src/Type/TypeCombinator.php
index 9921d0dd991..6d4ba2dd624 100644
--- a/src/Type/TypeCombinator.php
+++ b/src/Type/TypeCombinator.php
@@ -1744,6 +1744,14 @@ private static function reduceArrays(array $constantArrays, bool $preserveTagged
 	 * not such a value, in which case the caller falls back to the general A & (B|C)
 	 * distribution.
 	 */
+	/** @phpstan-assert-if-true UnionType $type */
+	private static function isPlainOrBenevolentUnion(Type $type): bool
+	{
+		$class = get_class($type);
+
+		return $class === UnionType::class || $class === BenevolentUnionType::class;
+	}
+
 	private static function intersectFiniteUnions(UnionType $a, UnionType $b): ?Type
 	{
 		$membersA = self::finiteUnionMembers($a);
@@ -1827,19 +1835,24 @@ public static function doIntersect(Type ...$types): Type
 			$unionTypesCount++;
 		}
 
-		// Fast path: the intersection of two plain unions whose members are all finite,
+		// Fast path: the intersection of two unions whose members are all finite,
 		// mutually-disjoint values (constant scalars and/or enum cases) is their
 		// identity-keyed set intersection (O(n)), avoiding the O(n*m) `A & (B|C)`
-		// distribution + union rebuild below. Restricted to the exact UnionType class so
-		// BenevolentUnionType and the template union types keep their dedicated handling.
+		// distribution + union rebuild below. A benevolent union is the one the
+		// distribution walks first and the benevolence it gives the result is kept;
+		// the template union types keep their dedicated handling.
 		if (
 			$typesCount === 2
-			&& get_class($types[0]) === UnionType::class
-			&& get_class($types[1]) === UnionType::class
+			&& self::isPlainOrBenevolentUnion($types[0])
+			&& self::isPlainOrBenevolentUnion($types[1])
 		) {
-			$finiteIntersection = self::intersectFiniteUnions($types[0], $types[1]);
+			[$a, $b] = $types;
+			if ($b instanceof BenevolentUnionType && !$a instanceof BenevolentUnionType) {
+				[$a, $b] = [$b, $a];
+			}
+			$finiteIntersection = self::intersectFiniteUnions($a, $b);
 			if ($finiteIntersection !== null) {
-				return $finiteIntersection;
+				return $a instanceof BenevolentUnionType ? TypeUtils::toBenevolentUnion($finiteIntersection) : $finiteIntersection;
 			}
 		}
 
diff --git a/turbo-ext/src/TypeCombinator.cpp b/turbo-ext/src/TypeCombinator.cpp
index f744bbbedb2..ee155c2085d 100644
--- a/turbo-ext/src/TypeCombinator.cpp
+++ b/turbo-ext/src/TypeCombinator.cpp
@@ -3166,6 +3166,12 @@ class TypeCombinator
 		return call(newArray.raw(), PT_LC("getarray"));
 	}
 
+	/* Mirrors isPlainOrBenevolentUnion() */
+	static bool isPlainOrBenevolentUnion(zval *type)
+	{
+		return Z_OBJCE_P(type) == pt_ce_union_type || Z_OBJCE_P(type) == pt_ce_benevolent_union_type;
+	}
+
 	static zv::Val doIntersect(uint32_t argc, zval *argv)
 	{
 		size_t typesCount = argc;
@@ -3189,13 +3195,20 @@ class TypeCombinator
 			unionTypesCount++;
 		}
 
-		/* Fast path: the intersection of two plain unions whose members are
-		 * all finite, mutually-disjoint values is their identity-keyed set
-		 * intersection; restricted to the exact UnionType class */
-		if (typesCount == 2 && Z_OBJCE_P(types[0].raw()) == pt_ce_union_type && Z_OBJCE_P(types[1].raw()) == pt_ce_union_type) {
-			zv::Val finiteIntersection = intersectFiniteUnions(types[0].raw(), types[1].raw());
+		/* Fast path: the intersection of two unions whose members are all
+		 * finite, mutually-disjoint values is their identity-keyed set
+		 * intersection; a benevolent union is the one the distribution walks
+		 * first and the benevolence it gives the result is kept */
+		if (typesCount == 2 && isPlainOrBenevolentUnion(types[0].raw()) && isPlainOrBenevolentUnion(types[1].raw())) {
+			zval *a = types[0].raw();
+			zval *b = types[1].raw();
+			if (Z_OBJCE_P(b) == pt_ce_benevolent_union_type && Z_OBJCE_P(a) != pt_ce_benevolent_union_type) std::swap(a, b);
+			zv::Val finiteIntersection = intersectFiniteUnions(a, b);
 			PT_FAIL_IF_UNDEF(finiteIntersection);
-			if (!isNull(finiteIntersection)) return finiteIntersection;
+			if (!isNull(finiteIntersection)) {
+				if (Z_OBJCE_P(a) == pt_ce_benevolent_union_type) return pt_union_to_benevolent(finiteIntersection.raw());
+				return finiteIntersection;
+			}
 		}
 
 		if (unionTypesCount >= 2) {
diff --git a/turbo-ext/src/generated/TypeCombinator.h b/turbo-ext/src/generated/TypeCombinator.h
index 613d52592e3..303b41cf6d5 100644
--- a/turbo-ext/src/generated/TypeCombinator.h
+++ b/turbo-ext/src/generated/TypeCombinator.h
@@ -63,16 +63,17 @@ inline constexpr char strings[] =
 	"constantArrays\0" /* 673 */
 	"preserveTaggedUnions\0" /* 688 */
 	"reduceArrays\0" /* 709 */
-	"PHPStan\\Type\\UnionType\0" /* 722 */
-	"intersectFiniteUnions\0" /* 745 */
-	"finiteUnionMembers\0" /* 767 */
-	"intersect\0" /* 786 */
-	"doIntersect\0" /* 796 */
-	"intersectDefiniteConstantArrays\0" /* 808 */
-	"PHPStan\\Type\\IntersectionType\0" /* 840 */
-	"mergeIntersectionsForUnion\0" /* 870 */
-	"removeFalsey\0" /* 897 */
-	"removeTruthy"; /* 910 */
+	"isPlainOrBenevolentUnion\0" /* 722 */
+	"PHPStan\\Type\\UnionType\0" /* 747 */
+	"intersectFiniteUnions\0" /* 770 */
+	"finiteUnionMembers\0" /* 792 */
+	"intersect\0" /* 811 */
+	"doIntersect\0" /* 821 */
+	"intersectDefiniteConstantArrays\0" /* 833 */
+	"PHPStan\\Type\\IntersectionType\0" /* 865 */
+	"mergeIntersectionsForUnion\0" /* 895 */
+	"removeFalsey\0" /* 922 */
+	"removeTruthy"; /* 935 */
 inline constexpr reg::PackedArg args[] = {
 	reg::packed(0, MAY_BE_VOID), /* clearCache return */
 	reg::packed(12, 0, 17), /* addNull $type */
@@ -131,10 +132,12 @@ inline constexpr reg::PackedArg args[] = {
 	reg::packed(673, MAY_BE_ARRAY), /* reduceArrays $constantArrays */
 	reg::packed(688, MAY_BE_BOOL), /* reduceArrays $preserveTaggedUnions */
 	reg::packed(0, MAY_BE_ARRAY), /* reduceArrays return */
-	reg::packed(164, 0, 722), /* intersectFiniteUnions $a */
-	reg::packed(166, 0, 722), /* intersectFiniteUnions $b */
+	reg::packed(12, 0, 17), /* isPlainOrBenevolentUnion $type */
+	reg::packed(0, MAY_BE_BOOL), /* isPlainOrBenevolentUnion return */
+	reg::packed(164, 0, 747), /* intersectFiniteUnions $a */
+	reg::packed(166, 0, 747), /* intersectFiniteUnions $b */
 	reg::packed(0, MAY_BE_NULL, 17), /* intersectFiniteUnions return */
-	reg::packed(132, 0, 722), /* finiteUnionMembers $union */
+	reg::packed(132, 0, 747), /* finiteUnionMembers $union */
 	reg::packed(0, MAY_BE_NULL | MAY_BE_ARRAY), /* finiteUnionMembers return */
 	reg::packed(126, 0, 17, false, true), /* intersect $types */
 	reg::packed(0, 0, 17), /* intersect return */
@@ -143,8 +146,8 @@ inline constexpr reg::PackedArg args[] = {
 	reg::packed(164, 0, 548), /* intersectDefiniteConstantArrays $a */
 	reg::packed(166, 0, 548), /* intersectDefiniteConstantArrays $b */
 	reg::packed(0, 0, 17), /* intersectDefiniteConstantArrays return */
-	reg::packed(164, 0, 840), /* mergeIntersectionsForUnion $a */
-	reg::packed(166, 0, 840), /* mergeIntersectionsForUnion $b */
+	reg::packed(164, 0, 865), /* mergeIntersectionsForUnion $a */
+	reg::packed(166, 0, 865), /* mergeIntersectionsForUnion $b */
 	reg::packed(0, MAY_BE_NULL, 17), /* mergeIntersectionsForUnion return */
 	reg::packed(12, 0, 17), /* removeFalsey $type */
 	reg::packed(0, 0, 17), /* removeFalsey return */
@@ -180,14 +183,15 @@ inline constexpr sigtab::Sig countConstantArrayValueTypes = { { 513 /* countCons
 inline constexpr sigtab::Sig getConstantScalarValuesByKey = { { 588 /* getConstantScalarValuesByKey */, 1, 48, 1, 49, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
 inline constexpr sigtab::Sig haveDisjointConstantScalarValues = { { 640 /* haveDisjointConstantScalarValues */, 3, 50, 3, 53, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
 inline constexpr sigtab::Sig reduceArrays = { { 709 /* reduceArrays */, 2, 54, 2, 56, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig intersectFiniteUnions = { { 745 /* intersectFiniteUnions */, 2, 57, 2, 59, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig finiteUnionMembers = { { 767 /* finiteUnionMembers */, 1, 60, 1, 61, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig intersect = { { 786 /* intersect */, 0, 62, 1, 63, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig doIntersect = { { 796 /* doIntersect */, 0, 64, 1, 65, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig intersectDefiniteConstantArrays = { { 808 /* intersectDefiniteConstantArrays */, 2, 66, 2, 68, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig mergeIntersectionsForUnion = { { 870 /* mergeIntersectionsForUnion */, 2, 69, 2, 71, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig removeFalsey = { { 897 /* removeFalsey */, 1, 72, 1, 73, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig removeTruthy = { { 910 /* removeTruthy */, 1, 74, 1, 75, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig isPlainOrBenevolentUnion = { { 722 /* isPlainOrBenevolentUnion */, 1, 57, 1, 58, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig intersectFiniteUnions = { { 770 /* intersectFiniteUnions */, 2, 59, 2, 61, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig finiteUnionMembers = { { 792 /* finiteUnionMembers */, 1, 62, 1, 63, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig intersect = { { 811 /* intersect */, 0, 64, 1, 65, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig doIntersect = { { 821 /* doIntersect */, 0, 66, 1, 67, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig intersectDefiniteConstantArrays = { { 833 /* intersectDefiniteConstantArrays */, 2, 68, 2, 70, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig mergeIntersectionsForUnion = { { 895 /* mergeIntersectionsForUnion */, 2, 71, 2, 73, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig removeFalsey = { { 922 /* removeFalsey */, 1, 74, 1, 75, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig removeTruthy = { { 935 /* removeTruthy */, 1, 76, 1, 77, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } };
 } // namespace sig
 
 } // namespace ptdecl::TypeCombinator

From 6888887daf22e2b0f8701e8ab6ce60cbe9cdb684 Mon Sep 17 00:00:00 2001
From: Ondrej Mirtes <ondrej@mirtes.cz>
Date: Mon, 28 Sep 2026 13:21:09 +0200
Subject: [PATCH 8/9] Answer the isset() conjunction fold's left operand once
 per ask

A multi-subject isset() in a non-true context folds its subjects into a
chain of conjunctions, each one's left operand being the conjunction
folded so far. Every step and every conjunction asked it again with the
same scope and context, re-folding every subject before it - 700
specifyConjunction() calls for the 26 subjects of the bench's bug-15061.

The left operand of each conjunction answers each (scope, context) pair
once; SpecifiedTypes are immutable, so the answer is shared.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Y5roddukgqaSAB2BT765UX
---
 src/Analyser/ExprHandler/IssetHandler.php | 29 +++++++++++-
 turbo-ext/src/IssetHandler.cpp            | 55 ++++++++++++++++++++++-
 turbo-ext/src/generated/IssetHandler.h    |  8 +++-
 3 files changed, 89 insertions(+), 3 deletions(-)

diff --git a/src/Analyser/ExprHandler/IssetHandler.php b/src/Analyser/ExprHandler/IssetHandler.php
index accc87d17c1..684c20df179 100644
--- a/src/Analyser/ExprHandler/IssetHandler.php
+++ b/src/Analyser/ExprHandler/IssetHandler.php
@@ -227,7 +227,7 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex
 						$rightFalseyScope = $accTruthyScope->applySpecifiedTypes($rightTypes($accTruthyScope, TypeSpecifierContext::createFalsey()));
 
 						$leftExprNode = $accExpr;
-						$leftTypes = $accTypes;
+						$leftTypes = self::memoizeSubjectTypes($accTypes);
 						$leftTruthyScope = $accTruthyScope;
 						$leftFalseyScope = $accFalseyScope;
 						$accTypes = fn (MutatingScope $scope, TypeSpecifierContext $ctx): SpecifiedTypes => $this->booleanNarrowingHelper->specifyConjunction(
@@ -264,4 +264,31 @@ public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Ex
 		);
 	}
 
+	/**
+	 * The narrowing of the conjunction folded so far: every later conjunction
+	 * asks it again as its left operand, with the scopes and contexts it was
+	 * already asked with - answered once per pair instead of re-folding every
+	 * subject before it on each ask.
+	 *
+	 * @param Closure(MutatingScope, TypeSpecifierContext): SpecifiedTypes $types
+	 * @return Closure(MutatingScope, TypeSpecifierContext): SpecifiedTypes
+	 */
+	private static function memoizeSubjectTypes(Closure $types): Closure
+	{
+		$answered = [];
+
+		return static function (MutatingScope $scope, TypeSpecifierContext $context) use ($types, &$answered): SpecifiedTypes {
+			foreach ($answered as [$answeredScope, $answeredContext, $answer]) {
+				if ($answeredScope === $scope && $answeredContext === $context) {
+					return $answer;
+				}
+			}
+
+			$answer = $types($scope, $context);
+			$answered[] = [$scope, $context, $answer];
+
+			return $answer;
+		};
+	}
+
 }
diff --git a/turbo-ext/src/IssetHandler.cpp b/turbo-ext/src/IssetHandler.cpp
index 5838821d25f..92a320f3fe0 100644
--- a/turbo-ext/src/IssetHandler.cpp
+++ b/turbo-ext/src/IssetHandler.cpp
@@ -575,7 +575,8 @@ class IssetHandler
 				ZVAL_COPY_VALUE(&conjunctionCaptures[1], nodeScopeResolver);
 				ZVAL_COPY_VALUE(&conjunctionCaptures[2], expr);
 				ZVAL_COPY_VALUE(&conjunctionCaptures[3], leftExprNode.raw());
-				ZVAL_COPY_VALUE(&conjunctionCaptures[4], accTypes.raw());
+				zv::Val leftTypes = memoizeSubjectTypes(accTypes.raw());
+				ZVAL_COPY_VALUE(&conjunctionCaptures[4], leftTypes.raw());
 				ZVAL_COPY_VALUE(&conjunctionCaptures[5], accTruthyScope.raw());
 				ZVAL_COPY_VALUE(&conjunctionCaptures[6], accFalseyScope.raw());
 				ZVAL_COPY_VALUE(&conjunctionCaptures[7], rightExprNode.raw());
@@ -675,6 +676,58 @@ class IssetHandler
 		ZVAL_COPY(return_value, &captures[0]);
 	}
 
+	/* Mirrors memoizeSubjectTypes(): the closure answering each (scope,
+	 * context) pair once; captures: $types, &$answered */
+	static zv::Val memoizeSubjectTypes(zval *types)
+	{
+		zval answered;
+		array_init(&answered);
+		zval reference;
+		ZVAL_NEW_REF(&reference, &answered);
+		zval captures[2];
+		ZVAL_COPY_VALUE(&captures[0], types);
+		ZVAL_COPY_VALUE(&captures[1], &reference);
+		zv::Val closure = pt_native_closure_new(&memoizedSubjectTypesBody, 2, captures, 1u << 1);
+		zval_ptr_dtor(&reference);
+		return closure;
+	}
+
+	static void memoizedSubjectTypesBody(zval *captures, uint32_t argc, zval *argv, zval *return_value)
+	{
+		if (UNEXPECTED(!requireArguments(argc, 2, pt_ish_closure_name))) return;
+		zval *answered = Z_REFVAL(captures[1]);
+		if (Z_TYPE_P(answered) == IS_ARRAY && Z_TYPE(argv[0]) == IS_OBJECT && Z_TYPE(argv[1]) == IS_OBJECT) {
+			zval *entry;
+			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(answered), entry) {
+				zval *answeredScope = zend_hash_index_find(Z_ARRVAL_P(entry), 0);
+				zval *answeredContext = zend_hash_index_find(Z_ARRVAL_P(entry), 1);
+				zval *answer = zend_hash_index_find(Z_ARRVAL_P(entry), 2);
+				if (answeredScope == NULL || answeredContext == NULL || answer == NULL) continue;
+				if (Z_OBJ_P(answeredScope) == Z_OBJ(argv[0]) && Z_OBJ_P(answeredContext) == Z_OBJ(argv[1])) {
+					ZVAL_COPY(return_value, answer);
+					return;
+				}
+			} ZEND_HASH_FOREACH_END();
+		}
+		zv::Val answer = pt_type_call_callable(&captures[0], 2, argv);
+		if (UNEXPECTED(answer.isUndef())) return;
+		if (Z_TYPE_P(answered) != IS_ARRAY) {
+			zval_ptr_dtor(answered);
+			array_init(answered);
+		}
+		SEPARATE_ARRAY(answered);
+		zval triple;
+		array_init_size(&triple, 3);
+		Z_TRY_ADDREF(argv[0]);
+		zend_hash_next_index_insert(Z_ARRVAL(triple), &argv[0]);
+		Z_TRY_ADDREF(argv[1]);
+		zend_hash_next_index_insert(Z_ARRVAL(triple), &argv[1]);
+		Z_TRY_ADDREF_P(answer.raw());
+		zend_hash_next_index_insert(Z_ARRVAL(triple), answer.raw());
+		zend_hash_next_index_insert(Z_ARRVAL_P(answered), &triple);
+		answer.intoReturnValue(return_value);
+	}
+
 	/* fn (MutatingScope $scope, TypeSpecifierContext $ctx): SpecifiedTypes =>
 	 * $this->booleanNarrowingHelper->specifyConjunction(...) — captures:
 	 * $this, $nodeScopeResolver, $expr, $leftExprNode, $leftTypes,
diff --git a/turbo-ext/src/generated/IssetHandler.h b/turbo-ext/src/generated/IssetHandler.h
index 3cb203bdab8..1f66b94bce5 100644
--- a/turbo-ext/src/generated/IssetHandler.h
+++ b/turbo-ext/src/generated/IssetHandler.h
@@ -63,7 +63,10 @@ inline constexpr char strings[] =
 	"context\0" /* 613 */
 	"PHPStan\\Analyser\\ExpressionContext\0" /* 621 */
 	"PHPStan\\Analyser\\ExpressionResult\0" /* 656 */
-	"processExpr"; /* 690 */
+	"processExpr\0" /* 690 */
+	"types\0" /* 702 */
+	"Closure\0" /* 708 */
+	"memoizeSubjectTypes"; /* 716 */
 inline constexpr reg::PackedArg args[] = {
 	reg::packed(0, 0, 21), /* __construct $nonNullabilityHelper */
 	reg::packed(78, 0, 102), /* __construct $expressionResultFactory */
@@ -80,6 +83,8 @@ inline constexpr reg::PackedArg args[] = {
 	reg::packed(600, MAY_BE_CALLABLE), /* processExpr $nodeCallback */
 	reg::packed(613, 0, 621), /* processExpr $context */
 	reg::packed(426, 0, 656), /* processExpr return */
+	reg::packed(702, 0, 708), /* memoizeSubjectTypes $types */
+	reg::packed(426, 0, 708), /* memoizeSubjectTypes return */
 };
 using Sig = reg::Sig<strings, args>;
 } // namespace sigtab
@@ -89,6 +94,7 @@ namespace sig {
 inline constexpr sigtab::Sig __construct = { { 389 /* __construct */, 5, 0, 5, reg::NoArg, ZEND_ACC_PUBLIC } };
 inline constexpr sigtab::Sig supports = { { 427 /* supports */, 1, 5, 1, 6, ZEND_ACC_PUBLIC } };
 inline constexpr sigtab::Sig processExpr = { { 690 /* processExpr */, 7, 7, 7, 14, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig memoizeSubjectTypes = { { 716 /* memoizeSubjectTypes */, 1, 15, 1, 16, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
 } // namespace sig
 
 } // namespace ptdecl::IssetHandler

From 7c94037a92949c3a722cb800c6b6ed39744fd4a6 Mon Sep 17 00:00:00 2001
From: Ondrej Mirtes <ondrej@mirtes.cz>
Date: Mon, 28 Sep 2026 13:21:20 +0200
Subject: [PATCH 9/9] Bump expected turbo version

---
 src/Turbo/TurboExtensionEnabler.php | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Turbo/TurboExtensionEnabler.php b/src/Turbo/TurboExtensionEnabler.php
index 72f6aef66ca..e77f9fdcba9 100644
--- a/src/Turbo/TurboExtensionEnabler.php
+++ b/src/Turbo/TurboExtensionEnabler.php
@@ -33,7 +33,7 @@
 final class TurboExtensionEnabler
 {
 
-	public const EXPECTED_EXTENSION_VERSION = 'f0ebc74';
+	public const EXPECTED_EXTENSION_VERSION = '6888887';
 
 	private static bool $active = false;