Implement Scope->getPhpVersion()

Author: staabm

src/Analyser/MutatingScope.php

@@ -47,6 +47,7 @@
 use PHPStan\Parser\NewAssignedToPropertyVisitor;
 use PHPStan\Parser\Parser;
 use PHPStan\Php\PhpVersion;
+use PHPStan\Php\PhpVersions;
 use PHPStan\PhpDoc\Tag\TemplateTag;
 use PHPStan\Reflection\Assertions;
 use PHPStan\Reflection\Callables\CallableParametersAcceptor;
@@ -144,6 +145,7 @@
 use function implode;
 use function in_array;
 use function is_bool;
+use function is_int;
 use function is_numeric;
 use function is_string;
 use function ltrim;
@@ -5721,4 +5723,34 @@ public function getIterableValueType(Type $iteratee): Type
 		return $iteratee->getIterableValueType();
 	}
 
+	public function getPhpVersions(): PhpVersions
+	{
+		$versionId = $this->getType(new ConstFetch(new Name('PHP_VERSION_ID')));
+		if ($versionId instanceof IntegerRangeType) {
+			if ($versionId->getMin() !== null && $versionId->getMax() !== null) {
+				return new PhpVersions([$versionId->getMin(), $versionId->getMax()]);
+			}
+			if ($versionId->getMin() !== null) {
+				return new PhpVersions([$versionId->getMin()]);
+			}
+			if ($versionId->getMax() !== null) {
+				return new PhpVersions([$versionId->getMax()]);
+			}
+		}
+
+		$scalars = $versionId->getConstantScalarValues();
+		if ($scalars !== []) {
+			$ints = [];
+			foreach ($scalars as $scalar) {
+				if (!is_int($scalar)) {
+					throw new ShouldNotHappenException();
+				}
+				$ints[] = $scalar;
+			}
+			return new PhpVersions($ints);
+		}
+
+		return new PhpVersions([$this->phpVersion->getVersionId()]);
+	}
+
 }

src/Analyser/Scope.php

@@ -6,6 +6,7 @@
 use PhpParser\Node\Expr;
 use PhpParser\Node\Name;
 use PhpParser\Node\Param;
+use PHPStan\Php\PhpVersions;
 use PHPStan\Reflection\ClassConstantReflection;
 use PHPStan\Reflection\ClassMemberAccessAnswerer;
 use PHPStan\Reflection\ClassReflection;
@@ -136,4 +137,6 @@ public function filterByFalseyValue(Expr $expr): self;
 
 	public function isInFirstLevelStatement(): bool;
 
+	public function getPhpVersions(): PhpVersions;
+
 }

src/Php/PhpVersions.php

@@ -0,0 +1,58 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Php;
+
+use PHPStan\ShouldNotHappenException;
+use PHPStan\TrinaryLogic;
+use function max;
+use function min;
+
+/**
+ * @api
+ */
+final class PhpVersions
+{
+
+	private int $minVersionId;
+
+	private int $maxVersionId;
+
+	/**
+	 * @api
+	 * @param list<int> $phpVersionIds
+	 */
+	public function __construct(
+		array $phpVersionIds,
+	)
+	{
+		if ($phpVersionIds === []) {
+			throw new ShouldNotHappenException();
+		}
+
+		$normalizedPhpVersionIds = [];
+		foreach ($phpVersionIds as $versionId) {
+			// drop patch version part and replace with 00
+			$normalizedPhpVersionIds[] = ((int) ($versionId / 100)) * 100;
+		}
+
+		$this->minVersionId = min($normalizedPhpVersionIds);
+		$this->maxVersionId = max($normalizedPhpVersionIds);
+	}
+
+	public function producesWarningForFinalPrivateMethods(): TrinaryLogic
+	{
+		return $this->minPhpVersion(80000);
+	}
+
+	private function minPhpVersion(int $versionId): TrinaryLogic
+	{
+		if ($this->minVersionId >= $versionId) {
+			return TrinaryLogic::createYes();
+		}
+		if ($this->maxVersionId >= $versionId) {
+			return TrinaryLogic::createMaybe();
+		}
+		return TrinaryLogic::createNo();
+	}
+
+}

src/Rules/Methods/FinalPrivateMethodRule.php

@@ -5,7 +5,6 @@
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
 use PHPStan\Node\InClassMethodNode;
-use PHPStan\Php\PhpVersion;
 use PHPStan\Rules\Rule;
 use PHPStan\Rules\RuleErrorBuilder;
 use function sprintf;
@@ -14,12 +13,6 @@
 final class FinalPrivateMethodRule implements Rule
 {
 
-	public function __construct(
-		private PhpVersion $phpVersion,
-	)
-	{
-	}
-
 	public function getNodeType(): string
 	{
 		return InClassMethodNode::class;
@@ -28,7 +21,7 @@ public function getNodeType(): string
 	public function processNode(Node $node, Scope $scope): array
 	{
 		$method = $node->getMethodReflection();
-		if (!$this->phpVersion->producesWarningForFinalPrivateMethods()) {
+		if ($scope->getPhpVersions()->producesWarningForFinalPrivateMethods()->no()) {
 			return [];
 		}
 

tests/PHPStan/Rules/Methods/FinalPrivateMethodRuleTest.php

@@ -2,50 +2,34 @@
 
 namespace PHPStan\Rules\Methods;
 
-use PHPStan\Php\PhpVersion;
 use PHPStan\Rules\Rule;
 use PHPStan\Testing\RuleTestCase;
 
 /** @extends RuleTestCase<FinalPrivateMethodRule> */
 class FinalPrivateMethodRuleTest extends RuleTestCase
 {
 
-	private int $phpVersionId;
-
 	protected function getRule(): Rule
 	{
-		return new FinalPrivateMethodRule(
-			new PhpVersion($this->phpVersionId),
-		);
+		return new FinalPrivateMethodRule();
 	}
 
-	public function dataRule(): array
+	public function testRule(): void
 	{
-		return [
+		$this->analyse([__DIR__ . '/data/final-private-method.php'], [
 			[
-				70400,
-				[],
+				'Private method FinalPrivateMethod\Foo::foo() cannot be final as it is never overridden by other classes.',
+				8,
 			],
 			[
-				80000,
-				[
-					[
-						'Private method FinalPrivateMethod\Foo::foo() cannot be final as it is never overridden by other classes.',
-						8,
-					],
-				],
+				'Private method FinalPrivateMethod\FooBarPhp8orHigher::foo() cannot be final as it is never overridden by other classes.',
+				39,
 			],
-		];
-	}
-
-	/**
-	 * @dataProvider dataRule
-	 * @param list<array{0: string, 1: int, 2?: string}> $errors
-	 */
-	public function testRule(int $phpVersion, array $errors): void
-	{
-		$this->phpVersionId = $phpVersion;
-		$this->analyse([__DIR__ . '/data/final-private-method.php'], $errors);
+			[
+				'Private method FinalPrivateMethod\FooBarPhp74OrHigher::foo() cannot be final as it is never overridden by other classes.',
+				59,
+			],
+		]);
 	}
 
 }

tests/PHPStan/Rules/Methods/data/final-private-method.php

@@ -31,3 +31,33 @@ final private function __construct()
 	}
 
 }
+
+if (PHP_VERSION_ID >= 80000) {
+	class FooBarPhp8orHigher
+	{
+
+		final private function foo(): void
+		{
+		}
+	}
+}
+
+if (PHP_VERSION_ID < 80000) {
+	class FooBarPhp7
+	{
+
+		final private function foo(): void
+		{
+		}
+	}
+}
+
+if (PHP_VERSION_ID > 70400) {
+	class FooBarPhp74OrHigher
+	{
+
+		final private function foo(): void
+		{
+		}
+	}
+}