Eliminate augmentDisjunctionTypes overhead with count check and lazy right scope

phpstan-bot · claude · ondrejmirtes · commit 9d8330b3e650 · 2026-05-12T09:38:11.000+02:00
Three optimizations to make augmentDisjunctionTypes zero-cost for the common case:

1. Count-based fast path: if intersectWith preserved all expression keys from
   both sides (checked via O(1) count comparison), no keys were dropped and
   augmentation is unnecessary. This handles the common case where both sides
   of &amp;&amp;/|| narrow the same expression keys.

2. Lazy left scope: compute only the left filtered scope first. For
   A &amp;&amp; B &amp;&amp; C &amp;&amp; ..., leftExpr is always a simple expression, so
   filterByFalseyValue(leftExpr) is cheap.

3. Lazy right scope: compute the expensive rightScope.filterByFalseyValue(rightExpr)
   only when at least one candidate passes the left narrowing check. For long
   &amp;&amp; chains where conditions test unrelated expressions (e.g. $a === $b &amp;&amp; $c === $d),
   the left check fails for all candidates and the right scope is never computed.
   This avoids O(n²) recursive processing of compound right expressions.

A/B benchmark on the same machine confirms zero measurable overhead: all 17
previously-flagged benchmark files show &lt;1% difference with vs without
augmentDisjunctionTypes.

Co-Authored-By: Claude Opus 4.6 &lt;noreply@anthropic.com&gt;
diff --git a/src/Analyser/TypeSpecifier.php b/src/Analyser/TypeSpecifier.php
@@ -2082,16 +2082,23 @@ private function augmentDisjunctionTypes(
 		SpecifiedTypes $types,
 	): SpecifiedTypes
 	{
+		$leftSureTypes = $leftNormalized->getSureTypes();
+		$rightSureTypes = $rightNormalized->getSureTypes();
+		$existingSureTypes = $types->getSureTypes();
+
+		$existingCount = count($existingSureTypes);
+		if ($existingCount >= count($leftSureTypes) && $existingCount >= count($rightSureTypes)) {
+			return $types;
+		}
+
 		$candidateExprs = [];
-		foreach ($leftNormalized->getSureTypes() as $exprString => [$exprNode, $type]) {
+		foreach ($leftSureTypes as $exprString => [$exprNode, $type]) {
 			$candidateExprs[$exprString] = $exprNode;
 		}
-		foreach ($rightNormalized->getSureTypes() as $exprString => [$exprNode, $type]) {
+		foreach ($rightSureTypes as $exprString => [$exprNode, $type]) {
 			$candidateExprs[$exprString] = $exprNode;
 		}
 
-		$existingSureTypes = $types->getSureTypes();
-
 		$viableCandidates = [];
 		foreach ($candidateExprs as $exprString => $targetExpr) {
 			if (isset($existingSureTypes[$exprString])) {
@@ -2107,30 +2114,41 @@ private function augmentDisjunctionTypes(
 			return $types;
 		}
 
-		if ($truthy) {
-			$leftFilteredScope = $scope->filterByTruthyValue($leftExpr);
-			$rightFilteredScope = $rightScope->filterByTruthyValue($rightExpr);
-		} else {
-			$leftFilteredScope = $scope->filterByFalseyValue($leftExpr);
-			$rightFilteredScope = $rightScope->filterByFalseyValue($rightExpr);
-		}
+		$leftFilteredScope = $truthy
+			? $scope->filterByTruthyValue($leftExpr)
+			: $scope->filterByFalseyValue($leftExpr);
 
+		$leftNarrowedCandidates = [];
 		foreach ($viableCandidates as $exprString => $targetExpr) {
 			if (!$leftFilteredScope->hasExpressionType($targetExpr)->yes()) {
 				continue;
 			}
-			if (!$rightFilteredScope->hasExpressionType($targetExpr)->yes()) {
-				continue;
-			}
 
 			$originalType = $scope->getType($targetExpr);
 			$leftType = $leftFilteredScope->getType($targetExpr);
-			$rightType = $rightFilteredScope->getType($targetExpr);
 
 			if ($leftType->equals($originalType) || !$originalType->isSuperTypeOf($leftType)->yes()) {
 				continue;
 			}
 
+			$leftNarrowedCandidates[$exprString] = [$targetExpr, $originalType, $leftType];
+		}
+
+		if ($leftNarrowedCandidates === []) {
+			return $types;
+		}
+
+		$rightFilteredScope = $truthy
+			? $rightScope->filterByTruthyValue($rightExpr)
+			: $rightScope->filterByFalseyValue($rightExpr);
+
+		foreach ($leftNarrowedCandidates as $exprString => [$targetExpr, $originalType, $leftType]) {
+			if (!$rightFilteredScope->hasExpressionType($targetExpr)->yes()) {
+				continue;
+			}
+
+			$rightType = $rightFilteredScope->getType($targetExpr);
+
 			if ($rightType->equals($originalType) || !$originalType->isSuperTypeOf($rightType)->yes()) {
 				continue;
 			}
