Merge remote-tracking branch 'origin/2.1.x' into 2.2.x

Author: ondrejmirtes

src/Analyser/TypeSpecifier.php

@@ -19,6 +19,7 @@
 use PhpParser\Node\Expr\StaticCall;
 use PhpParser\Node\Expr\StaticPropertyFetch;
 use PhpParser\Node\Name;
+use PHPStan\Analyser\ExprHandler\BooleanAndHandler;
 use PHPStan\DependencyInjection\AutowiredService;
 use PHPStan\Node\Expr\AlwaysRememberedExpr;
 use PHPStan\Node\Expr\TypeExpr;
@@ -99,6 +100,8 @@ final class TypeSpecifier
 
 	private const MAX_ACCESSORIES_LIMIT = 8;
 
+	private const BOOLEAN_EXPRESSION_MAX_PROCESS_DEPTH = 4;
+
 	/** @var MethodTypeSpecifyingExtension[][]|null */
 	private ?array $methodTypeSpecifyingExtensionsByClass = null;
 
@@ -731,6 +734,13 @@ public function specifyTypesInCondition(
 			if (!$scope instanceof MutatingScope) {
 				throw new ShouldNotHappenException();
 			}
+
+			// For deep BooleanOr chains, flatten and process all arms at once
+			// to avoid O(n^2) recursive filterByFalseyValue calls
+			if (BooleanAndHandler::getBooleanExpressionDepth($expr) > self::BOOLEAN_EXPRESSION_MAX_PROCESS_DEPTH) {
+				return $this->specifyTypesForFlattenedBooleanOr($scope, $expr, $context);
+			}
+
 			$leftTypes = $this->specifyTypesInCondition($scope, $expr->left, $context)->setRootExpr($expr);
 			$rightScope = $scope->filterByFalseyValue($expr->left);
 			$rightTypes = $this->specifyTypesInCondition($rightScope, $expr->right, $context)->setRootExpr($expr);
@@ -1967,6 +1977,60 @@ private function processBooleanSureConditionalTypes(Scope $scope, SpecifiedTypes
 		return [];
 	}
 
+	/**
+	 * Flatten a deep BooleanOr chain into leaf expressions and process them
+	 * without recursive filterByFalseyValue calls. This reduces O(n^2) to O(n)
+	 * for chains with many arms (e.g., 80+ === comparisons in ||).
+	 */
+	private function specifyTypesForFlattenedBooleanOr(
+		MutatingScope $scope,
+		BooleanOr|LogicalOr $expr,
+		TypeSpecifierContext $context,
+	): SpecifiedTypes
+	{
+		// Collect all leaf expressions from the chain
+		$arms = [];
+		$current = $expr;
+		while ($current instanceof BooleanOr || $current instanceof LogicalOr) {
+			$arms[] = $current->right;
+			$current = $current->left;
+		}
+		$arms[] = $current; // leftmost leaf
+		$arms = array_reverse($arms);
+
+		if ($context->false() || $context->falsey()) {
+			// Falsey: all arms are false → union all SpecifiedTypes
+			$result = new SpecifiedTypes([], []);
+			foreach ($arms as $arm) {
+				$armTypes = $this->specifyTypesInCondition($scope, $arm, $context);
+				$result = $result->unionWith($armTypes);
+			}
+			return $result->setRootExpr($expr);
+		}
+
+		// Truthy: at least one arm is true → intersect all normalized SpecifiedTypes
+		$armSpecifiedTypes = [];
+		foreach ($arms as $arm) {
+			$armTypes = $this->specifyTypesInCondition($scope, $arm, $context);
+			$armSpecifiedTypes[] = $armTypes->normalize($scope);
+		}
+
+		$types = $armSpecifiedTypes[0];
+		for ($i = 1; $i < count($armSpecifiedTypes); $i++) {
+			$types = $types->intersectWith($armSpecifiedTypes[$i]);
+		}
+
+		$result = new SpecifiedTypes(
+			$types->getSureTypes(),
+			$types->getSureNotTypes(),
+		);
+		if ($types->shouldOverwrite()) {
+			$result = $result->setAlwaysOverwriteTypes();
+		}
+
+		return $result->setRootExpr($expr);
+	}
+
 	/**
 	 * @return array<string, ConditionalExpressionHolder[]>
 	 */

src/Type/Constant/ConstantFloatType.php

@@ -99,6 +99,15 @@ public function toArrayKey(): Type
 		return new ConstantIntegerType((int) $this->value);
 	}
 
+	public function getFiniteTypes(): array
+	{
+		if (is_nan($this->value)) {
+			return [];
+		}
+
+		return [$this];
+	}
+
 	public function generalize(GeneralizePrecision $precision): Type
 	{
 		return new FloatType();

tests/PHPStan/Rules/Comparison/StrictComparisonOfDifferentTypesRuleTest.php

@@ -1193,4 +1193,15 @@ public function testInTrait(): void
 		]);
 	}
 
+	public function testBug11054(): void
+	{
+		$this->analyse([__DIR__ . '/data/bug-11054.php'], [
+			[
+				'Strict comparison using === between mixed and array{INF} will always evaluate to false.',
+				47,
+				'Type array{INF} has already been eliminated from mixed.',
+			],
+		]);
+	}
+
 }

tests/PHPStan/Rules/Comparison/data/bug-11054.php

@@ -0,0 +1,58 @@
+<?php declare(strict_types = 1);
+
+namespace Bug11054;
+
+class XXX {
+	public const DEF_VALUE = [NAN];
+	public const NO_VALUE  = [NAN];
+}
+
+class YYY
+{
+	public const LOSSLESS = [NAN];
+
+	/**
+	 * @param  string|int|mixed $substituteChar
+	 */
+	public static function convertEncoding (
+		string $str,
+		string $sourceEncoding,
+		string $targetEncoding,
+		$substituteChar = XXX::DEF_VALUE,
+		$defValue       = XXX::NO_VALUE
+	): string {
+		if ($substituteChar === XXX::DEF_VALUE) { // no error expected
+			return mb_convert_encoding($str, $targetEncoding, $sourceEncoding);
+		}
+
+		if ($substituteChar === self::LOSSLESS) { // no error expected
+			return $str;
+		}
+
+		return $str;
+	}
+}
+
+class InfTest {
+	public const DEF_VALUE = [INF];
+	public const NO_VALUE  = [INF];
+
+	/** @param mixed $v */
+	public static function test($v): void
+	{
+		if ($v === self::DEF_VALUE) { // no error expected
+			return;
+		}
+
+		if ($v === self::NO_VALUE) {} // error expected - INF === INF is true, so narrowing is correct
+	}
+}
+
+class SimpleTest {
+	/** @param mixed $v */
+	public static function test($v): void
+	{
+		if ($v === [NAN]) {} // no error expected
+		if ($v === [INF]) {} // no error expected
+	}
+}