Utilize composer min-php version to narrow PHP_VERSION_ID

.github/workflows/e2e-tests.yml

@@ -270,7 +270,35 @@ jobs:
               cd e2e/baseline-uninit-prop-trait
               ../../bin/phpstan analyse --configuration test-no-baseline.neon --generate-baseline test-baseline.neon
               ../../bin/phpstan analyse --configuration test.neon
-
+          - script: |
+              cd e2e/composer-max-version
+              composer install
+              ../../bin/phpstan analyze test.php --level=0
+          - script: |
+              cd e2e/composer-min-max-version
+              composer install
+              ../../bin/phpstan analyze test.php --level=0
+          - script: |
+              cd e2e/composer-min-open-end-version
+              composer install
+              ../../bin/phpstan analyze test.php --level=0
+          - script: |
+              cd e2e/composer-min-version-bc
+              composer install
+              ../../bin/phpstan analyze test.php --level=0
+          - script: |
+              cd e2e/composer-min-version
+              composer install
+              ../../bin/phpstan analyze test.php --level=0
+          - script: |
+              cd e2e/composer-version-config
+              composer install
+              ../../bin/phpstan analyze test.php --level=0
+          - script: |
+              cd e2e/composer-version-config-invalid
+              OUTPUT=$(../../bin/phpstan 2>&1 || true)
+              grep 'Invalid configuration' <<< "$OUTPUT"
+              grep 'Invalid PHP version range: phpVersion.max should be greater or equal to phpVersion.min.' <<< "$OUTPUT"
     steps:
       - name: "Checkout"
         uses: actions/checkout@v4

conf/config.neon

@@ -397,8 +397,16 @@ services:
 	-
 		class: PHPStan\Php\PhpVersionFactoryFactory
 		arguments:
-			versionId: %phpVersion%
+			phpVersion: %phpVersion%
 			composerAutoloaderProjectPaths: %composerAutoloaderProjectPaths%
+			bleedingEdge: %featureToggles.bleedingEdge%
+
+	-
+		class: PHPStan\Php\ComposerPhpVersionFactory
+		arguments:
+			phpVersion: %phpVersion%
+			composerAutoloaderProjectPaths: %composerAutoloaderProjectPaths%
+			bleedingEdge: %featureToggles.bleedingEdge%
 
 	-
 		class: PHPStan\PhpDocParser\Lexer\Lexer

conf/parametersSchema.neon

@@ -140,7 +140,13 @@ parametersSchema:
 		minimumNumberOfJobsPerProcess: int(),
 		buffer: int()
 	])
-	phpVersion: schema(anyOf(schema(int(), min(70100), max(80399))), nullable())
+	phpVersion: schema(anyOf(
+		schema(int(), min(70100), max(80399)),
+		structure([
+			min: schema(int(), min(70100), max(80399)),
+			max: schema(int(), min(70100), max(80399))
+		])
+	), nullable())
 	polluteScopeWithLoopInitialAssignments: bool()
 	polluteScopeWithAlwaysIterableForeach: bool()
 	propertyAlwaysWrittenTags: listOf(string())

e2e/composer-max-version/.gitignore

@@ -0,0 +1,2 @@
+/vendor/
+composer.lock

e2e/composer-max-version/composer.json

@@ -0,0 +1,5 @@
+{
+	"require": {
+		"php": "<=8.3"
+	}
+}

e2e/composer-max-version/phpstan.neon

@@ -0,0 +1,2 @@
+includes:
+	- ../../conf/bleedingEdge.neon

e2e/composer-max-version/test.php

@@ -0,0 +1,10 @@
+<?php
+
+\PHPStan\Testing\assertType('int<50207, 80300>', PHP_VERSION_ID);
+\PHPStan\Testing\assertType('int<5, 8>', PHP_MAJOR_VERSION);
+\PHPStan\Testing\assertType('int<0, max>', PHP_MINOR_VERSION);
+\PHPStan\Testing\assertType('int<0, max>', PHP_RELEASE_VERSION);
+
+\PHPStan\Testing\assertType('-1|0|1', version_compare(PHP_VERSION, '7.0.0'));
+\PHPStan\Testing\assertType('bool', version_compare(PHP_VERSION, '7.0.0', '<'));
+\PHPStan\Testing\assertType('bool', version_compare(PHP_VERSION, '7.0.0', '>'));

e2e/composer-min-max-version/.gitignore

@@ -0,0 +1,2 @@
+/vendor/
+composer.lock

e2e/composer-min-max-version/composer.json

@@ -0,0 +1,5 @@
+{
+	"require": {
+		"php": ">=8.1, <=8.2.99"
+	}
+}

e2e/composer-min-max-version/phpstan.neon

@@ -0,0 +1,2 @@
+includes:
+	- ../../conf/bleedingEdge.neon

e2e/composer-min-max-version/test.php

@@ -0,0 +1,10 @@
+<?php
+
+\PHPStan\Testing\assertType('int<80100, 80299>', PHP_VERSION_ID);
+\PHPStan\Testing\assertType('8', PHP_MAJOR_VERSION);
+\PHPStan\Testing\assertType('int<1, 2>', PHP_MINOR_VERSION);
+\PHPStan\Testing\assertType('int<0, max>', PHP_RELEASE_VERSION);
+
+\PHPStan\Testing\assertType('1', version_compare(PHP_VERSION, '7.0.0'));
+\PHPStan\Testing\assertType('false', version_compare(PHP_VERSION, '7.0.0', '<'));
+\PHPStan\Testing\assertType('true', version_compare(PHP_VERSION, '7.0.0', '>'));

e2e/composer-min-open-end-version/.gitignore

@@ -0,0 +1,2 @@
+/vendor/
+composer.lock

e2e/composer-min-open-end-version/composer.json

@@ -0,0 +1,5 @@
+{
+	"require": {
+		"php": ">= 8.1"
+	}
+}

e2e/composer-min-open-end-version/phpstan.neon

@@ -0,0 +1,2 @@
+includes:
+	- ../../conf/bleedingEdge.neon

e2e/composer-min-open-end-version/test.php

@@ -0,0 +1,6 @@
+<?php
+
+\PHPStan\Testing\assertType('int<80100, max>', PHP_VERSION_ID);
+\PHPStan\Testing\assertType('int<8, max>', PHP_MAJOR_VERSION);
+\PHPStan\Testing\assertType('int<0, max>', PHP_MINOR_VERSION);
+\PHPStan\Testing\assertType('int<0, max>', PHP_RELEASE_VERSION);

e2e/composer-min-version-bc/.gitignore

@@ -0,0 +1,2 @@
+/vendor/
+composer.lock

e2e/composer-min-version-bc/composer.json

@@ -0,0 +1,5 @@
+{
+	"require": {
+		"php": "^8.1"
+	}
+}

e2e/composer-min-version-bc/test.php

@@ -0,0 +1,7 @@
+<?php
+
+// no bleeding edge enabled
+\PHPStan\Testing\assertType('int<50207, max>', PHP_VERSION_ID);
+\PHPStan\Testing\assertType('int<5, max>', PHP_MAJOR_VERSION);
+\PHPStan\Testing\assertType('int<0, max>', PHP_MINOR_VERSION);
+\PHPStan\Testing\assertType('int<0, max>', PHP_RELEASE_VERSION);

e2e/composer-min-version/.gitignore

@@ -0,0 +1,2 @@
+/vendor/
+composer.lock

e2e/composer-min-version/composer.json

@@ -0,0 +1,5 @@
+{
+	"require": {
+		"php": "^8.1"
+	}
+}

e2e/composer-min-version/phpstan.neon

@@ -0,0 +1,2 @@
+includes:
+	- ../../conf/bleedingEdge.neon

e2e/composer-min-version/test.php

@@ -0,0 +1,6 @@
+<?php
+
+\PHPStan\Testing\assertType('int<80100, 90000>', PHP_VERSION_ID);
+\PHPStan\Testing\assertType('int<8, 9>', PHP_MAJOR_VERSION);
+\PHPStan\Testing\assertType('int<0, max>', PHP_MINOR_VERSION);
+\PHPStan\Testing\assertType('int<0, max>', PHP_RELEASE_VERSION);

e2e/composer-version-config-invalid/phpstan.neon

@@ -0,0 +1,7 @@
+includes:
+	- ../../conf/bleedingEdge.neon
+parameters:
+	phpVersion:
+		min: 80303
+		max: 80104
+

e2e/composer-version-config-patch/.gitignore

@@ -0,0 +1,2 @@
+/vendor/
+composer.lock

e2e/composer-version-config-patch/composer.json

@@ -0,0 +1,5 @@
+{
+	"require": {
+		"php": ">=8.0.2, <8.0.15"
+	}
+}

e2e/composer-version-config-patch/phpstan.neon

@@ -0,0 +1,2 @@
+includes:
+	- ../../conf/bleedingEdge.neon

e2e/composer-version-config-patch/test.php

@@ -0,0 +1,7 @@
+<?php
+
+// constraint from composer.json is overruled by phpstan.neon config
+\PHPStan\Testing\assertType('int<80001, 80015>', PHP_VERSION_ID);
+\PHPStan\Testing\assertType('8', PHP_MAJOR_VERSION);
+\PHPStan\Testing\assertType('0', PHP_MINOR_VERSION);
+\PHPStan\Testing\assertType('int<1, 15>', PHP_RELEASE_VERSION);

e2e/composer-version-config/.gitignore

@@ -0,0 +1,2 @@
+/vendor/
+composer.lock

e2e/composer-version-config/composer.json

@@ -0,0 +1,5 @@
+{
+	"require": {
+		"php": "^8.0"
+	}
+}

e2e/composer-version-config/phpstan.neon

@@ -0,0 +1,6 @@
+includes:
+	- ../../conf/bleedingEdge.neon
+parameters:
+	phpVersion:
+		min: 80103
+		max: 80304

e2e/composer-version-config/test.php

@@ -0,0 +1,11 @@
+<?php
+
+// constraint from composer.json is overruled by phpstan.neon config
+\PHPStan\Testing\assertType('int<80103, 80304>', PHP_VERSION_ID);
+\PHPStan\Testing\assertType('8', PHP_MAJOR_VERSION);
+\PHPStan\Testing\assertType('int<1, 3>', PHP_MINOR_VERSION);
+\PHPStan\Testing\assertType('int<0, max>', PHP_RELEASE_VERSION);
+
+\PHPStan\Testing\assertType('1', version_compare(PHP_VERSION, '7.0.0'));
+\PHPStan\Testing\assertType('false', version_compare(PHP_VERSION, '7.0.0', '<'));
+\PHPStan\Testing\assertType('true', version_compare(PHP_VERSION, '7.0.0', '>'));

src/Analyser/ConstantResolver.php

@@ -3,6 +3,7 @@
 namespace PHPStan\Analyser;
 
 use PhpParser\Node\Name;
+use PHPStan\Php\PhpVersion;
 use PHPStan\Reflection\NamespaceAnswerer;
 use PHPStan\Reflection\ReflectionProvider;
 use PHPStan\Reflection\ReflectionProvider\ReflectionProviderProvider;
@@ -20,6 +21,7 @@
 use PHPStan\Type\UnionType;
 use function array_key_exists;
 use function in_array;
+use function max;
 use function sprintf;
 use const INF;
 use const NAN;
@@ -34,7 +36,12 @@ class ConstantResolver
 	/**
 	 * @param string[] $dynamicConstantNames
 	 */
-	public function __construct(private ReflectionProviderProvider $reflectionProviderProvider, private array $dynamicConstantNames)
+	public function __construct(
+		private ReflectionProviderProvider $reflectionProviderProvider,
+		private array $dynamicConstantNames,
+		private ?PhpVersion $composerMinPhpVersion,
+		private ?PhpVersion $composerMaxPhpVersion,
+	)
 	{
 	}
 
@@ -77,16 +84,60 @@ public function resolvePredefinedConstant(string $resolvedConstantName): ?Type
 			]);
 		}
 		if ($resolvedConstantName === 'PHP_MAJOR_VERSION') {
-			return IntegerRangeType::fromInterval(5, null);
+			$minMajor = 5;
+			$maxMajor = null;
+
+			if ($this->composerMinPhpVersion !== null) {
+				$minMajor = max($minMajor, $this->composerMinPhpVersion->getMajor());
+			}
+			if ($this->composerMaxPhpVersion !== null) {
+				$maxMajor = $this->composerMaxPhpVersion->getMajor();
+			}
+
+			return $this->createInteger($minMajor, $maxMajor);
 		}
 		if ($resolvedConstantName === 'PHP_MINOR_VERSION') {
-			return IntegerRangeType::fromInterval(0, null);
+			$minMinor = 0;
+			$maxMinor = null;
+
+			if (
+				$this->composerMinPhpVersion !== null
+				&& $this->composerMaxPhpVersion !== null
+				&& $this->composerMaxPhpVersion->getMajor() === $this->composerMinPhpVersion->getMajor()
+			) {
+				$minMinor = $this->composerMinPhpVersion->getMinor();
+				$maxMinor = $this->composerMaxPhpVersion->getMinor();
+			}
+
+			return $this->createInteger($minMinor, $maxMinor);
 		}
 		if ($resolvedConstantName === 'PHP_RELEASE_VERSION') {
-			return IntegerRangeType::fromInterval(0, null);
+			$minRelease = 0;
+			$maxRelease = null;
+
+			if (
+				$this->composerMinPhpVersion !== null
+				&& $this->composerMaxPhpVersion !== null
+				&& $this->composerMaxPhpVersion->getMajor() === $this->composerMinPhpVersion->getMajor()
+				&& $this->composerMaxPhpVersion->getMinor() === $this->composerMinPhpVersion->getMinor()
+			) {
+				$minRelease = $this->composerMinPhpVersion->getPatch();
+				$maxRelease = $this->composerMaxPhpVersion->getPatch();
+			}
+
+			return $this->createInteger($minRelease, $maxRelease);
 		}
 		if ($resolvedConstantName === 'PHP_VERSION_ID') {
-			return IntegerRangeType::fromInterval(50207, null);
+			$minVersion = 50207;
+			$maxVersion = null;
+			if ($this->composerMinPhpVersion !== null) {
+				$minVersion = max($minVersion, $this->composerMinPhpVersion->getVersionId());
+			}
+			if ($this->composerMaxPhpVersion !== null) {
+				$maxVersion = $this->composerMaxPhpVersion->getVersionId();
+			}
+
+			return $this->createInteger($minVersion, $maxVersion);
 		}
 		if ($resolvedConstantName === 'PHP_ZTS') {
 			return new UnionType([
@@ -325,6 +376,14 @@ public function resolveClassConstantType(string $className, string $constantName
 		return $constantType;
 	}
 
+	private function createInteger(?int $min, ?int $max): Type
+	{
+		if ($min !== null && $min === $max) {
+			return new ConstantIntegerType($min);
+		}
+		return IntegerRangeType::fromInterval($min, $max);
+	}
+
 	private function getReflectionProvider(): ReflectionProvider
 	{
 		return $this->reflectionProviderProvider->getReflectionProvider();

src/Analyser/ConstantResolverFactory.php

@@ -3,6 +3,7 @@
 namespace PHPStan\Analyser;
 
 use PHPStan\DependencyInjection\Container;
+use PHPStan\Php\ComposerPhpVersionFactory;
 use PHPStan\Reflection\ReflectionProvider\ReflectionProviderProvider;
 
 class ConstantResolverFactory
@@ -17,9 +18,13 @@ public function __construct(
 
 	public function create(): ConstantResolver
 	{
+		$composerFactory = $this->container->getByType(ComposerPhpVersionFactory::class);
+
 		return new ConstantResolver(
 			$this->reflectionProviderProvider,
 			$this->container->getParameter('dynamicConstantNames'),
+			$composerFactory->getMinVersion(),
+			$composerFactory->getMaxVersion(),
 		);
 	}
 

src/DependencyInjection/ContainerFactory.php

@@ -36,6 +36,7 @@
 use PHPStan\Type\ObjectType;
 use Symfony\Component\Finder\Finder;
 use function array_diff_key;
+use function array_key_exists;
 use function array_map;
 use function array_merge;
 use function array_unique;
@@ -352,6 +353,18 @@ private function validateParameters(array $parameters, array $parametersSchema):
 			$context->path = ['parameters'];
 		};
 		$processor->process($schema, $parameters);
+
+		if (
+			!array_key_exists('phpVersion', $parameters)
+			|| !is_array($parameters['phpVersion'])) {
+			return;
+		}
+
+		$phpVersion = $parameters['phpVersion'];
+
+		if ($phpVersion['max'] < $phpVersion['min']) {
+			throw new InvalidPhpVersionException('Invalid PHP version range: phpVersion.max should be greater or equal to phpVersion.min.');
+		}
 	}
 
 	/**

src/DependencyInjection/InvalidPhpVersionException.php

@@ -0,0 +1,10 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\DependencyInjection;
+
+use Nette\DI\InvalidConfigurationException;
+
+class InvalidPhpVersionException extends InvalidConfigurationException
+{
+
+}