Use the PHP versions of the scope in the range() return type extension

`Scope::getPhpVersion()` follows conditions like `PHP_VERSION_ID < 80000`,
so the tests move into `nsrt/` and no longer need separate test classes
with a fixed `phpVersion`.

When a combination fails at runtime but the analysed PHP versions might
accept its step, the other constant combinations are not returned on
their own anymore.

Author: zonuexe

src/Php/PhpVersion.php

@@ -531,13 +531,4 @@ public function throwsOnStringCast(): bool
 		return $this->versionId >= 70400;
 	}
 
-	/**
-	 * PHP 8.3 rejects a negative or non-finite step, always builds a character range
-	 * from two string boundaries and no longer turns an integral float step into floats.
-	 */
-	public function hasStricterRangeFunction(): bool
-	{
-		return $this->versionId >= 80300;
-	}
-
 }

src/Php/PhpVersions.php

@@ -61,4 +61,18 @@ public function supportsMaxMemoryLimit(): TrinaryLogic
 		return IntegerRangeType::fromInterval(80500, null)->isSuperTypeOf($this->phpVersions)->result;
 	}
 
+	public function throwsValueErrorForInternalFunctions(): TrinaryLogic
+	{
+		return IntegerRangeType::fromInterval(80000, null)->isSuperTypeOf($this->phpVersions)->result;
+	}
+
+	/**
+	 * PHP 8.3 rejects a negative or non-finite step, always builds a character range
+	 * from two string boundaries and no longer turns an integral float step into floats.
+	 */
+	public function hasStricterRangeFunction(): TrinaryLogic
+	{
+		return IntegerRangeType::fromInterval(80300, null)->isSuperTypeOf($this->phpVersions)->result;
+	}
+
 }

src/Type/Php/RangeFunctionReturnTypeExtension.php

@@ -5,8 +5,8 @@
 use PhpParser\Node\Expr\FuncCall;
 use PHPStan\Analyser\Scope;
 use PHPStan\DependencyInjection\AutowiredService;
-use PHPStan\Php\PhpVersion;
 use PHPStan\Reflection\FunctionReflection;
+use PHPStan\TrinaryLogic;
 use PHPStan\Type\Accessory\AccessoryArrayListType;
 use PHPStan\Type\Accessory\AccessoryLiteralStringType;
 use PHPStan\Type\Accessory\AccessoryNonEmptyStringType;
@@ -42,10 +42,6 @@ final class RangeFunctionReturnTypeExtension implements DynamicFunctionReturnTyp
 
 	private const RANGE_LENGTH_THRESHOLD = 50;
 
-	public function __construct(private PhpVersion $phpVersion)
-	{
-	}
-
 	public function isFunctionSupported(FunctionReflection $functionReflection): bool
 	{
 		return $functionReflection->getName() === 'range';
@@ -62,10 +58,15 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 		$endType = $scope->getType($args[1]->value);
 		$stepType = count($args) >= 3 ? $scope->getType($args[2]->value) : new ConstantIntegerType(1);
 
+		$phpVersions = $scope->getPhpVersion();
+		$hasStricterRange = $phpVersions->hasStricterRangeFunction();
+		$throwsValueError = $phpVersions->throwsValueErrorForInternalFunctions();
+
 		$constantReturnTypes = [];
 		$constantCombinations = 0;
 		$throwingCombinations = 0;
 		$hasSkippedCombination = false;
+		$hasUnknownCombination = false;
 
 		$startConstants = $startType->getConstantScalarTypes();
 		foreach ($startConstants as $startConstant) {
@@ -98,12 +99,14 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 
 					// PHP 7 reports an invalid step by returning false instead of throwing a ValueError
 					if ($rangeValues === false) {
-						if ($this->failsOnAnalysedVersion($startConstant->getValue(), $endConstant->getValue(), $stepConstant->getValue())) {
-							if ($this->phpVersion->throwsValueErrorForInternalFunctions()) {
-								$throwingCombinations++;
-							} else {
-								$constantReturnTypes[] = new ConstantBooleanType(false);
-							}
+						$fails = self::failsOnAnalysedVersion($hasStricterRange, $startConstant->getValue(), $endConstant->getValue(), $stepConstant->getValue());
+						if (!$fails->yes()) {
+							// the analysed PHP version might accept the step, but only the runtime's verdict is known
+							$hasUnknownCombination = true;
+						} elseif ($throwsValueError->yes()) {
+							$throwingCombinations++;
+						} else {
+							$constantReturnTypes[] = new ConstantBooleanType(false);
 						}
 						continue;
 					}
@@ -127,7 +130,8 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 							);
 						}
 
-						return $this->getLargeRangeType(
+						return self::getLargeRangeType(
+							$hasStricterRange,
 							$rangeValues,
 							$startConstant->getValue(),
 							$endConstant->getValue(),
@@ -144,6 +148,10 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 			}
 		}
 
+		if ($hasUnknownCombination) {
+			$constantReturnTypes = [];
+		}
+
 		if (count($constantReturnTypes) > 0) {
 			return TypeCombinator::union(...$constantReturnTypes);
 		}
@@ -198,14 +206,22 @@ public function getTypeFromFunctionCall(FunctionReflection $functionReflection,
 	/**
 	 * The constant arguments are folded by calling range() on the PHP version PHPStan
 	 * itself runs on, so a failure only says that the runtime rejects the step.
-	 * This checks whether the analysed PHP version rejects it as well.
+	 * This checks whether the analysed PHP versions reject it as well.
 	 */
-	private function failsOnAnalysedVersion(int|float|string $start, int|float|string $end, int|float $step): bool
+	private static function failsOnAnalysedVersion(TrinaryLogic $hasStricterRange, int|float|string $start, int|float|string $end, int|float $step): TrinaryLogic
 	{
-		if ($this->phpVersion->hasStricterRangeFunction()) {
-			return true;
+		if (self::failsBeforePhp83($start, $end, $step)) {
+			return TrinaryLogic::createYes();
 		}
 
+		return $hasStricterRange;
+	}
+
+	/**
+	 * PHP 7.x reported these steps with a warning and false, PHP 8.0-8.2 with a ValueError.
+	 */
+	private static function failsBeforePhp83(int|float|string $start, int|float|string $end, int|float $step): bool
+	{
 		if (is_string($start) || is_string($end)) {
 			// how a string boundary was coerced before PHP 8.3 is not modelled here
 			return false;
@@ -232,7 +248,7 @@ private function failsOnAnalysedVersion(int|float|string $start, int|float|strin
 	/**
 	 * @param non-empty-list<int|float|string> $rangeValues
 	 */
-	private function getLargeRangeType(array $rangeValues, int|float|string $start, int|float|string $end, int|float $step): IntersectionType
+	private static function getLargeRangeType(TrinaryLogic $hasStricterRange, array $rangeValues, int|float|string $start, int|float|string $end, int|float $step): Type
 	{
 		// range() only ever returns values of a single type
 		$firstValue = $rangeValues[0];
@@ -247,25 +263,28 @@ private function getLargeRangeType(array $rangeValues, int|float|string $start,
 			));
 		}
 
-		if (
-			is_float($firstValue)
-			|| is_float($lastValue)
-			// before PHP 8.3 a float argument produced floats even when none of
-			// the arguments had a fractional part
-			|| (
-				!$this->phpVersion->hasStricterRangeFunction()
-				&& (is_float($start) || is_float($end) || is_float($step))
-			)
-		) {
-			return self::getNonEmptyListOfType(new FloatType());
+		$floatListType = self::getNonEmptyListOfType(new FloatType());
+		if (is_float($firstValue) || is_float($lastValue)) {
+			return $floatListType;
 		}
 
 		// the sequence is monotonic, so the first and the last value are its bounds
 		if ($firstValue > $lastValue) {
 			[$firstValue, $lastValue] = [$lastValue, $firstValue];
 		}
 
-		return self::getNonEmptyListOfType(IntegerRangeType::fromInterval($firstValue, $lastValue));
+		$intListType = self::getNonEmptyListOfType(IntegerRangeType::fromInterval($firstValue, $lastValue));
+		if ($hasStricterRange->yes() || (!is_float($start) && !is_float($end) && !is_float($step))) {
+			return $intListType;
+		}
+
+		// before PHP 8.3 a float argument produced floats even when none of
+		// the arguments had a fractional part
+		if ($hasStricterRange->no()) {
+			return $floatListType;
+		}
+
+		return TypeCombinator::union($intListType, $floatListType);
 	}
 
 	private static function getNonEmptyListOfType(Type $type): IntersectionType

tests/PHPStan/Analyser/RangePhp74Test.php

@@ -7,26 +7,32 @@
 // https://github.com/phpstan/phpstan/issues/10022
 assertType('array{\'1\', \'2\', \'3\', \'4\', \'5\', \'6\', \'7\', \'8\', \'9\', \':\', \';\', \'<\', \'=\', \'>\', \'?\', \'@\', \'A\', \'B\', \'C\', \'D\', \'E\', \'F\', \'G\', \'H\', \'I\', \'J\', \'K\', \'L\', \'M\', \'N\', \'O\', \'P\', \'Q\', \'R\', \'S\', \'T\', \'U\', \'V\', \'W\', \'X\', \'Y\', \'Z\', \'[\', \'\\\\\', \']\', \'^\', \'_\', \'`\', \'a\'}', range('1', 'a'));
 
-// an invalid step is reported as a ValueError since PHP 8.0
-assertType('*NEVER*', range(2, 5, 0));
-assertType('*NEVER*', range('a', 'z', 0));
-assertType('*NEVER*', range(5, 6, 3));
-assertType('*NEVER*', range(2, 5, -1));
-assertType('*NEVER*', range('a', 'z', -1));
-assertType('*NEVER*', range(1, 10, INF));
-assertType('*NEVER*', range(1, 10, NAN));
-
-function maybeInvalidStep(bool $flag): void
+function doFoo(bool $flag): void
 {
-	// only one of the constant combinations throws, the other one returns a range
-	assertType('array{6}', range($flag ? 5 : 6, 6, 3));
+	if (PHP_VERSION_ID >= 80300) {
+		// a negative step on an increasing range and a non-finite step throw a ValueError since PHP 8.3
+		assertType('*NEVER*', range(2, 5, -1));
+		assertType('*NEVER*', range('a', 'z', -1));
+		assertType('*NEVER*', range('a', 'z', 0));
+		assertType('*NEVER*', range(1, 10, NAN));
+
+		// an integral float step produces ints since PHP 8.3
+		assertType('non-empty-list<int<1, 200>>', range(1, 200, 1.0));
+	} elseif (PHP_VERSION_ID >= 80000) {
+		// the sign of the step used to be ignored
+		assertType('non-empty-list<int>', range(2, 5, -1));
+		assertType('non-empty-list<string>', range('a', 'z', -1));
+		assertType('non-empty-list<float|int>', range(1, 10, NAN));
+
+		// a float argument used to produce floats even without a fractional part
+		assertType('non-empty-list<float>', range(1, 200, 1.0));
+	}
+
+	// ranges longer than the threshold are generalized from the returned values
+	assertType('non-empty-list<float>', range(1.0, 100.0));
+	assertType('non-empty-list<literal-string&non-empty-string>', range('A', 'z'));
 
 	// a step that is neither an int nor a float is not folded at all, so nothing
 	// can be said about the combination it belongs to
 	assertType('non-empty-list<float|int>', range(2, 5, $flag ? 0 : true));
 }
-
-// ranges longer than the threshold are generalized from the returned values
-assertType('non-empty-list<int<1, 200>>', range(1, 200, 1.0));
-assertType('non-empty-list<float>', range(1.0, 100.0));
-assertType('non-empty-list<literal-string&non-empty-string>', range('A', 'z'));

tests/PHPStan/Analyser/RangePhp82Test.php

@@ -0,0 +1,22 @@
+<?php
+
+namespace RangeInvalidStep;
+
+use function PHPStan\Testing\assertType;
+
+function doFoo(bool $flag): void
+{
+	if (PHP_VERSION_ID >= 80000) {
+		// a step of 0 or one wider than the range throws a ValueError since PHP 8.0
+		assertType('*NEVER*', range(2, 5, 0));
+		assertType('*NEVER*', range(5, 6, 3));
+		assertType('*NEVER*', range(1, 10, INF));
+		assertType('array{6}', range($flag ? 5 : 6, 6, 3));
+	} else {
+		// PHP 7 reports an invalid step with a warning and returns false instead
+		assertType('false', range(2, 5, 0));
+		assertType('false', range(5, 6, 3));
+		assertType('false', range(1, 10, INF));
+		assertType('array{6}|false', range($flag ? 5 : 6, 6, 3));
+	}
+}