[PHP 8.5] Global constants support attributes

Author: ondrejmirtes

build/ignore-by-php-version.neon.php

@@ -41,6 +41,10 @@
 	$includes[] = __DIR__ . '/new-phpunit.neon';
 }
 
+if (PHP_VERSION_ID < 80500) {
+	$includes[] = __DIR__ . '/pre-php-85.neon';
+}
+
 $config = [];
 $config['includes'] = $includes;
 

build/pre-php-85.neon

@@ -0,0 +1,3 @@
+parameters:
+	excludePaths:
+		- ../src/Rules/Constants/ConstantAttributesRule.php

src/Php/PhpVersion.php

@@ -449,4 +449,9 @@ public function deprecatesBacktickOperator(): bool
 		return $this->versionId >= 80500;
 	}
 
+	public function supportsAttributesOnGlobalConstants(): bool
+	{
+		return $this->versionId >= 80500;
+	}
+
 }

src/Reflection/BetterReflection/BetterReflectionProvider.php

@@ -8,9 +8,11 @@
 use PHPStan\Analyser\Scope;
 use PHPStan\BetterReflection\Identifier\Exception\InvalidIdentifierName;
 use PHPStan\BetterReflection\NodeCompiler\Exception\UnableToCompileNode;
+use PHPStan\BetterReflection\Reflection\Adapter\ReflectionAttributeFactory;
 use PHPStan\BetterReflection\Reflection\Adapter\ReflectionClass;
 use PHPStan\BetterReflection\Reflection\Adapter\ReflectionFunction;
 use PHPStan\BetterReflection\Reflection\Adapter\ReflectionParameter;
+use PHPStan\BetterReflection\Reflection\ReflectionAttribute as BetterReflectionAttribute;
 use PHPStan\BetterReflection\Reflection\ReflectionEnum;
 use PHPStan\BetterReflection\Reflector\Exception\IdentifierNotFound;
 use PHPStan\BetterReflection\Reflector\Reflector;
@@ -450,12 +452,20 @@ public function getConstant(Node\Name $nameNode, ?NamespaceAnswerer $namespaceAn
 			}
 		}
 
+		if (!$isDeprecated) {
+			$isDeprecated = $constantReflection->isDeprecated();
+		}
+
 		return $this->cachedConstants[$constantName] = new RuntimeConstantReflection(
 			$constantName,
 			$constantValueType,
 			$fileName,
 			TrinaryLogic::createFromBoolean($isDeprecated),
 			$deprecatedDescription,
+			$this->attributeReflectionFactory->fromNativeReflection(
+				array_map(static fn (BetterReflectionAttribute $betterReflectionAttribute) => ReflectionAttributeFactory::create($betterReflectionAttribute), $constantReflection->getAttributes()),
+				InitializerExprContext::fromGlobalConstant($constantReflection),
+			),
 		);
 	}
 

src/Reflection/ClassConstantReflection.php

@@ -21,9 +21,4 @@ public function hasNativeType(): bool;
 
 	public function getNativeType(): ?Type;
 
-	/**
-	 * @return list<AttributeReflection>
-	 */
-	public function getAttributes(): array;
-
 }

src/Reflection/Constant/RuntimeConstantReflection.php

@@ -2,19 +2,24 @@
 
 namespace PHPStan\Reflection\Constant;
 
+use PHPStan\Reflection\AttributeReflection;
 use PHPStan\Reflection\ConstantReflection;
 use PHPStan\TrinaryLogic;
 use PHPStan\Type\Type;
 
 final class RuntimeConstantReflection implements ConstantReflection
 {
 
+	/**
+	 * @param list<AttributeReflection> $attributes
+	 */
 	public function __construct(
 		private string $name,
 		private Type $valueType,
 		private ?string $fileName,
 		private TrinaryLogic $isDeprecated,
 		private ?string $deprecatedDescription,
+		private array $attributes,
 	)
 	{
 	}
@@ -49,4 +54,9 @@ public function isInternal(): TrinaryLogic
 		return TrinaryLogic::createNo();
 	}
 
+	public function getAttributes(): array
+	{
+		return $this->attributes;
+	}
+
 }

src/Reflection/ConstantReflection.php

@@ -21,4 +21,9 @@ public function isInternal(): TrinaryLogic;
 
 	public function getFileName(): ?string;
 
+	/**
+	 * @return list<AttributeReflection>
+	 */
+	public function getAttributes(): array;
+
 }

src/Rules/Constants/ConstantAttributesRule.php

@@ -0,0 +1,67 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Rules\Constants;
+
+use Attribute;
+use PhpParser\Node;
+use PHPStan\Analyser\Scope;
+use PHPStan\DependencyInjection\RegisteredRule;
+use PHPStan\Php\PhpVersion;
+use PHPStan\Rules\AttributesCheck;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
+use const PHP_VERSION_ID;
+
+/**
+ * @implements Rule<Node\Stmt\Const_>
+ */
+#[RegisteredRule(level: 0)]
+final class ConstantAttributesRule implements Rule
+{
+
+	public function __construct(
+		private AttributesCheck $attributesCheck,
+		private PhpVersion $phpVersion,
+	)
+	{
+	}
+
+	public function getNodeType(): string
+	{
+		return Node\Stmt\Const_::class;
+	}
+
+	public function processNode(Node $node, Scope $scope): array
+	{
+		if ($node->attrGroups === []) {
+			return [];
+		}
+
+		if (!$this->phpVersion->supportsAttributesOnGlobalConstants()) {
+			return [
+				RuleErrorBuilder::message('Attributes on global constants are supported only on PHP 8.5 and later.')
+					->identifier('constant.attributesNotSupported')
+					->nonIgnorable()
+					->build(),
+			];
+		}
+
+		if (PHP_VERSION_ID < 80500) {
+			// because of Attribute::TARGET_CONSTANT constant
+			return [
+				RuleErrorBuilder::message('ConstantAttributesRule requires PHP 8.5 runtime to check the code.')
+					->identifier('constant.attributesRuleCannotRun')
+					->nonIgnorable()
+					->build(),
+			];
+		}
+
+		return $this->attributesCheck->check(
+			$scope,
+			$node->attrGroups,
+			Attribute::TARGET_CONSTANT,
+			'constant',
+		);
+	}
+
+}

tests/PHPStan/Reflection/AttributeReflectionTest.php

@@ -135,6 +135,21 @@ public static function dataAttributeReflections(): iterable
 			];
 		}
 
+		if (PHP_VERSION_ID >= 80500) {
+			yield [
+				$reflectionProvider->getConstant(new Name('AttributeReflectionTest\\ExampleConstWithAttribute'), null)->getAttributes(),
+				[
+					[
+						MyAttr::class,
+						[
+							'one' => '1',
+							'two' => '2',
+						],
+					],
+				],
+			];
+		}
+
 		yield [
 			$foo->getConstructor()->getOnlyVariant()->getParameters()[0]->getAttributes(),
 			[

tests/PHPStan/Reflection/ReflectionProviderTest.php

@@ -108,6 +108,36 @@ public function testFunctionDeprecated(string $functionName, bool $isDeprecated)
 		$this->assertEquals(TrinaryLogic::createFromBoolean($isDeprecated), $function->isDeprecated());
 	}
 
+	public static function dataConstantDeprecated(): iterable
+	{
+		if (PHP_VERSION_ID >= 80500) {
+			yield [
+				'AttributeReflectionTest\\ExampleConstWithAttribute',
+				false,
+			];
+			yield [
+				'AttributeReflectionTest\\DeprecatedConst',
+				true,
+			];
+		}
+
+		yield [
+			'AttributeReflectionTest\\DeprecatedConstWithPhpDoc',
+			true,
+		];
+	}
+
+	/**
+	 * @param non-empty-string $constantName
+	 */
+	#[DataProvider('dataConstantDeprecated')]
+	public function testConstantDeprecated(string $constantName, bool $isDeprecated): void
+	{
+		$reflectionProvider = self::createReflectionProvider();
+		$constant = $reflectionProvider->getConstant(new Name($constantName), null);
+		$this->assertSame(TrinaryLogic::createFromBoolean($isDeprecated)->describe(), $constant->isDeprecated()->describe());
+	}
+
 	public static function dataMethodThrowType(): array
 	{
 		return [