Refactor ContextualTypeParser

Author: vudaltsov

composer.lock

@@ -13,7 +13,7 @@ interface CustomTypeParser
 {
     /**
      * @param non-empty-string $unresolvedName
-     * @param list<Type> $typeArguments
+     * @param list<Type> $templateArguments
      */
-    public function parseCustomType(string $unresolvedName, array $typeArguments, TypeContext $context): ?Type;
+    public function parseCustomType(string $unresolvedName, array $templateArguments, TypeContext $context): ?Type;
 }

src/CustomTypeParser.php

@@ -18,10 +18,10 @@ public function __construct(
         private readonly iterable $customTypeParsers = [],
     ) {}
 
-    public function parseCustomType(string $unresolvedName, array $typeArguments, TypeContext $context): ?Type
+    public function parseCustomType(string $unresolvedName, array $templateArguments, TypeContext $context): ?Type
     {
         foreach ($this->customTypeParsers as $customTypeParser) {
-            $type = $customTypeParser->parseCustomType($unresolvedName, $typeArguments, $context);
+            $type = $customTypeParser->parseCustomType($unresolvedName, $templateArguments, $context);
 
             if ($type !== null) {
                 return $type;

src/CustomTypeParsers.php

@@ -140,14 +140,10 @@ private function parseIdentifier(string $name, array $genericNodes = []): Type
             return $type($genericNodes);
         }
 
-        $typeArguments = array_map($this->parseTypeNode(...), $genericNodes);
-        $customType = $this->customTypeParser->parseCustomType($name, $typeArguments, $this->context);
+        $templateArguments = array_map($this->parseTypeNode(...), $genericNodes);
 
-        if ($customType !== null) {
-            return $customType;
-        }
-
-        throw new \LogicException(\sprintf('Unsupported identifier `%s`', $name));
+        return $this->customTypeParser->parseCustomType($name, $templateArguments, $this->context)
+            ?? $this->context->resolveNameAsType($name, $templateArguments);
     }
 
     /**

src/Internal/ContextualTypeParser.php

@@ -4,8 +4,8 @@
 
 namespace Typhoon\PHPStanTypeParser;
 
-use Typhoon\Type\NamedObjectT;
 use Typhoon\Type\Type;
+use function Typhoon\Type\objectT;
 
 /**
  * @api
@@ -23,19 +23,15 @@ public function resolveConstantName(string $unresolvedName): array
 
     public function resolveClassName(string $unresolvedName): string
     {
-        if (class_exists($unresolvedName)) {
+        if (class_exists($unresolvedName) || interface_exists($unresolvedName)) {
             return $unresolvedName;
         }
 
         throw new \LogicException(\sprintf('Class `%s` does not exist', $unresolvedName));
     }
 
-    public function resolveNameAsType(string $unresolvedName, array $typeArguments = []): Type
+    public function resolveNameAsType(string $unresolvedName, array $templateArguments = []): Type
     {
-        /**
-         * @todo requires objectT() type constructor
-         * @psalm-suppress InternalMethod
-         */
-        return new NamedObjectT($this->resolveClassName($unresolvedName), $typeArguments);
+        return objectT($this->resolveClassName($unresolvedName), $templateArguments);
     }
 }

src/RuntimeTypeContext.php

@@ -25,7 +25,7 @@ public function resolveClassName(string $unresolvedName): string;
 
     /**
      * @param non-empty-string $unresolvedName
-     * @param list<Type> $typeArguments
+     * @param list<Type> $templateArguments
      */
-    public function resolveNameAsType(string $unresolvedName, array $typeArguments = []): Type;
+    public function resolveNameAsType(string $unresolvedName, array $templateArguments = []): Type;
 }

src/TypeContext.php

@@ -15,6 +15,7 @@
 use function Typhoon\Type\intRangeT;
 use function Typhoon\Type\intT;
 use function Typhoon\Type\nullOrT;
+use function Typhoon\Type\objectT;
 use function Typhoon\Type\orT;
 use function Typhoon\Type\stringT;
 use const Typhoon\Type\arrayKeyT;
@@ -89,6 +90,9 @@ private static function cases(): \Generator
         yield 'int&string' => andT(intT, stringT);
         yield '(int&string)&float' => andT(andT(intT, stringT), floatT);
         yield 'mixed' => mixedT;
+        yield \stdClass::class => objectT(\stdClass::class);
+        yield \Stringable::class => objectT(\Stringable::class);
+        yield 'Traversable<int, string>' => objectT(\Traversable::class, [intT, stringT]);
     }
 
     /**