Rework extension

Author: VincentLanglet

build/baseline-8.0.neon

@@ -26,7 +26,7 @@ parameters:
 			path: ../src/Type/Php/StrSplitFunctionReturnTypeExtension.php
 
 		-
-			message: "#^Strict comparison using \\=\\=\\= between list<string> and false will always evaluate to false\\.$#"
+			message: "#^Strict comparison using \\=\\=\\= between non\\-empty\\-list<string> and false will always evaluate to false\\.$#"
 			count: 1
 			path: ../src/Type/Php/StrSplitFunctionReturnTypeExtension.php
 

src/Type/Php/StrSplitFunctionReturnTypeExtension.php

@@ -19,7 +19,9 @@
 use PHPStan\Type\Constant\ConstantIntegerType;
 use PHPStan\Type\Constant\ConstantStringType;
 use PHPStan\Type\DynamicFunctionReturnTypeExtension;
+use PHPStan\Type\IntegerRangeType;
 use PHPStan\Type\IntegerType;
+use PHPStan\Type\NeverType;
 use PHPStan\Type\StringType;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
@@ -54,14 +56,15 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 
 		if (count($functionCall->getArgs()) >= 2) {
 			$splitLengthType = $scope->getType($functionCall->getArgs()[1]->value);
-			if ($splitLengthType instanceof ConstantIntegerType) {
-				$splitLength = $splitLengthType->getValue();
-				if ($splitLength < 1) {
-					return new ConstantBooleanType(false);
-				}
-			}
 		} else {
-			$splitLength = 1;
+			$splitLengthType = new ConstantIntegerType(1);
+		}
+
+		if ($splitLengthType instanceof ConstantIntegerType) {
+			$splitLength = $splitLengthType->getValue();
+			if ($splitLength < 1) {
+				return new ConstantBooleanType(false);
+			}
 		}
 
 		$encoding = null;
@@ -70,26 +73,25 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 				$strings = $scope->getType($functionCall->getArgs()[2]->value)->getConstantStrings();
 				$values = array_unique(array_map(static fn (ConstantStringType $encoding): string => $encoding->getValue(), $strings));
 
-				if (count($values) !== 1) {
-					return null;
-				}
-
 				$encoding = $values[0];
 				if (!$this->isSupportedEncoding($encoding)) {
-					return new ConstantBooleanType(false);
+					return $this->phpVersion->throwsValueErrorForInternalFunctions() ? new NeverType() : new ConstantBooleanType(false);
 				}
 			} else {
 				$encoding = mb_internal_encoding();
 			}
 		}
 
 		$stringType = $scope->getType($functionCall->getArgs()[0]->value);
-		if (isset($splitLength)) {
+		if (
+			isset($splitLength)
+			&& ($functionReflection->getName() === 'str_split' || null !== $encoding)
+		) {
 			$constantStrings = $stringType->getConstantStrings();
 			if (count($constantStrings) > 0) {
 				$results = [];
 				foreach ($constantStrings as $constantString) {
-					$items = $encoding === null
+					$items = null === $encoding
 						? str_split($constantString->getValue(), $splitLength)
 						: @mb_str_split($constantString->getValue(), $splitLength, $encoding);
 					if ($items === false) {
@@ -118,10 +120,23 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 		$returnValueType = TypeCombinator::intersect(new StringType(), ...$valueTypes);
 
 		$returnType = AccessoryArrayListType::intersectWith(TypeCombinator::intersect(new ArrayType(new IntegerType(), $returnValueType)));
+		if (
+			// Non-empty-string will return an array with at least an element
+			$isInputNonEmptyString
+			// str_split('', 1) returns [''] on old PHP version and [] on new ones
+			|| ($functionReflection->getName() === 'str_split' && !$this->phpVersion->strSplitReturnsEmptyArray())
+		) {
+			$returnType = TypeCombinator::intersect($returnType, new NonEmptyArrayType());
+		}
+		if (
+			// Length parameter accepts int<1, max> or throws a ValueError/return false based on PHP Version.
+			!$this->phpVersion->throwsValueErrorForInternalFunctions()
+			&& !IntegerRangeType::fromInterval(1, null)->isSuperTypeOf($splitLengthType)->yes()
+		) {
+			$returnType = TypeCombinator::union($returnType, new ConstantBooleanType(false));
+		}
 
-		return $isInputNonEmptyString || ($encoding === null && !$this->phpVersion->strSplitReturnsEmptyArray())
-			? TypeCombinator::intersect($returnType, new NonEmptyArrayType())
-			: $returnType;
+		return $returnType;
 	}
 
 	/**

tests/PHPStan/Analyser/data/str-split-php74.php

@@ -28,13 +28,13 @@ public function legacyTest() {
 		assertType('false', $strSplitConstantStringWithFailureSplitLength);
 
 		$strSplitConstantStringWithInvalidSplitLengthType = str_split('abcdef', []);
-		assertType('non-empty-list<lowercase-string&non-empty-string>|false', $strSplitConstantStringWithInvalidSplitLengthType);
+		assertType('(non-empty-list<lowercase-string&non-empty-string>)|false', $strSplitConstantStringWithInvalidSplitLengthType);
 
 		$strSplitConstantStringWithVariableStringAndConstantSplitLength = str_split(doFoo() ? 'abcdef' : 'ghijkl', 1);
 		assertType("array{'a', 'b', 'c', 'd', 'e', 'f'}|array{'g', 'h', 'i', 'j', 'k', 'l'}", $strSplitConstantStringWithVariableStringAndConstantSplitLength);
 
 		$strSplitConstantStringWithVariableStringAndVariableSplitLength = str_split(doFoo() ? 'abcdef' : 'ghijkl', doFoo() ? 1 : 2);
-		assertType('non-empty-list<lowercase-string&non-empty-string>|false', $strSplitConstantStringWithVariableStringAndVariableSplitLength);
+		assertType('(non-empty-list<lowercase-string&non-empty-string>)|false', $strSplitConstantStringWithVariableStringAndVariableSplitLength);
 
 	}
 }

tests/PHPStan/Analyser/nsrt/bug-7580-php82.php

@@ -0,0 +1,20 @@
+<?php // lint >= 8.2
+
+declare(strict_types = 1);
+
+namespace Bug7580TypesPHP82;
+
+use function PHPStan\Testing\assertType;
+
+assertType('array{}', mb_str_split('', 1));
+
+assertType('array{\'x\'}', mb_str_split('x', 1));
+
+$v = (string) (mt_rand() === 0 ? '' : 'x');
+assertType('\'\'|\'x\'', $v);
+assertType('array{}|array{\'x\'}', mb_str_split($v, 1));
+
+function x(): string { throw new \Exception(); };
+$v = x();
+assertType('string', $v);
+assertType('list<non-empty-string>', mb_str_split($v, 1));

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

@@ -1,4 +1,6 @@
-<?php declare(strict_types = 1);
+<?php // lint < 8.2
+
+declare(strict_types = 1);
 
 namespace Bug7580Types;