feat: handle local type aliasing in class definition

Type aliases can now be added to a class definition.

Both PHPStan and Psalm syntax are handled.

```php
/**
 * @phpstan-type SomeTypeAlias = array{foo: string}
 * @psalm-type SomeOtherTypeAlias = array{bar: int}
 */
final class SomeClass
{
    /** @var SomeTypeAlias */
    public array $someTypeAlias;

    /** @var SomeOtherTypeAlias */
    public array $someOtherTypeAlias;
}
```

src/Definition/Exception/ClassTypeAliasesDuplication.php

@@ -0,0 +1,25 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CuyZ\Valinor\Definition\Exception;
+
+use LogicException;
+
+use function implode;
+
+final class ClassTypeAliasesDuplication extends LogicException
+{
+    /**
+     * @param class-string $className
+     */
+    public function __construct(string $className, string ...$names)
+    {
+        $names = implode('`, `', $names);
+
+        parent::__construct(
+            "The following type aliases already exist in class `$className`: `$names`.",
+            1638477604
+        );
+    }
+}

src/Definition/Repository/Reflection/ReflectionClassDefinitionRepository.php

@@ -6,19 +6,25 @@
 
 use CuyZ\Valinor\Definition\ClassDefinition;
 use CuyZ\Valinor\Definition\ClassSignature;
+use CuyZ\Valinor\Definition\Exception\ClassTypeAliasesDuplication;
 use CuyZ\Valinor\Definition\Methods;
 use CuyZ\Valinor\Definition\Properties;
 use CuyZ\Valinor\Definition\Repository\AttributesRepository;
 use CuyZ\Valinor\Definition\Repository\ClassDefinitionRepository;
+use CuyZ\Valinor\Type\Parser\Exception\InvalidType;
 use CuyZ\Valinor\Type\Parser\Factory\Specifications\ClassAliasSpecification;
 use CuyZ\Valinor\Type\Parser\Factory\Specifications\ClassContextSpecification;
 use CuyZ\Valinor\Type\Parser\Factory\Specifications\HandleClassGenericSpecification;
 use CuyZ\Valinor\Type\Parser\Factory\Specifications\TypeAliasAssignerSpecification;
 use CuyZ\Valinor\Type\Parser\Factory\TypeParserFactory;
+use CuyZ\Valinor\Type\Type;
+use CuyZ\Valinor\Type\Types\UnresolvableType;
 use CuyZ\Valinor\Utility\Reflection\Reflection;
 use ReflectionMethod;
 use ReflectionProperty;
 
+use function array_intersect_key;
+use function array_keys;
 use function array_map;
 
 final class ReflectionClassDefinitionRepository implements ClassDefinitionRepository
@@ -70,13 +76,55 @@ private function typeResolver(ClassSignature $signature): ReflectionTypeResolver
             new ClassContextSpecification($signature->className())
         );
 
+        $generics = $signature->generics();
+        $localAliases = $this->localTypeAliases($signature);
+        $duplicates = array_intersect_key($generics, $localAliases);
+
+        if (count($duplicates) > 0) {
+            throw new ClassTypeAliasesDuplication($signature->className(), ...array_keys($duplicates));
+        }
+
+        $aliases = $generics + $localAliases;
+
         $advancedParser = $this->typeParserFactory->get(
             new ClassContextSpecification($signature->className()),
             new ClassAliasSpecification($signature->className()),
             new HandleClassGenericSpecification(),
-            new TypeAliasAssignerSpecification($signature->generics()),
+            new TypeAliasAssignerSpecification($aliases)
         );
 
         return new ReflectionTypeResolver($nativeParser, $advancedParser);
     }
+
+    /**
+     * @return array<string, Type>
+     */
+    private function localTypeAliases(ClassSignature $signature): array
+    {
+        $reflection = Reflection::class($signature->className());
+        $rawTypes = Reflection::localTypeAliases($reflection);
+
+        $typeParser = $this->typeParserFactory->get(
+            new ClassContextSpecification($signature->className()),
+            new ClassAliasSpecification($signature->className()),
+            new HandleClassGenericSpecification(),
+            new TypeAliasAssignerSpecification($signature->generics()),
+        );
+
+        $types = [];
+
+        foreach ($rawTypes as $name => $raw) {
+            try {
+                $types[$name] = $typeParser->parse($raw);
+            } catch (InvalidType $exception) {
+                $raw = trim($raw);
+
+                $types[$name] = new UnresolvableType(
+                    "The type `$raw` for local alias `$name` of the class `{$signature->className()}` could not be resolved: {$exception->getMessage()}"
+                );
+            }
+        }
+
+        return $types;
+    }
 }

src/Utility/Reflection/Reflection.php

@@ -21,6 +21,7 @@
 use function get_class;
 use function implode;
 use function preg_match;
+use function preg_match_all;
 use function preg_replace;
 use function trim;
 
@@ -117,6 +118,24 @@ public static function docBlockReturnType(ReflectionFunctionAbstract $reflection
         return trim($matches[1]);
     }
 
+    /**
+     * @param ReflectionClass<object> $reflection
+     * @return array<string, string>
+     */
+    public static function localTypeAliases(ReflectionClass $reflection): array
+    {
+        $types = [];
+        $docComment = self::sanitizeDocComment($reflection);
+
+        preg_match_all('/@(phpstan|psalm)-type\s+([a-zA-Z]\w*)\s*=?\s*([\w\s?|&<>\'",-:\\\\\[\]{}]+)/', $docComment, $matches);
+
+        foreach ($matches[2] as $key => $name) {
+            $types[(string)$name] = $matches[3][$key];
+        }
+
+        return $types;
+    }
+
     public static function ofCallable(callable $callable): ReflectionFunctionAbstract
     {
         if ($callable instanceof Closure) {

tests/Integration/Mapping/Type/LocalTypeAliasMappingTest.php

@@ -0,0 +1,101 @@
+<?php
+
+declare(strict_types=1);
+
+namespace CuyZ\Valinor\Tests\Integration\Mapping\Type;
+
+use CuyZ\Valinor\Mapper\MappingError;
+use CuyZ\Valinor\Tests\Integration\IntegrationTest;
+
+final class LocalTypeAliasMappingTest extends IntegrationTest
+{
+    public function test_values_are_mapped_properly(): void
+    {
+        $source = [
+            'aliasWithEqualsSign' => 42,
+            'aliasWithoutEqualsSign' => 42,
+            'aliasShapedArray' => [
+                'foo' => 'foo',
+                'bar' => 1337,
+            ],
+            'aliasGeneric' => [42, 1337],
+        ];
+
+        foreach ([PhpStanLocalAliases::class, PsalmLocalAliases::class] as $class) {
+            try {
+                $result = $this->mapperBuilder
+                    ->mapper()
+                    ->map($class, $source);
+
+                self::assertSame(42, $result->aliasWithEqualsSign);
+                self::assertSame(42, $result->aliasWithoutEqualsSign);
+                self::assertSame($source['aliasShapedArray'], $result->aliasShapedArray);
+                self::assertSame($source['aliasGeneric'], $result->aliasGeneric->aliasArray);
+            } catch (MappingError $error) {
+                $this->mappingFail($error);
+            }
+        }
+    }
+}
+
+/**
+ * @template T
+ * @phpstan-type AliasArray = T[]
+ */
+class GenericObjectWithPhpStanLocalAlias
+{
+    /** @var AliasArray */
+    public array $aliasArray;
+}
+
+/**
+ * @phpstan-type AliasWithEqualsSign = int
+ * @phpstan-type AliasWithoutEqualsSign int
+ * @phpstan-type AliasShapedArray = array{foo: string, bar: int}
+ * @phpstan-type AliasGeneric = GenericObjectWithPhpStanLocalAlias<int>
+ */
+class PhpStanLocalAliases
+{
+    /** @var AliasWithEqualsSign */
+    public int $aliasWithEqualsSign;
+
+    /** @var AliasWithoutEqualsSign */
+    public int $aliasWithoutEqualsSign;
+
+    /** @var AliasShapedArray */
+    public array $aliasShapedArray;
+
+    /** @var AliasGeneric */
+    public GenericObjectWithPhpStanLocalAlias $aliasGeneric;
+}
+
+/**
+ * @template T
+ * @psalm-type AliasArray = T[]
+ */
+class GenericObjectWithPsalmLocalAlias
+{
+    /** @var AliasArray */
+    public array $aliasArray;
+}
+
+/**
+ * @psalm-type AliasWithEqualsSign = int
+ * @psalm-type AliasWithoutEqualsSign int
+ * @psalm-type AliasShapedArray = array{foo: string, bar: int}
+ * @psalm-type AliasGeneric = GenericObjectWithPsalmLocalAlias<int>
+ */
+class PsalmLocalAliases
+{
+    /** @var AliasWithEqualsSign */
+    public int $aliasWithEqualsSign;
+
+    /** @var AliasWithoutEqualsSign */
+    public int $aliasWithoutEqualsSign;
+
+    /** @var AliasShapedArray */
+    public array $aliasShapedArray;
+
+    /** @var AliasGeneric */
+    public GenericObjectWithPsalmLocalAlias $aliasGeneric;
+}

tests/Unit/Definition/Repository/Reflection/ReflectionClassDefinitionRepositoryTest.php

@@ -5,11 +5,13 @@
 namespace CuyZ\Valinor\Tests\Unit\Definition\Repository\Reflection;
 
 use CuyZ\Valinor\Definition\ClassSignature;
+use CuyZ\Valinor\Definition\Exception\ClassTypeAliasesDuplication;
 use CuyZ\Valinor\Definition\Exception\InvalidParameterDefaultValue;
 use CuyZ\Valinor\Definition\Exception\InvalidPropertyDefaultValue;
 use CuyZ\Valinor\Definition\Exception\TypesDoNotMatch;
 use CuyZ\Valinor\Definition\Repository\Reflection\ReflectionClassDefinitionRepository;
 use CuyZ\Valinor\Tests\Fake\Definition\Repository\FakeAttributesRepository;
+use CuyZ\Valinor\Tests\Fake\Type\FakeType;
 use CuyZ\Valinor\Tests\Fake\Type\Parser\Factory\FakeTypeParserFactory;
 use CuyZ\Valinor\Type\StringType;
 use CuyZ\Valinor\Type\Types\BooleanType;
@@ -271,4 +273,23 @@ public function publicMethod(): string
 
         $this->repository->for(new ClassSignature($class));
     }
+
+    public function test_class_with_local_type_alias_name_duplication_throws_exception(): void
+    {
+        $class = get_class(
+            /**
+             * @template T
+             * @template AnotherTemplate
+             * @psalm-type T = int
+             * @phpstan-type AnotherTemplate = int
+             */
+            new class () { }
+        );
+
+        $this->expectException(ClassTypeAliasesDuplication::class);
+        $this->expectExceptionCode(1638477604);
+        $this->expectExceptionMessage("The following type aliases already exist in class `$class`: `T`, `AnotherTemplate`.");
+
+        $this->repository->for(new ClassSignature($class, ['T' => new FakeType(), 'AnotherTemplate' => new FakeType()]));
+    }
 }