Improve type inference for coalesce with ErrorType, strpos === int narrowing, and str_repeat return types

- Handle ErrorType in InitializerExprTypeResolver coalesce: `[][0] ?? 42` now resolves to `42` instead of `*ERROR*`
- Apply truthy narrowing when function/method calls are compared to truthy constants via ===, enabling `strpos($s, ':') === 5` to narrow `$s` to non-falsy-string
- Return non-falsy-string from str_repeat when input is non-empty and multiplier >= 2 (result length >= 2 means it can't be '0' or '')
- Preserve numeric-string in str_repeat when multiplier is exactly 1
- Update test assertions for all improved type inference cases

Author: ondrejmirtes

src/Analyser/TypeSpecifier.php

@@ -1548,6 +1548,23 @@ private function specifyTypesForConstantBinaryExpression(
 			)->setRootExpr($rootExpr));
 		}
 
+		if (
+			$context->true()
+			&& $constantType->toBoolean()->isTrue()->yes()
+			&& ($exprNode instanceof FuncCall || $exprNode instanceof Expr\MethodCall || $exprNode instanceof Expr\StaticCall)
+		) {
+			$additionalTypes = $this->specifyTypesInCondition(
+				$scope,
+				$exprNode,
+				TypeSpecifierContext::createTrue(),
+			)->setRootExpr($rootExpr);
+
+			if ($additionalTypes->getSureTypes() !== [] || $additionalTypes->getSureNotTypes() !== []) {
+				$types = $this->create($exprNode, $constantType, $context, $scope)->setRootExpr($rootExpr);
+				return $types->unionWith($additionalTypes);
+			}
+		}
+
 		return null;
 	}
 

src/Reflection/InitializerExprTypeResolver.php

@@ -281,6 +281,10 @@ public function getType(Expr $expr, InitializerExprContext $context): Type
 			$leftType = $this->getType($expr->left, $context);
 			$rightType = $this->getType($expr->right, $context);
 
+			if ($leftType instanceof ErrorType) {
+				return $rightType;
+			}
+
 			return TypeCombinator::union(TypeCombinator::removeNull($leftType), $rightType);
 		}
 

src/Type/Php/StrRepeatFunctionReturnTypeExtension.php

@@ -68,14 +68,15 @@ public function getTypeFromFunctionCall(
 		$accessoryTypes = [];
 		if ($inputType->isNonEmptyString()->yes()) {
 			if (IntegerRangeType::fromInterval(1, null)->isSuperTypeOf($multiplierType)->yes()) {
-				if ($inputType->isNonFalsyString()->yes()) {
+				if ($inputType->isNonFalsyString()->yes() || IntegerRangeType::fromInterval(2, null)->isSuperTypeOf($multiplierType)->yes()) {
 					$accessoryTypes[] = new AccessoryNonFalsyStringType();
 				} else {
 					$accessoryTypes[] = new AccessoryNonEmptyStringType();
 				}
 			}
 		}
 
+		$addedNumericString = false;
 		if ($inputType->isLiteralString()->yes()) {
 			$accessoryTypes[] = new AccessoryLiteralStringType();
 
@@ -93,10 +94,19 @@ public function getTypeFromFunctionCall(
 
 				if ($onlyNumbers) {
 					$accessoryTypes[] = new AccessoryNumericStringType();
+					$addedNumericString = true;
 				}
 			}
 		}
 
+		if (
+			!$addedNumericString
+			&& $inputType->isNumericString()->yes()
+			&& (new ConstantIntegerType(1))->isSuperTypeOf($multiplierType)->yes()
+		) {
+			$accessoryTypes[] = new AccessoryNumericStringType();
+		}
+
 		if ($inputType->isLowercaseString()->yes()) {
 			$accessoryTypes[] = new AccessoryLowercaseStringType();
 		}

tests/PHPStan/Analyser/nsrt/initializer-expr-type-resolver.php

@@ -14,7 +14,7 @@ class Foo
 
 	public function doFoo(): void
 	{
-		assertType('*ERROR*', self::COALESCE_SPECIAL); // could be 42
+		assertType('42', self::COALESCE_SPECIAL);
 		assertType("0|1|2|'foo'", self::COALESCE);
 		assertType("'bar'|'foo'|true", self::TERNARY_SHORT);
 		assertType("'bar'|'foo'", self::TERNARY_FULL);

tests/PHPStan/Analyser/nsrt/literal-string.php

@@ -38,18 +38,18 @@ public function doFoo($literalString, string $string, $numericString)
 		);
 		assertType('literal-string&lowercase-string&non-falsy-string', str_repeat('a', 100));
 		assertType('literal-string&non-falsy-string&uppercase-string', str_repeat('A', 100));
-		assertType('literal-string&lowercase-string&non-empty-string&numeric-string&uppercase-string', str_repeat('0', 100)); // could be non-falsy-string
+		assertType('literal-string&lowercase-string&non-falsy-string&numeric-string&uppercase-string', str_repeat('0', 100));
 		assertType('literal-string&lowercase-string&non-falsy-string&numeric-string&uppercase-string', str_repeat('1', 100));
 		// Repeating a numeric type multiple times can lead to a non-numeric type: 3v4l.org/aRBdZ
-		assertType('non-empty-string', str_repeat($numericString, 100));
+		assertType('non-falsy-string', str_repeat($numericString, 100));
 
 		assertType("''", str_repeat('1.23', 0));
 		assertType("''", str_repeat($string, 0));
 		assertType("''", str_repeat($numericString, 0));
 
 		// see https://3v4l.org/U4bM2
-		assertType("non-empty-string", str_repeat($numericString, 1)); // could be numeric-string
-		assertType("non-empty-string", str_repeat($numericString, 2));
+		assertType("non-empty-string&numeric-string", str_repeat($numericString, 1));
+		assertType("non-falsy-string", str_repeat($numericString, 2));
 		assertType("literal-string", str_repeat($literalString, 1));
 		$x = rand(1,2);
 		assertType("literal-string&lowercase-string&non-falsy-string&uppercase-string", str_repeat('    1   ', $x));

tests/PHPStan/Analyser/nsrt/non-empty-string-str-containing-fns.php

@@ -100,7 +100,7 @@ public function variants(string $s) {
 		assertType('string', $s);
 
 		if (strpos($s, ':') === 5) {
-			assertType('string', $s); // could be non-empty-string
+			assertType('non-falsy-string', $s);
 		}
 		assertType('string', $s);
 		if (strpos($s, ':') !== 5) {
@@ -152,7 +152,7 @@ public function variants(string $s) {
 		assertType('string', $s);
 
 		if (mb_strpos($s, ':') === 5) {
-			assertType('string', $s); // could be non-empty-string
+			assertType('non-falsy-string', $s);
 		}
 		assertType('string', $s);
 		if (mb_strpos($s, ':') !== 5) {