Add ClassReflection::typeArgumentsOf($class) and resolvedTypeArgumentsOf($class)

src/Reflection/CHANGELOG.md

@@ -10,6 +10,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 
 - Add `ConstantReflection` and `TyphoonReflector::reflectConstant()`.
+- Add `ClassReflection::typeArgumentsOf($class)`.
+- Add `ClassReflection::resolvedTypeArgumentsOf($class)`.
 
 ## [0.4.2] 2024-08-05
 

src/Reflection/ClassReflection.php

@@ -13,6 +13,7 @@
 use Typhoon\Reflection\Internal\Misc\NonSerializable;
 use Typhoon\Reflection\Internal\NativeAdapter\ClassAdapter;
 use Typhoon\Type\Type;
+use Typhoon\Type\types;
 use Typhoon\Type\Visitor\TemplateTypeResolver;
 use Typhoon\TypedMap\TypedMap;
 
@@ -199,6 +200,52 @@ public function isInstanceOf(string|NamedClassId|AnonymousClassId $class): bool
             || \array_key_exists($class->name, $this->data[Data::Interfaces]);
     }
 
+    /**
+     * @param non-empty-string|NamedClassId|AnonymousClassId $class
+     * @return list<Type>
+     */
+    public function typeArgumentsOf(string|NamedClassId|AnonymousClassId $class): array
+    {
+        if (\is_string($class)) {
+            $class = Id::class($class);
+        }
+
+        if ($this->id->equals($class)) {
+            return $this
+                ->templates()
+                ->map(static fn(TemplateReflection $template): Type => types::template($template->id))
+                ->toList();
+        }
+
+        if ($class instanceof AnonymousClassId) {
+            return [];
+        }
+
+        /** @psalm-suppress PossiblyInvalidArrayOffset */
+        return $this->data[Data::Parents][$class->name] ?? $this->data[Data::Interfaces][$class->name] ?? [];
+    }
+
+    /**
+     * @param non-empty-string|NamedClassId|AnonymousClassId $class
+     * @param list<Type> $typeArguments
+     * @return list<Type>
+     */
+    public function resolvedTypeArgumentsOf(string|NamedClassId|AnonymousClassId $class, array $typeArguments = []): array
+    {
+        $classTypeArguments = $this->typeArgumentsOf($class);
+
+        if ($classTypeArguments === []) {
+            return [];
+        }
+
+        $templateResolver = $this->createTemplateResolver($typeArguments);
+
+        return array_map(
+            static fn(Type $type): Type => $type->accept($templateResolver),
+            $classTypeArguments,
+        );
+    }
+
     public function isClass(): bool
     {
         return $this->data[Data::ClassKind] === ClassKind::Class_;

tests/Reflection/functional_tests/class/resolved_type_arguments_of.php

@@ -0,0 +1,32 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Typhoon\Reflection;
+
+use Typhoon\Reflection\Locator\Resource;
+use Typhoon\Type\types;
+use function PHPUnit\Framework\assertEquals;
+
+return static function (TyphoonReflector $reflector): void {
+    $iterator = $reflector->reflectClass(\Iterator::class);
+    assertEquals([types::mixed, types::mixed], $iterator->resolvedTypeArgumentsOf(\Iterator::class));
+    assertEquals([types::int, types::string], $iterator->resolvedTypeArgumentsOf(\Iterator::class, [types::int, types::string]));
+    assertEquals([types::mixed, types::mixed], $iterator->resolvedTypeArgumentsOf(\Traversable::class));
+    assertEquals([types::int, types::string], $iterator->resolvedTypeArgumentsOf(\Traversable::class, [types::int, types::string]));
+
+    $a = $reflector
+        ->withResource(Resource::fromCode(
+            <<<'PHP'
+                <?php
+
+                /**
+                 * @implements Iterator<string>
+                 */
+                abstract class A implements Iterator {}
+                PHP,
+        ))
+        ->reflectClass('A');
+    assertEquals([types::mixed, types::string], $a->resolvedTypeArgumentsOf(\Iterator::class));
+    assertEquals([types::mixed, types::string], $a->resolvedTypeArgumentsOf(\Traversable::class));
+};

tests/Reflection/functional_tests/class/type_arguments_of.php

@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Typhoon\Reflection;
+
+use Typhoon\Reflection\Locator\Resource;
+use Typhoon\Type\types;
+use function PHPUnit\Framework\assertEquals;
+
+return static function (TyphoonReflector $reflector): void {
+    $iterator = $reflector->reflectClass(\Iterator::class);
+    assertEquals(
+        [types::classTemplate(\Iterator::class, 'TKey'), types::classTemplate(\Iterator::class, 'TValue')],
+        $iterator->typeArgumentsOf(\Iterator::class),
+    );
+    assertEquals(
+        [types::classTemplate(\Iterator::class, 'TKey'), types::classTemplate(\Iterator::class, 'TValue')],
+        $iterator->typeArgumentsOf(\Traversable::class),
+    );
+
+    $a = $reflector
+        ->withResource(Resource::fromCode(
+            <<<'PHP'
+                <?php
+
+                /**
+                 * @implements Iterator<string>
+                 */
+                abstract class A implements Iterator {}
+                PHP,
+        ))
+        ->reflectClass('A');
+    assertEquals(
+        [types::mixed, types::string],
+        $a->typeArgumentsOf(\Iterator::class),
+    );
+    assertEquals(
+        [types::mixed, types::string],
+        $a->typeArgumentsOf(\Traversable::class),
+    );
+};