Add support for PHP 8.3 typed class constants

The Constant class now accepts and exposes a Type parameter,
following the same pattern used by Property. The ClassConstantIterator
reads the type from the AST node, and the ClassConstant factory
converts it via the Type helper before passing it to the Constant
constructor.

Author: lacatoire

src/phpDocumentor/Reflection/Php/Constant.php

@@ -19,6 +19,7 @@
 use phpDocumentor\Reflection\Fqsen;
 use phpDocumentor\Reflection\Location;
 use phpDocumentor\Reflection\Metadata\MetaDataContainer as MetaDataContainerInterface;
+use phpDocumentor\Reflection\Type;
 
 use function is_string;
 use function trigger_error;
@@ -52,6 +53,7 @@ public function __construct(
         Location|null $endLocation = null,
         Visibility|null $visibility = null,
         private readonly bool $final = false,
+        private readonly Type|null $type = null,
     ) {
         $this->location = $location ?: new Location(-1);
         $this->endLocation = $endLocation ?: new Location(-1);
@@ -135,4 +137,9 @@ public function isFinal(): bool
     {
         return $this->final;
     }
+
+    public function getType(): Type|null
+    {
+        return $this->type;
+    }
 }

src/phpDocumentor/Reflection/Php/Factory/ClassConstant.php

@@ -93,6 +93,7 @@ protected function doCreate(
                 new Location($const->getEndLine()),
                 $this->buildVisibility($const),
                 $const->isFinal(),
+                (new Type())->fromPhpParser($const->getType(), $context->getTypeContext()),
             );
 
             foreach ($this->reducers as $reducer) {

src/phpDocumentor/Reflection/Php/Factory/ClassConstantIterator.php

@@ -17,7 +17,10 @@
 use Override;
 use phpDocumentor\Reflection\Fqsen;
 use PhpParser\Comment\Doc;
+use PhpParser\Node\ComplexType;
 use PhpParser\Node\Expr;
+use PhpParser\Node\Identifier;
+use PhpParser\Node\Name;
 use PhpParser\Node\Stmt\ClassConst;
 
 /**
@@ -123,6 +126,14 @@ public function isFinal(): bool
         return $this->classConstants->isFinal();
     }
 
+    /**
+     * Gets the type of the constant.
+     */
+    public function getType(): Identifier|Name|ComplexType|null
+    {
+        return $this->classConstants->type;
+    }
+
     /** @link http://php.net/manual/en/iterator.current.php */
     #[Override]
     public function current(): self

tests/integration/TypedConstantTest.php

@@ -0,0 +1,34 @@
+<?php
+
+declare(strict_types=1);
+
+namespace integration;
+
+use phpDocumentor\Reflection\File\LocalFile;
+use phpDocumentor\Reflection\Php\ProjectFactory;
+use phpDocumentor\Reflection\Types\Compound;
+use phpDocumentor\Reflection\Types\Integer;
+use phpDocumentor\Reflection\Types\Nullable;
+use phpDocumentor\Reflection\Types\String_;
+use PHPUnit\Framework\Attributes\CoversNothing;
+use PHPUnit\Framework\TestCase;
+
+#[CoversNothing]
+final class TypedConstantTest extends TestCase
+{
+    public function testTypedClassConstantsHaveType(): void
+    {
+        $file = __DIR__ . '/data/PHP83/TypedConstants.php';
+        $projectFactory = ProjectFactory::createInstance();
+        $project = $projectFactory->create('My project', [new LocalFile($file)]);
+
+        $class = $project->getFiles()[$file]->getClasses()['\PHP83\TypedConstants'];
+        $constants = $class->getConstants();
+
+        $this->assertEquals(new String_(), $constants['\PHP83\TypedConstants::NAME']->getType());
+        $this->assertEquals(new Integer(), $constants['\PHP83\TypedConstants::COUNT']->getType());
+        $this->assertEquals(new Compound([new String_(), new Integer()]), $constants['\PHP83\TypedConstants::UNION']->getType());
+        $this->assertEquals(new Nullable(new String_()), $constants['\PHP83\TypedConstants::NULLABLE']->getType());
+        $this->assertNull($constants['\PHP83\TypedConstants::UNTYPED']->getType());
+    }
+}

tests/integration/data/PHP83/TypedConstants.php

@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PHP83;
+
+class TypedConstants
+{
+    const string NAME = 'typed';
+    const int COUNT = 42;
+    const string|int UNION = 'either';
+    const ?string NULLABLE = null;
+    const UNTYPED = 'no type';
+}

tests/unit/phpDocumentor/Reflection/Php/ConstantTest.php

@@ -17,6 +17,7 @@
 use phpDocumentor\Reflection\Fqsen;
 use phpDocumentor\Reflection\Location;
 use phpDocumentor\Reflection\Metadata\MetaDataContainer as MetaDataContainerInterface;
+use phpDocumentor\Reflection\Types\String_;
 use PHPUnit\Framework\Attributes\CoversClass;
 use PHPUnit\Framework\Attributes\UsesClass;
 
@@ -76,6 +77,28 @@ public function testGetVisibility(): void
         self::assertEquals(new Visibility(Visibility::PUBLIC_), $this->fixture->getVisibility());
     }
 
+    public function testGetTypeReturnsNullByDefault(): void
+    {
+        self::assertNull($this->fixture->getType());
+    }
+
+    public function testGetTypeReturnsTypeWhenProvided(): void
+    {
+        $type = new String_();
+        $fixture = new Constant(
+            $this->fqsen,
+            $this->docBlock,
+            new Expression($this->value),
+            null,
+            null,
+            null,
+            false,
+            $type,
+        );
+
+        self::assertSame($type, $fixture->getType());
+    }
+
     public function testLineAndColumnNumberIsReturnedWhenALocationIsProvided(): void
     {
         $fixture = new Constant($this->fqsen, $this->docBlock, null, new Location(100, 20), new Location(101, 20));

tests/unit/phpDocumentor/Reflection/Php/Factory/ClassConstantIteratorTest.php

@@ -19,6 +19,8 @@
 use PhpParser\Comment\Doc;
 use PhpParser\Node\Const_;
 use PhpParser\Node\Expr\Variable;
+use PhpParser\Node\Identifier;
+use PhpParser\Node\Scalar\String_;
 use PhpParser\Node\Stmt\ClassConst;
 use PHPUnit\Framework\Attributes\CoversClass;
 
@@ -78,6 +80,31 @@ public function testGetDocCommentPropFirst(): void
         $this->assertEquals('test', $fixture->getDocComment()->getText());
     }
 
+    public function testGetTypeReturnsNullWhenUntyped(): void
+    {
+        $const = new Const_('\Space\MyClass::MY_CONST1', new String_('a'));
+        $const->setAttribute('fqsen', new Fqsen((string) $const->name));
+
+        $classConstantNode = new ClassConst([$const]);
+
+        $fixture = new ClassConstantIterator($classConstantNode);
+
+        $this->assertNull($fixture->getType());
+    }
+
+    public function testGetTypeReturnsTypeWhenTyped(): void
+    {
+        $const = new Const_('\Space\MyClass::MY_CONST1', new String_('a'));
+        $const->setAttribute('fqsen', new Fqsen((string) $const->name));
+
+        $classConstantNode = new ClassConst([$const], 0, [], [], new Identifier('string'));
+
+        $fixture = new ClassConstantIterator($classConstantNode);
+
+        $this->assertInstanceOf(Identifier::class, $fixture->getType());
+        $this->assertEquals('string', $fixture->getType()->toString());
+    }
+
     public function testGetDocComment(): void
     {
         $const = m::mock(Const_::class);

tests/unit/phpDocumentor/Reflection/Php/Factory/ClassConstantTest.php

@@ -24,8 +24,10 @@
 use phpDocumentor\Reflection\Php\ProjectFactoryStrategies;
 use phpDocumentor\Reflection\Php\Trait_ as TraitElement;
 use phpDocumentor\Reflection\Types\Null_;
+use phpDocumentor\Reflection\Types\String_ as StringType;
 use PhpParser\Comment\Doc;
 use PhpParser\Node\Const_;
+use PhpParser\Node\Identifier;
 use PhpParser\Node\Scalar\String_;
 use PhpParser\Node\Stmt\Class_ as ClassNode;
 use PhpParser\Node\Stmt\ClassConst;
@@ -138,6 +140,29 @@ public function testCreateForEnum(): void
         self::assertInstanceOf(ConstantDescriptor::class, current($result->getConstants()));
     }
 
+    public function testCreateWithTypedConstant(): void
+    {
+        $const = new Const_('\Space\MyClass::MY_CONST1', new String_('a'));
+        $const->setAttribute('fqsen', new Fqsen((string) $const->name));
+        $constantStub = new ClassConst([$const], ClassNode::MODIFIER_PUBLIC, [], [], new Identifier('string'));
+
+        $class = $this->performCreate($constantStub);
+
+        $constant = current($class->getConstants());
+        $this->assertInstanceOf(ConstantDescriptor::class, $constant);
+        $this->assertEquals(new StringType(), $constant->getType());
+    }
+
+    public function testCreateWithUntypedConstantHasNullType(): void
+    {
+        $constantStub = $this->buildConstantIteratorStub();
+
+        $class = $this->performCreate($constantStub);
+
+        $constant = current($class->getConstants());
+        $this->assertNull($constant->getType());
+    }
+
     public function testCreateWithDocBlock(): void
     {
         $doc = new Doc('text');