fix: properly handle nested local type aliases

The following annotation now works properly:

```php
/**
 * @phpstan-type Address = array{street?: string, city: string}
 * @phpstan-type User = array{name: non-empty-string, address: Address}
 */
final class SomeClass
{
    public function __construct(
        /** @var User */
        public $value,
    ) {}
}

(new \CuyZ\Valinor\MapperBuilder())
    ->mapper()
    ->map(SomeClass::class, [
        'name' => 'John Doe',
        'address' => [
            'street' => 'Bron-Yr-Aur',
            'city' => 'SY20 8QA, Machynlleth',
        ],
    ]);
 ```

src/Definition/Repository/Reflection/TypeResolver/ClassImportedTypeAliasResolver.php

@@ -77,7 +77,7 @@ private function extractImportedAliasesFromDocBlock(string $className): array
 
  $importedAliases = [];
 
- $annotations = (new Annotations($docBlock))->allOf(
+ $annotations = (new Annotations($docBlock))->filteredByPriority(
  '@phpstan-import-type',
  '@psalm-import-type',
  );

src/Definition/Repository/Reflection/TypeResolver/ClassLocalTypeAliasResolver.php

@@ -32,12 +32,12 @@ public function resolveLocalTypeAliases(ObjectType $type): array
  return [];
  }
 
- $typeParser = $this->typeParserFactory->buildAdvancedTypeParserForClass($type);
-
  $types = [];
 
  foreach ($localAliases as $name => $raw) {
  try {
+ $typeParser = $this->typeParserFactory->buildAdvancedTypeParserForClass($type, $types);
+
  $types[$name] = $typeParser->parse($raw);
  } catch (InvalidType $exception) {
  $types[$name] = UnresolvableType::forLocalAlias($raw, $name, $type, $exception);
@@ -61,7 +61,7 @@ private function extractLocalAliasesFromDocBlock(string $className): array
 
  $aliases = [];
 
- $annotations = (new Annotations($docBlock))->allOf(
+ $annotations = (new Annotations($docBlock))->filteredInOrder(
  '@phpstan-type',
  '@psalm-type',
  );
@@ -80,7 +80,7 @@ private function extractLocalAliasesFromDocBlock(string $className): array
  $key = key($tokens);
 
  if ($key !== null) {
- $aliases[$name] ??= $annotation->allAfter($key);
+ $aliases[$name] = $annotation->allAfter($key);
  }
  }
 

src/Definition/Repository/Reflection/TypeResolver/ClassParentTypeResolver.php

@@ -72,7 +72,7 @@ private function extractParentTypeFromDocBlock(ReflectionClass $reflection): arr
  return [];
  }
 
- $annotations = (new Annotations($docBlock))->allOf(
+ $annotations = (new Annotations($docBlock))->filteredByPriority(
  '@phpstan-extends',
  '@psalm-extends',
  '@extends',

src/Definition/Repository/Reflection/TypeResolver/ClassTemplatesResolver.php

@@ -10,7 +10,6 @@
 
 use function array_key_exists;
 use function array_keys;
-use function array_reverse;
 use function current;
 use function key;
 
@@ -40,7 +39,7 @@ public function resolveTemplatesFrom(string $className): array
 
  $templates = [];
 
- $annotations = (new Annotations($docBlock))->allOf(
+ $annotations = (new Annotations($docBlock))->filteredByPriority(
  '@phpstan-template',
  '@psalm-template',
  '@template',
@@ -72,6 +71,6 @@ public function resolveTemplatesFrom(string $className): array
  }
  }
 
- return array_reverse($templates);
+ return $templates;
  }
 }

src/Definition/Repository/Reflection/TypeResolver/FunctionReturnTypeResolver.php

@@ -37,6 +37,6 @@ private function extractReturnTypeFromDocBlock(ReflectionFunctionAbstract $refle
  '@phpstan-return',
  '@psalm-return',
  '@return',
- );
+ )?->raw();
  }
 }

src/Definition/Repository/Reflection/TypeResolver/ParameterTypeResolver.php

@@ -58,7 +58,7 @@ private function extractTypeFromDocBlock(ReflectionParameter $reflection): ?stri
  return null;
  }
 
- $annotations = (new Annotations($docBlock))->allOf(
+ $annotations = (new Annotations($docBlock))->filteredByPriority(
  '@phpstan-param',
  '@psalm-param',
  '@param',

src/Definition/Repository/Reflection/TypeResolver/PropertyTypeResolver.php

@@ -37,6 +37,6 @@ public function extractTypeFromDocBlock(ReflectionProperty $reflection): ?string
  '@phpstan-var',
  '@psalm-var',
  '@var',
- );
+ )?->raw();
  }
 }

src/Type/Parser/Lexer/Annotations.php

@@ -4,14 +4,16 @@
 
 namespace CuyZ\Valinor\Type\Parser\Lexer;
 
+use function array_filter;
 use function array_merge;
 use function current;
+use function in_array;
 use function trim;
 
 /** @internal */
 final class Annotations
 {
- /** @var array<non-empty-string, non-empty-list<TokenizedAnnotation>> */
+ /** @var list<TokenizedAnnotation> */
  private array $annotations = [];
 
  public function __construct(string $docBlock)
@@ -27,7 +29,7 @@ public function __construct(string $docBlock)
  $current = $this->trimArrayTips($current);
 
  if ($current !== []) {
- $this->annotations[$token][] = new TokenizedAnnotation($current);
+ array_unshift($this->annotations, new TokenizedAnnotation($token, $current));
  }
 
  $current = [];
@@ -37,31 +39,47 @@ public function __construct(string $docBlock)
  }
  }
 
- public function firstOf(string ...$annotations): ?string
+ public function firstOf(string ...$annotations): ?TokenizedAnnotation
  {
  foreach ($annotations as $annotation) {
- if (isset($this->annotations[$annotation])) {
- return $this->annotations[$annotation][0]->raw();
+ foreach ($this->annotations as $tokenizedAnnotation) {
+ if ($tokenizedAnnotation->name() === $annotation) {
+ return $tokenizedAnnotation;
+ }
  }
  }
 
  return null;
  }
 
+ /**
+ * @return array<TokenizedAnnotation>
+ */
+ public function filteredInOrder(string ...$annotations): array
+ {
+ return array_filter(
+ $this->annotations,
+ static fn (TokenizedAnnotation $tokenizedAnnotation) => in_array($tokenizedAnnotation->name(), $annotations, true),
+ );
+ }
+
  /**
  * @return list<TokenizedAnnotation>
  */
- public function allOf(string ...$annotations): array
+ public function filteredByPriority(string ...$annotations): array
  {
- $all = [];
+ $result = [];
 
  foreach ($annotations as $annotation) {
- if (isset($this->annotations[$annotation])) {
- $all = array_merge($all, $this->annotations[$annotation]);
- }
+ $filtered = array_filter(
+ $this->annotations,
+ static fn (TokenizedAnnotation $tokenizedAnnotation) => $tokenizedAnnotation->name() === $annotation,
+ );
+
+ $result = array_merge($result, $filtered);
  }
 
- return $all;
+ return $result;
  }
 
  private function sanitizeDocComment(string $value): string

src/Type/Parser/Lexer/TokenizedAnnotation.php

@@ -11,10 +11,20 @@
 final class TokenizedAnnotation
 {
  public function __construct(
+ /** @var non-empty-string */
+ private string $name,
  /** @var non-empty-list<string>> */
  private array $tokens,
  ) {}
 
+ /**
+ * @return non-empty-string
+ */
+ public function name(): string
+ {
+ return $this->name;
+ }
+
  public function splice(int $length): string
  {
  return implode('', array_splice($this->tokens, 0, $length));

tests/Functional/Definition/Repository/Reflection/TypeResolver/ClassLocalTypeAliasResolverTest.php

@@ -81,5 +81,47 @@ public static function local_type_alias_is_resolved_properly_data_provider(): it
  'SomeType' => 'int<42, 1337>',
  ]
  ];
+
+ yield 'types can be nested' => [
+ 'className' => (
+ /**
+ * @phpstan-type SomeType = non-empty-string
+ * @phpstan-type SomeNestedType = array<SomeType>
+ */
+ new class () {}
+ )::class,
+ [
+ 'SomeType' => 'non-empty-string',
+ 'SomeNestedType' => 'array<non-empty-string>',
+ ]
+ ];
+
+ yield 'PHPStan type can use a Psalm type' => [
+ 'className' => (
+ /**
+ * @psalm-type SomeType = non-empty-string
+ * @phpstan-type SomeNestedType = array<SomeType>
+ */
+ new class () {}
+ )::class,
+ [
+ 'SomeType' => 'non-empty-string',
+ 'SomeNestedType' => 'array<non-empty-string>',
+ ]
+ ];
+
+ yield 'Psalm type can use a PHPStan type' => [
+ 'className' => (
+ /**
+ * @phpstan-type SomeType = non-empty-string
+ * @psalm-type SomeNestedType = array<SomeType>
+ */
+ new class () {}
+ )::class,
+ [
+ 'SomeType' => 'non-empty-string',
+ 'SomeNestedType' => 'array<non-empty-string>',
+ ]
+ ];
  }
 }

tests/Functional/Definition/Repository/Reflection/TypeResolver/PropertyTypeResolverTest.php

@@ -139,5 +139,15 @@ public static function property_type_is_resolved_properly_data_provider(): itera
  }, 'foo'),
  'non-empty-string',
  ];
+
+ yield 'docBlock present but no @var annotation' => [
+ new ReflectionProperty(new class () {
+ /**
+ * Some comment
+ */
+ public string $foo;
+ }, 'foo'),
+ 'string',
+ ];
  }
 }

tests/Unit/Type/Parser/Lexer/AnnotationsTest.php

@@ -24,7 +24,7 @@ public function test_annotations_are_parsed_properly(string $docBlock, array $ex
  foreach ($expectedAnnotations as $name => $expected) {
  $result = array_map(
  fn (TokenizedAnnotation $annotation) => $annotation->raw(),
- $annotations->allOf($name)
+ $annotations->filteredByPriority($name)
  );
 
  self::assertSame($expected, $result);