Intersect cached count()/strlen() expression types with current argument type constraints

src/Analyser/MutatingScope.php

@@ -2819,6 +2819,10 @@
 		$nativeTypes = $scope->nativeExpressionTypes;
 		$nativeTypes[$exprString] = new ExpressionTypeHolder($expr, $nativeType, $certainty);
 
+		if ($expr instanceof Variable) {
+			$this->refineDependentFuncCallTypes($exprString, $type, $nativeType, $expressionTypes, $nativeTypes);
+		}
+
 		$scope = $this->scopeFactory->create(
 			$this->context,
 			$this->isDeclareStrictTypes(),
@@ -2845,6 +2849,63 @@
 		return $scope;
 	}
 
+	/**
+	 * @param array<string, ExpressionTypeHolder> $expressionTypes
+	 * @param array<string, ExpressionTypeHolder> $nativeTypes
+	 */
+	private function refineDependentFuncCallTypes(
+		string $varExprString,
+		Type $varType,
+		Type $varNativeType,
+		array &$expressionTypes,
+		array &$nativeTypes,
+	): void
+	{
+		foreach ($expressionTypes as $exprString => $holder) {
+			$holderExpr = $holder->getExpr();
+			if (!$holderExpr instanceof FuncCall || !$holderExpr->name instanceof Name) {
+				continue;
+			}
+			if ($holderExpr->isFirstClassCallable() || count($holderExpr->getArgs()) < 1) {
+				continue;
+			}
+			if ($this->getNodeKey($holderExpr->getArgs()[0]->value) !== $varExprString) {
+				continue;
+			}
+
+			$funcName = $holderExpr->name->toLowerString();
+			$constraint = null;
+			$nativeConstraint = null;
+			if (in_array($funcName, ['count', 'sizeof'], true)) {
+				$constraint = $varType->getArraySize();
+				$nativeConstraint = $varNativeType->getArraySize();
+			} elseif (in_array($funcName, ['strlen', 'mb_strlen'], true)) {
+				if ($varType->isNonEmptyString()->yes()) {
+					$constraint = IntegerRangeType::fromInterval(1, null);
+				}
+				if ($varNativeType->isNonEmptyString()->yes()) {
+					$nativeConstraint = IntegerRangeType::fromInterval(1, null);
+				}
+			}
+
+			if ($constraint !== null) {
+				$expressionTypes[$exprString] = new ExpressionTypeHolder(
+					$holderExpr,
+					TypeCombinator::intersect($holder->getType(), $constraint),
+					$holder->getCertainty(),
+				);
+			}
+
+			if ($nativeConstraint !== null && array_key_exists($exprString, $nativeTypes)) {
+				$nativeTypes[$exprString] = new ExpressionTypeHolder(
+					$holderExpr,
+					TypeCombinator::intersect($nativeTypes[$exprString]->getType(), $nativeConstraint),
+					$nativeTypes[$exprString]->getCertainty(),
+				);
+			}
+		}
+	}
+
 	public function assignExpression(Expr $expr, Type $type, Type $nativeType): self
 	{
 		$scope = $this;
@@ -3310,7 +3371,7 @@
 				foreach ($conditionalExpressions as $conditionalExpression) {
 					foreach ($conditionalExpression->getConditionExpressionTypeHolders() as $holderExprString => $conditionalTypeHolder) {
 						if (
 							!array_key_exists($holderExprString, $specifiedExpressions)
 							|| !$conditionalTypeHolder->equals($specifiedExpressions[$holderExprString])
 						) {
 							continue 2;

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

@@ -0,0 +1,84 @@
+<?php
+
+namespace Bug13750;
+
+use function PHPStan\Testing\assertType;
+
+class HelloWorld
+{
+	/** @param array<mixed> $arr */
+	public function forgetCount(array $arr): void
+	{
+		if (count($arr) > 2) {
+			assertType('non-empty-array<mixed>', $arr);
+			assertType('int<3, max>', count($arr));
+		}
+		assertType('array<mixed>', $arr);
+		assertType('int<0, max>', count($arr));
+		if (count($arr, COUNT_RECURSIVE) > 2) {
+			assertType('non-empty-array<mixed>', $arr);
+			assertType('int<1, max>', count($arr));
+		}
+	}
+
+	/** @param array<mixed> $arr */
+	public function sizeofAfterCount(array $arr): void
+	{
+		if (sizeof($arr) > 2) {
+			assertType('int<3, max>', sizeof($arr));
+		}
+		assertType('int<0, max>', sizeof($arr));
+		if (sizeof($arr, COUNT_RECURSIVE) > 2) {
+			assertType('non-empty-array<mixed>', $arr);
+			assertType('int<1, max>', sizeof($arr));
+		}
+	}
+
+	/** @param array<mixed> $arr */
+	public function countAfterNonEmptyNarrowing(array $arr): void
+	{
+		if (count($arr) > 2) {
+			assertType('int<3, max>', count($arr));
+		}
+		assertType('int<0, max>', count($arr));
+		if ($arr !== []) {
+			assertType('non-empty-array<mixed>', $arr);
+			assertType('int<1, max>', count($arr));
+		}
+	}
+
+	/** @param array<mixed> $arr */
+	public function nestedCountPreservation(array $arr): void
+	{
+		if (count($arr) > 2) {
+			assertType('int<3, max>', count($arr));
+			if (count($arr, COUNT_RECURSIVE) > 10) {
+				assertType('int<3, max>', count($arr));
+			}
+		}
+	}
+
+	public function strlenAfterNonEmptyNarrowing(string $str): void
+	{
+		if (strlen($str) > 5) {
+			assertType('int<6, max>', strlen($str));
+		}
+		assertType('int<0, max>', strlen($str));
+		if ($str !== '') {
+			assertType('non-empty-string', $str);
+			assertType('int<1, max>', strlen($str));
+		}
+	}
+
+	public function mbStrlenAfterNonEmptyNarrowing(string $str): void
+	{
+		if (mb_strlen($str) > 5) {
+			assertType('int<6, max>', mb_strlen($str));
+		}
+		assertType('int<0, max>', mb_strlen($str));
+		if ($str !== '') {
+			assertType('non-empty-string', $str);
+			assertType('int<1, max>', mb_strlen($str));
+		}
+	}
+}