Pre-compute count-specific conditional expressions to narrow list types when count() is stored in a variable

src/Analyser/ExprHandler/AssignHandler.php

@@ -81,6 +81,8 @@
 final class AssignHandler implements ExprHandler
 {
 
+	private const INTEGER_CONDITIONAL_LIMIT = 8;
+
 	public function __construct(
 		private TypeSpecifier $typeSpecifier,
 		private PhpVersion $phpVersion,
@@ -313,6 +315,39 @@
 					$conditionalExpressions = $this->processSureNotTypesForConditionalExpressionsAfterAssign($scope, $var->name, $conditionalExpressions, $identicalSpecifiedTypes, $falseyType);
 				}
 
+				if (
+					$assignedExpr instanceof FuncCall
+					&& $type->isInteger()->yes()
+					&& !$type instanceof ConstantIntegerType
+				) {
+					for ($n = 1; $n <= self::INTEGER_CONDITIONAL_LIMIT; $n++) {
+						$nType = new ConstantIntegerType($n);
+						$identicalExpr = new Expr\BinaryOp\Identical(
+							$assignedExpr,
+							new Node\Scalar\Int_($n),
+						);
+						$identicalSpecifiedTypes = $this->typeSpecifier->specifyTypesInCondition(
+							$scope,
+							$identicalExpr,
+							TypeSpecifierContext::createTrue(),
+						);
+						$conditionalExpressions = $this->processSureTypesForConditionalExpressionsAfterAssign(
+							$scope,
+							$var->name,
+							$conditionalExpressions,
+							$identicalSpecifiedTypes,
+							$nType,
+						);
+						$conditionalExpressions = $this->processSureNotTypesForConditionalExpressionsAfterAssign(
+							$scope,
+							$var->name,
+							$conditionalExpressions,
+							$identicalSpecifiedTypes,
+							$nType,
+						);
+					}
+				}
+
 				$nodeScopeResolver->callNodeCallback($nodeCallback, new VariableAssignNode($var, $assignedExpr), $scopeBeforeAssignEval, $storage);
 				$scope = $scope->assignVariable($var->name, $type, $scope->getNativeType($assignedExpr), TrinaryLogic::createYes());
 				foreach ($conditionalExpressions as $exprString => $holders) {

tests/PHPStan/Analyser/nsrt/bug-14464-analogous.php

@@ -0,0 +1,114 @@
+<?php declare(strict_types = 1);
+
+namespace Bug14464Analogous;
+
+use function PHPStan\Testing\assertType;
+
+/**
+ * sizeof() alias
+ * @param list<int> $items
+ */
+function testSizeof(array $items): void {
+	$count = sizeof($items);
+	if ($count === 3) {
+		assertType('array{int, int, int}', $items);
+	}
+}
+
+/**
+ * Inline count still works
+ * @param list<int> $items
+ */
+function testInlineCount(array $items): void {
+	if (count($items) === 3) {
+		assertType('array{int, int, int}', $items);
+	}
+}
+
+/**
+ * explode() result
+ */
+function testExplode(string $input): void {
+	$parts = explode(',', $input);
+	$count = count($parts);
+	if ($count === 3) {
+		assertType('array{string, string, string}', $parts);
+	} elseif ($count === 1) {
+		assertType('array{string}', $parts);
+	}
+}
+
+/**
+ * Variable count >= N (range comparison)
+ * @param list<int> $items
+ */
+function testGreaterOrEqual(array $items): void {
+	$count = count($items);
+	if ($count >= 3) {
+		assertType('non-empty-list<int>', $items);
+	}
+}
+
+/**
+ * Count value > 8 (beyond pre-computed limit)
+ * @param list<int> $items
+ */
+function testBeyondLimit(array $items): void {
+	$count = count($items);
+	if ($count === 10) {
+		assertType('non-empty-list<int>', $items);
+	}
+}
+
+/**
+ * Count with mode argument - safe for list<int> since int values are not countable
+ * @param list<int> $items
+ */
+function testCountWithMode(array $items, int $mode): void {
+	$count = count($items, $mode);
+	if ($count === 3) {
+		assertType('array{int, int, int}', $items);
+	}
+}
+
+/**
+ * Variable strlen - generalized integer pre-computation also works for strlen
+ */
+function testStrlen(string $s): void {
+	$len = strlen($s);
+	if ($len === 3) {
+		assertType('non-falsy-string', $s);
+	} elseif ($len === 1) {
+		assertType('non-empty-string', $s);
+	}
+}
+
+/**
+ * Variable count on non-empty-list
+ * @param non-empty-list<string> $items
+ */
+function testNonEmptyList(array $items): void {
+	$count = count($items);
+	if ($count === 2) {
+		assertType('array{string, string}', $items);
+	}
+}
+
+/**
+ * Variable count with switch statement
+ * @param list<int> $items
+ */
+function testSwitch(array $items): void {
+	$count = count($items);
+	switch ($count) {
+		case 1:
+			assertType('array{int}', $items);
+			break;
+		case 2:
+			assertType('array{int, int}', $items);
+			break;
+		case 3:
+			assertType('array{int, int, int}', $items);
+			break;
+	}
+}

tests/PHPStan/Analyser/nsrt/bug-14464.php

@@ -0,0 +1,72 @@
+<?php declare(strict_types = 1);
+
+namespace Bug14464;
+
+use function PHPStan\Testing\assertType;
+
+class HelloWorld
+{
+	/** Variable count with == (loose comparison from the issue) */
+	protected function columnOrAlias(string $columnName): void
+	{
+		$colParts = preg_split('/\s+/', $columnName, -1, \PREG_SPLIT_NO_EMPTY);
+		if ($colParts === false) {
+			throw new \RuntimeException('preg error');
+		}
+		assertType('list<non-empty-string>', $colParts);
+		$numParts = count($colParts);
+
+		if ($numParts == 3) {
+			assertType('array{non-empty-string, non-empty-string, non-empty-string}', $colParts);
+			$this->columnName($colParts[0]);
+			$this->columnName($colParts[1]);
+			$this->columnName($colParts[2]);
+		} elseif ($numParts == 2) {
+			assertType('array{non-empty-string, non-empty-string}', $colParts);
+			$this->columnName($colParts[0]);
+			$this->columnName($colParts[1]);
+		} elseif ($numParts == 1) {
+			assertType('array{non-empty-string}', $colParts);
+			$this->columnName($colParts[0]);
+		} else {
+			throw new \LogicException('invalid');
+		}
+	}
+
+	/** Variable count with === (strict comparison) */
+	protected function strictComparison(string $input): void
+	{
+		$parts = preg_split('/,/', $input, -1, \PREG_SPLIT_NO_EMPTY);
+		if ($parts === false) {
+			throw new \RuntimeException('preg error');
+		}
+		$count = count($parts);
+
+		if ($count === 3) {
+			assertType('array{non-empty-string, non-empty-string, non-empty-string}', $parts);
+		} elseif ($count === 1) {
+			assertType('array{non-empty-string}', $parts);
+		}
+	}
+
+	/**
+	 * Variable count on a PHPDoc list type
+	 * @param list<int> $items
+	 */
+	protected function phpdocList(array $items): void
+	{
+		$count = count($items);
+		if ($count === 3) {
+			assertType('array{int, int, int}', $items);
+		} elseif ($count === 5) {
+			assertType('array{int, int, int, int, int}', $items);
+		} else {
+			assertType('list<int>', $items);
+		}
+	}
+
+	public function columnName(string $columnName): string
+	{
+		return 'abc';
+	}
+}