Add AlwaysUsedClassConstantsExtension interface

Author: jdecool

conf/config.neon

@@ -773,6 +773,9 @@ services:
 	-
 		class: PHPStan\Rules\NullsafeCheck
 
+	-
+		class: PHPStan\Rules\Constants\LazyAlwaysUsedClassConstantsExtensionProvider
+
 	-
 		class: PHPStan\Rules\Properties\LazyReadWritePropertiesExtensionProvider
 

src/Rules/Constants/AlwaysUsedClassConstantsExtension.php

@@ -0,0 +1,12 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Constants;
+
+use PHPStan\Reflection\ConstantReflection;
+
+interface AlwaysUsedClassConstantsExtension
+{
+
+	public function isAlwaysUsed(ConstantReflection $constant): bool;
+
+}

src/Rules/Constants/AlwaysUsedClassConstantsExtensionProvider.php

@@ -0,0 +1,15 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Constants;
+
+interface AlwaysUsedClassConstantsExtensionProvider
+{
+
+	public const EXTENSION_TAG = 'phpstan.constants.alwaysUsedClassConstantsExtension';
+
+	/**
+	 * @return AlwaysUsedClassConstantsExtension[]
+	 */
+	public function getExtensions(): array;
+
+}

src/Rules/Constants/LazyAlwaysUsedClassConstantsExtensionProvider.php

@@ -0,0 +1,29 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Constants;
+
+use PHPStan\DependencyInjection\Container;
+
+class LazyAlwaysUsedClassConstantsExtensionProvider implements AlwaysUsedClassConstantsExtensionProvider
+{
+
+	private Container $container;
+
+	/** @var AlwaysUsedClassConstantsExtension[]|null */
+	private ?array $extensions = null;
+
+	public function __construct(Container $container)
+	{
+		$this->container = $container;
+	}
+
+	public function getExtensions(): array
+	{
+		if ($this->extensions === null) {
+			$this->extensions = $this->container->getServicesByTag(AlwaysUsedClassConstantsExtensionProvider::EXTENSION_TAG);
+		}
+
+		return $this->extensions;
+	}
+
+}

src/Rules/DeadCode/UnusedPrivateConstantRule.php

@@ -5,6 +5,7 @@
 use PhpParser\Node;
 use PHPStan\Analyser\Scope;
 use PHPStan\Node\ClassConstantsNode;
+use PHPStan\Rules\Constants\AlwaysUsedClassConstantsExtensionProvider;
 use PHPStan\Rules\Rule;
 use PHPStan\Rules\RuleErrorBuilder;
 
@@ -14,6 +15,13 @@
 class UnusedPrivateConstantRule implements Rule
 {
 
+	private AlwaysUsedClassConstantsExtensionProvider $extensionProvider;
+
+	public function __construct(AlwaysUsedClassConstantsExtensionProvider $extensionProvider)
+	{
+		$this->extensionProvider = $extensionProvider;
+	}
+
 	public function getNodeType(): string
 	{
 		return ClassConstantsNode::class;
@@ -35,8 +43,18 @@ public function processNode(Node $node, Scope $scope): array
 			if (!$constant->isPrivate()) {
 				continue;
 			}
+
 			foreach ($constant->consts as $const) {
-				$constants[$const->name->toString()] = $const;
+				$constantName = $const->name->toString();
+
+				$constantReflection = $classReflection->getConstant($constantName);
+				foreach ($this->extensionProvider->getExtensions() as $extension) {
+					if ($extension->isAlwaysUsed($constantReflection)) {
+						continue 2;
+					}
+				}
+
+				$constants[$constantName] = $const;
 			}
 		}
 

tests/PHPStan/Rules/Constants/DirectAlwaysUsedClassConstantsExtensionProvider.php

@@ -0,0 +1,27 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Constants;
+
+class DirectAlwaysUsedClassConstantsExtensionProvider implements AlwaysUsedClassConstantsExtensionProvider
+{
+
+	/** @var AlwaysUsedClassConstantsExtension[] */
+	private $extensions;
+
+	/**
+	 * @param AlwaysUsedClassConstantsExtension[] $extensions
+	 */
+	public function __construct(array $extensions)
+	{
+		$this->extensions = $extensions;
+	}
+
+	/**
+	 * @return AlwaysUsedClassConstantsExtension[]
+	 */
+	public function getExtensions(): array
+	{
+		return $this->extensions;
+	}
+
+}

tests/PHPStan/Rules/DeadCode/UnusedPrivateConstantRuleTest.php

@@ -2,8 +2,12 @@
 
 namespace PHPStan\Rules\DeadCode;
 
+use PHPStan\Reflection\ConstantReflection;
+use PHPStan\Rules\Constants\AlwaysUsedClassConstantsExtension;
+use PHPStan\Rules\Constants\DirectAlwaysUsedClassConstantsExtensionProvider;
 use PHPStan\Rules\Rule;
 use PHPStan\Testing\RuleTestCase;
+use UnusedPrivateConstant\TestExtension;
 
 /**
  * @extends RuleTestCase<UnusedPrivateConstantRule>
@@ -13,7 +17,19 @@ class UnusedPrivateConstantRuleTest extends RuleTestCase
 
 	protected function getRule(): Rule
 	{
-		return new UnusedPrivateConstantRule();
+		return new UnusedPrivateConstantRule(
+			new DirectAlwaysUsedClassConstantsExtensionProvider([
+				new class() implements AlwaysUsedClassConstantsExtension {
+
+					public function isAlwaysUsed(ConstantReflection $constant): bool
+					{
+						return $constant->getDeclaringClass()->getName() === TestExtension::class
+							&& $constant->getName() === 'USED';
+					}
+
+				},
+			])
+		);
 	}
 
 	public function testRule(): void
@@ -23,6 +39,10 @@ public function testRule(): void
 				'Constant UnusedPrivateConstant\Foo::BAR_CONST is unused.',
 				10,
 			],
+			[
+				'Constant UnusedPrivateConstant\TestExtension::UNUSED is unused.',
+				23,
+			],
 		]);
 	}
 

tests/PHPStan/Rules/DeadCode/data/unused-private-constant.php

@@ -15,3 +15,10 @@ public function doFoo()
 	}
 
 }
+
+class TestExtension
+{
+	private const USED = 1;
+
+	private const UNUSED = 2;
+}