phpstan-bot · Sep 22, 2026 · Sep 22, 2026 · Sep 22, 2026 · Sep 22, 2026 · Sep 22, 2026
diff --git a/build/PHPStan/Build/NoInjectedPhpVersionInScopeAwareExtensionRule.php b/build/PHPStan/Build/NoInjectedPhpVersionInScopeAwareExtensionRule.php
@@ -0,0 +1,130 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Build;
+
+use PhpParser\Node;
+use PHPStan\Analyser\IgnoreErrorExtension;
+use PHPStan\Analyser\Scope;
+use PHPStan\Collectors\Collector;
+use PHPStan\Node\InClassNode;
+use PHPStan\Php\PhpVersion;
+use PHPStan\Rules\RestrictedUsage\RestrictedClassConstantUsageExtension;
+use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension;
+use PHPStan\Rules\RestrictedUsage\RestrictedFunctionUsageExtension;
+use PHPStan\Rules\RestrictedUsage\RestrictedMethodUsageExtension;
+use PHPStan\Rules\RestrictedUsage\RestrictedPropertyUsageExtension;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
+use PHPStan\Type\DynamicFunctionReturnTypeExtension;
+use PHPStan\Type\DynamicFunctionThrowTypeExtension;
+use PHPStan\Type\DynamicMethodReturnTypeExtension;
+use PHPStan\Type\DynamicMethodThrowTypeExtension;
+use PHPStan\Type\DynamicStaticMethodReturnTypeExtension;
+use PHPStan\Type\DynamicStaticMethodThrowTypeExtension;
+use PHPStan\Type\ExpressionTypeResolverExtension;
+use PHPStan\Type\FunctionParameterClosureThisExtension;
+use PHPStan\Type\FunctionParameterClosureTypeExtension;
+use PHPStan\Type\FunctionParameterOutTypeExtension;
+use PHPStan\Type\FunctionTypeSpecifyingExtension;
+use PHPStan\Type\MethodParameterClosureThisExtension;
+use PHPStan\Type\MethodParameterClosureTypeExtension;
+use PHPStan\Type\MethodParameterOutTypeExtension;
+use PHPStan\Type\MethodTypeSpecifyingExtension;
+use PHPStan\Type\StaticMethodParameterClosureThisExtension;
+use PHPStan\Type\StaticMethodParameterClosureTypeExtension;
+use PHPStan\Type\StaticMethodParameterOutTypeExtension;
+use PHPStan\Type\StaticMethodTypeSpecifyingExtension;
+use function sprintf;
+
+/**
+ * Every one of these extension interfaces hands the call's Scope to the extension,
+ * so the analysed PHP version must be read from Scope::getPhpVersion(). A DI-injected
+ * PhpVersion always answers with the configured version and silently ignores both
+ * PHP_VERSION_ID narrowing in the analysed code and configured version ranges.
+ *
+ * The list holds every extension interface with a method taking the public Scope.
+ * Interfaces taking the engine-internal MutatingScope (ExprHandler, StmtHandler) are not
+ * extensions in this sense, and OperatorTypeSpecifyingExtension gets no Scope at all,
+ * so both are absent on purpose. An extension interface added later belongs here too.
+ *
+ * @implements Rule<InClassNode>
+ */
+final class NoInjectedPhpVersionInScopeAwareExtensionRule implements Rule
+{
+
+	private const SCOPE_AWARE_EXTENSIONS = [
+		DynamicFunctionReturnTypeExtension::class,
+		DynamicMethodReturnTypeExtension::class,
+		DynamicStaticMethodReturnTypeExtension::class,
+		DynamicFunctionThrowTypeExtension::class,
+		DynamicMethodThrowTypeExtension::class,
+		DynamicStaticMethodThrowTypeExtension::class,
+		FunctionTypeSpecifyingExtension::class,
+		MethodTypeSpecifyingExtension::class,
+		StaticMethodTypeSpecifyingExtension::class,
+		FunctionParameterOutTypeExtension::class,
+		MethodParameterOutTypeExtension::class,
+		StaticMethodParameterOutTypeExtension::class,
+		FunctionParameterClosureTypeExtension::class,
+		MethodParameterClosureTypeExtension::class,
+		StaticMethodParameterClosureTypeExtension::class,
+		FunctionParameterClosureThisExtension::class,
+		MethodParameterClosureThisExtension::class,
+		StaticMethodParameterClosureThisExtension::class,
+		RestrictedClassConstantUsageExtension::class,
+		RestrictedClassNameUsageExtension::class,
+		RestrictedFunctionUsageExtension::class,
+		RestrictedMethodUsageExtension::class,
+		RestrictedPropertyUsageExtension::class,
+		ExpressionTypeResolverExtension::class,
+		IgnoreErrorExtension::class,
+		Collector::class,
+	];
+
+	public function getNodeType(): string
+	{
+		return InClassNode::class;
+	}
+
+	public function processNode(Node $node, Scope $scope): array
+	{
+		$classReflection = $node->getClassReflection();
+		if (!$classReflection->hasConstructor()) {
+			return [];
+		}
+
+		$implementedExtension = null;
+		foreach (self::SCOPE_AWARE_EXTENSIONS as $extensionInterface) {
+			if (!$classReflection->is($extensionInterface)) {
+				continue;
+			}
+
+			$implementedExtension = $extensionInterface;
+			break;
+		}
+
+		if ($implementedExtension === null) {
+			return [];
+		}
+
+		$constructorVariant = $classReflection->getConstructor()->getOnlyVariant();
+		$errors = [];
+		foreach ($constructorVariant->getParameters() as $parameter) {
+			foreach ($parameter->getType()->getObjectClassNames() as $className) {
+				if ($className !== PhpVersion::class) {
+					continue;
+				}
+
+				$errors[] = RuleErrorBuilder::message(sprintf(
+					'%s implements %s and must not inject %s - read the analysed PHP version from Scope::getPhpVersion() instead.',
+					$classReflection->getDisplayName(),
+					$implementedExtension,
+					PhpVersion::class,
+				))->identifier('phpstanBuild.phpVersionInExtension')->build();
+			}
+		}
+
+		return $errors;
+	}
+
+}
diff --git a/build/phpstan.neon b/build/phpstan.neon
@@ -201,6 +201,7 @@ parameters:
 rules:
 	- PHPStan\Build\FinalClassRule
 	- PHPStan\Build\NoScopeTypeReadInEngineRule
+	- PHPStan\Build\NoInjectedPhpVersionInScopeAwareExtensionRule
 	- PHPStan\Build\AttributeNamedArgumentsRule
 	- PHPStan\Build\NamedArgumentsRule
 	- PHPStan\Build\OverrideAttributeThirdPartyMethodRule

diff --git a/phpstan-baseline.neon b/phpstan-baseline.neon
@@ -1548,6 +1548,12 @@ parameters:
 			count: 2
 			path: src/Type/Php/MinMaxFunctionReturnTypeExtension.php
 
+		-
+			rawMessage: 'PHPStan\Type\Php\PDOConnectReturnTypeExtension implements PHPStan\Type\DynamicStaticMethodReturnTypeExtension and must not inject PHPStan\Php\PhpVersion - read the analysed PHP version from Scope::getPhpVersion() instead.'
+			identifier: phpstanBuild.phpVersionInExtension
+			count: 1
+			path: src/Type/Php/PDOConnectReturnTypeExtension.php
+
 		-
 			rawMessage: 'Doing instanceof PHPStan\Type\Constant\ConstantStringType is error-prone and deprecated. Use Type::getConstantStrings() instead.'
 			identifier: phpstanApi.instanceofType

diff --git a/src/Php/PhpVersions.php b/src/Php/PhpVersions.php
@@ -188,9 +188,106 @@ public function supportsDeprecatedTraits(): TrinaryLogic
 		return IntegerRangeType::fromInterval(80500, null)->isSuperTypeOf($this->phpVersions)->result;
 	}
 
+	public function arrayFunctionsReturnNullWithNonArray(): TrinaryLogic
+	{
+		return IntegerRangeType::fromInterval(null, 79999)->isSuperTypeOf($this->phpVersions)->result;
+	}
+
+	public function hasDateTimeExceptions(): TrinaryLogic
+	{
+		return IntegerRangeType::fromInterval(80300, null)->isSuperTypeOf($this->phpVersions)->result;
+	}
+
+	public function hasFilterThrowOnFailureConstant(): TrinaryLogic
+	{
+		return IntegerRangeType::fromInterval(80500, null)->isSuperTypeOf($this->phpVersions)->result;
+	}
+
+	public function hasPDOSubclasses(): TrinaryLogic
+	{
+		return IntegerRangeType::fromInterval(80400, null)->isSuperTypeOf($this->phpVersions)->result;
+	}
+
+	public function hasStricterRoundFunctions(): TrinaryLogic
+	{
+		return IntegerRangeType::fromInterval(80000, null)->isSuperTypeOf($this->phpVersions)->result;
+	}
+
+	public function highlightStringDoesNotReturnFalse(): TrinaryLogic
+	{
+		return IntegerRangeType::fromInterval(80400, null)->isSuperTypeOf($this->phpVersions)->result;
+	}
+
+	public function isEmptyStringValidAliasForNoneInMbSubstituteCharacter(): TrinaryLogic
+	{
+		return IntegerRangeType::fromInterval(null, 79999)->isSuperTypeOf($this->phpVersions)->result;
+	}
+
+	public function isNullValidArgInMbSubstituteCharacter(): TrinaryLogic
+	{
+		return IntegerRangeType::fromInterval(80000, null)->isSuperTypeOf($this->phpVersions)->result;
+	}
+
+	public function isNumericStringValidArgInMbSubstituteCharacter(): TrinaryLogic
+	{
+		return IntegerRangeType::fromInterval(null, 79999)->isSuperTypeOf($this->phpVersions)->result;
+	}
+
+	public function strSplitReturnsEmptyArray(): TrinaryLogic
+	{
+		return IntegerRangeType::fromInterval(80200, null)->isSuperTypeOf($this->phpVersions)->result;
+	}
+
+	public function substrReturnFalseInsteadOfEmptyString(): TrinaryLogic
+	{
+		return IntegerRangeType::fromInterval(null, 79999)->isSuperTypeOf($this->phpVersions)->result;
+	}
+
+	public function supportsAllUnicodeScalarCodePointsInMbSubstituteCharacter(): TrinaryLogic
+	{
+		return IntegerRangeType::fromInterval(70200, null)->isSuperTypeOf($this->phpVersions)->result;
+	}
+
 	public function supportsHhPrintfSpecifier(): TrinaryLogic
 	{
 		return IntegerRangeType::fromInterval(80000, null)->isSuperTypeOf($this->phpVersions)->result;
 	}
 
+	public function supportsPassNoneEncodings(): TrinaryLogic
+	{
+		return IntegerRangeType::fromInterval(null, 70299)->isSuperTypeOf($this->phpVersions)->result;
+	}
+
+	public function supportsPregCaptureOnlyNamedGroups(): TrinaryLogic
+	{
+		// https://php.watch/versions/8.2/preg-n-no-capture-modifier
+		return IntegerRangeType::fromInterval(80200, null)->isSuperTypeOf($this->phpVersions)->result;
+	}
+
+	public function supportsPregUnmatchedAsNull(): TrinaryLogic
+	{
+		// while PREG_UNMATCHED_AS_NULL is defined in php-src since 7.2.x it starts working as expected with 7.4.x
+		// https://3v4l.org/v3HE4
+		return IntegerRangeType::fromInterval(70400, null)->isSuperTypeOf($this->phpVersions)->result;
+	}
+
+	public function throwsOnInvalidMbStringEncoding(): TrinaryLogic
+	{
+		return IntegerRangeType::fromInterval(80000, null)->isSuperTypeOf($this->phpVersions)->result;
+	}
+
+	public function throwsValueErrorForInvalidRoundingMode(): TrinaryLogic
+	{
+		return IntegerRangeType::fromInterval(80400, null)->isSuperTypeOf($this->phpVersions)->result;
+	}
+
+	/**
+	 * PHPStan's BetterReflection adapters keep their narrowed native return types only on PHP 8+;
+	 * the downgraded PHP 7 build widens them back to the core Reflection ones.
+	 */
+	public function supportsNativeReflectionAdapterReturnTypes(): TrinaryLogic
+	{
+		return IntegerRangeType::fromInterval(80000, null)->isSuperTypeOf($this->phpVersions)->result;
+	}
+
 }
diff --git a/src/Reflection/BetterReflection/Type/AdapterReflectionEnumCaseDynamicReturnTypeExtension.php b/src/Reflection/BetterReflection/Type/AdapterReflectionEnumCaseDynamicReturnTypeExtension.php
@@ -5,7 +5,6 @@
 use PhpParser\Node\Expr\MethodCall;
 use PHPStan\Analyser\Scope;
 use PHPStan\BetterReflection\Reflection\Adapter\ReflectionType;
-use PHPStan\Php\PhpVersion;
 use PHPStan\Reflection\MethodReflection;
 use PHPStan\Type\Constant\ConstantBooleanType;
 use PHPStan\Type\DynamicMethodReturnTypeExtension;
@@ -22,7 +21,7 @@ final class AdapterReflectionEnumCaseDynamicReturnTypeExtension implements Dynam
 	/**
 	 * @param class-string $class
 	 */
-	public function __construct(private PhpVersion $phpVersion, private string $class)
+	public function __construct(private string $class)
 	{
 	}
 
@@ -41,7 +40,7 @@ public function isMethodSupported(MethodReflection $methodReflection): bool
 
 	public function getTypeFromMethodCall(MethodReflection $methodReflection, MethodCall $methodCall, Scope $scope): ?Type
 	{
-		if ($this->phpVersion->getVersionId() >= 80000) {
+		if (!$scope->getPhpVersion()->supportsNativeReflectionAdapterReturnTypes()->no()) {
 			return null;
 		}
 

diff --git a/src/Reflection/BetterReflection/Type/AdapterReflectionEnumDynamicReturnTypeExtension.php b/src/Reflection/BetterReflection/Type/AdapterReflectionEnumDynamicReturnTypeExtension.php
@@ -9,7 +9,6 @@
 use PHPStan\BetterReflection\Reflection\Adapter\ReflectionEnum;
 use PHPStan\BetterReflection\Reflection\Adapter\ReflectionNamedType;
 use PHPStan\DependencyInjection\AutowiredService;
-use PHPStan\Php\PhpVersion;
 use PHPStan\Reflection\MethodReflection;
 use PHPStan\Type\Accessory\AccessoryNonEmptyStringType;
 use PHPStan\Type\Constant\ConstantBooleanType;
@@ -27,10 +26,6 @@
 final class AdapterReflectionEnumDynamicReturnTypeExtension implements DynamicMethodReturnTypeExtension
 {
 
-	public function __construct(private PhpVersion $phpVersion)
-	{
-	}
-
 	public function getClass(): string
 	{
 		return ReflectionEnum::class;
@@ -52,7 +47,7 @@ public function isMethodSupported(MethodReflection $methodReflection): bool
 
 	public function getTypeFromMethodCall(MethodReflection $methodReflection, MethodCall $methodCall, Scope $scope): ?Type
 	{
-		if ($this->phpVersion->getVersionId() >= 80000) {
+		if (!$scope->getPhpVersion()->supportsNativeReflectionAdapterReturnTypes()->no()) {
 			return null;
 		}
 

diff --git a/src/Reflection/PHPStan/NativeReflectionEnumReturnDynamicReturnTypeExtension.php b/src/Reflection/PHPStan/NativeReflectionEnumReturnDynamicReturnTypeExtension.php
@@ -5,7 +5,6 @@
 use PhpParser\Node\Expr\MethodCall;
 use PHPStan\Analyser\Scope;
 use PHPStan\BetterReflection\Reflection\Adapter\ReflectionClass;
-use PHPStan\Php\PhpVersion;
 use PHPStan\Reflection\MethodReflection;
 use PHPStan\Type\DynamicMethodReturnTypeExtension;
 use PHPStan\Type\ObjectType;
@@ -17,7 +16,7 @@ final class NativeReflectionEnumReturnDynamicReturnTypeExtension implements Dyna
 	/**
 	 * @param class-string $className
 	 */
-	public function __construct(private PhpVersion $phpVersion, private string $className, private string $methodName)
+	public function __construct(private string $className, private string $methodName)
 	{
 	}
 
@@ -33,7 +32,7 @@ public function isMethodSupported(MethodReflection $methodReflection): bool
 
 	public function getTypeFromMethodCall(MethodReflection $methodReflection, MethodCall $methodCall, Scope $scope): ?Type
 	{
-		if ($this->phpVersion->getVersionId() >= 80000) {
+		if (!$scope->getPhpVersion()->supportsNativeReflectionAdapterReturnTypes()->no()) {
 			return null;
 		}
 

diff --git a/src/Rules/Functions/FilterVarRule.php b/src/Rules/Functions/FilterVarRule.php
@@ -7,7 +7,6 @@
 use PhpParser\Node\Name;
 use PHPStan\Analyser\Scope;
 use PHPStan\DependencyInjection\RegisteredRule;
-use PHPStan\Php\PhpVersion;
 use PHPStan\Reflection\ReflectionProvider;
 use PHPStan\Rules\Rule;
 use PHPStan\Rules\RuleErrorBuilder;
@@ -25,7 +24,6 @@ public function __construct(
 		private ReflectionProvider $reflectionProvider,
 		private FilterFunctionReturnTypeHelper $filterFunctionReturnTypeHelper,
 		private FilterFunctionFlagsHelper $filterFunctionFlagsHelper,
-		private PhpVersion $phpVersion,
 	)
 	{
 	}
@@ -51,7 +49,7 @@ public function processNode(Node $node, Scope $scope): array
 		}
 
 		if (
-			!$this->phpVersion->hasFilterThrowOnFailureConstant()
+			$scope->getPhpVersion()->hasFilterThrowOnFailureConstant()->no()
 			|| !$this->reflectionProvider->hasConstant(new Name\FullyQualified('FILTER_THROW_ON_FAILURE'), null)
 		) {
 			return [];