Rename to PHPStanTypeParser

Author: vudaltsov

README.md

@@ -1,12 +1,12 @@
-# Typhoon PHPStan PHPDoc Parser Bridge
+# Typhoon PHPStan Type Parser
 
-[![PHP Version Requirement](https://img.shields.io/packagist/dependency-v/typhoon/phpstan-phpdoc-parser-bridge/php)](https://packagist.org/packages/typhoon/phpstan-phpdoc-parser-bridge)
-[![GitHub Release](https://img.shields.io/github/v/release/typhoon-php/phpstan-phpdoc-parser-bridge)](https://github.com/typhoon-php/phpstan-phpdoc-parser-bridge/releases)
-[![Code Coverage](https://codecov.io/gh/typhoon-php/phpstan-phpdoc-parser-bridge/branch/0.1.x/graph/badge.svg)](https://codecov.io/gh/typhoon-php/phpstan-phpdoc-parser-bridge/tree/0.1.x)
-[![Mutation testing badge](https://img.shields.io/endpoint?style=flat&url=https%3A%2F%2Fbadge-api.stryker-mutator.io%2Fgithub.com%2Ftyphoon-php%2Fphpstan-phpdoc-parser-bridge%2F0.1.x)](https://dashboard.stryker-mutator.io/reports/github.com/typhoon-php/phpstan-phpdoc-parser-bridge/0.1.x)
+[![PHP Version Requirement](https://img.shields.io/packagist/dependency-v/typhoon/phpstan-type-parser/php)](https://packagist.org/packages/typhoon/phpstan-type-parser)
+[![GitHub Release](https://img.shields.io/github/v/release/typhoon-php/phpstan-type-parser)](https://github.com/typhoon-php/phpstan-type-parser/releases)
+[![Code Coverage](https://codecov.io/gh/typhoon-php/phpstan-type-parser/branch/0.1.x/graph/badge.svg)](https://codecov.io/gh/typhoon-php/phpstan-type-parser/tree/0.1.x)
+[![Mutation testing badge](https://img.shields.io/endpoint?style=flat&url=https%3A%2F%2Fbadge-api.stryker-mutator.io%2Fgithub.com%2Ftyphoon-php%2Fphpstan-type-parser%2F0.1.x)](https://dashboard.stryker-mutator.io/reports/github.com/typhoon-php/phpstan-type-parser/0.1.x)
 
 ## Installation
 
 ```shell
-composer require typhoon/phpstan-phpdoc-parser-bridge
+composer require typhoon/phpstan-type-parser
 ```

composer.json

@@ -1,6 +1,6 @@
 {
-    "name": "typhoon/phpstan-phpdoc-parser-bridge",
-    "description": "Typhoon PHPStan PHPDoc Parser Bridge",
+    "name": "typhoon/phpstan-type-parser",
+    "description": "Typhoon PHPStan Type Parser",
     "license": "MIT",
     "type": "library",
     "authors": [
@@ -25,12 +25,12 @@
     },
     "autoload": {
         "psr-4": {
-            "Typhoon\\PHPStanPhpDocParserBridge\\": "src/"
+            "Typhoon\\PHPStanTypeParser\\": "src/"
         }
     },
     "autoload-dev": {
         "psr-4": {
-            "Typhoon\\PHPStanPhpDocParserBridge\\": "tests/"
+            "Typhoon\\PHPStanTypeParser\\": "tests/"
         }
     },
     "config": {

composer.lock

@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Typhoon\PHPStanTypeParser;
+
+use Typhoon\Type\Type;
+
+/**
+ * @api
+ */
+interface CustomTypeParser
+{
+    /**
+     * @param non-empty-string $unresolvedName
+     * @param list<Type> $typeArguments
+     */
+    public function parseCustomType(string $unresolvedName, array $typeArguments, TypeContext $context): ?Type;
+}

src/CustomTypeParser.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Typhoon\PHPStanTypeParser;
+
+use Typhoon\Type\Type;
+
+/**
+ * @api
+ */
+final class CustomTypeParsers implements CustomTypeParser
+{
+    /**
+     * @param iterable<CustomTypeParser> $customTypeParsers
+     */
+    public function __construct(
+        private readonly iterable $customTypeParsers = [],
+    ) {}
+
+    public function parseCustomType(string $unresolvedName, array $typeArguments, TypeContext $context): ?Type
+    {
+        foreach ($this->customTypeParsers as $customTypeParser) {
+            $type = $customTypeParser->parseCustomType($unresolvedName, $typeArguments, $context);
+
+            if ($type !== null) {
+                return $type;
+            }
+        }
+
+        return null;
+    }
+}

src/CustomTypeParsers.php

@@ -2,7 +2,7 @@
 
 declare(strict_types=1);
 
-namespace Typhoon\PHPStanPhpDocParserBridge\Internal;
+namespace Typhoon\PHPStanTypeParser\Internal;
 
 use PHPStan\PhpDocParser\Ast\ConstExpr\ConstExprFalseNode;
 use PHPStan\PhpDocParser\Ast\ConstExpr\ConstExprFloatNode;
@@ -17,9 +17,10 @@
 use PHPStan\PhpDocParser\Ast\Type\NullableTypeNode;
 use PHPStan\PhpDocParser\Ast\Type\TypeNode;
 use PHPStan\PhpDocParser\Ast\Type\UnionTypeNode;
+use Typhoon\PHPStanTypeParser\CustomTypeParser;
+use Typhoon\PHPStanTypeParser\TypeContext;
 use Typhoon\Type\Type;
 use function Typhoon\Type\andT;
-use function Typhoon\Type\diffT;
 use function Typhoon\Type\floatRangeT;
 use function Typhoon\Type\floatT;
 use function Typhoon\Type\intRangeT;
@@ -48,34 +49,39 @@
 
 /**
  * @internal
- * @psalm-internal Typhoon\PHPStanPhpDocParserBridge
+ * @psalm-internal Typhoon\PHPStanTypeParser
  */
-final class TypeConverter
+final class ContextualTypeParser
 {
-    public function convert(TypeNode $node): Type
+    public function __construct(
+        private readonly CustomTypeParser $customTypeParser,
+        private readonly TypeContext $context,
+    ) {}
+
+    public function parseTypeNode(TypeNode $node): Type
     {
         if ($node instanceof NullableTypeNode) {
-            return nullOrT($this->convert($node->type));
+            return nullOrT($this->parseTypeNode($node->type));
         }
 
         if ($node instanceof ConstTypeNode) {
-            return $this->reflectConstExpr($node);
+            return $this->parseConstExpr($node);
         }
 
         if ($node instanceof IdentifierTypeNode) {
-            return $this->reflectIdentifier($node->name);
+            return $this->parseIdentifier($node->name);
         }
 
         if ($node instanceof GenericTypeNode) {
-            return $this->reflectIdentifier($node->type->name, $node->genericTypes);
+            return $this->parseIdentifier($node->type->name, $node->genericTypes);
         }
 
         if ($node instanceof UnionTypeNode) {
-            return orT(...array_map($this->convert(...), $node->types));
+            return orT(...array_map($this->parseTypeNode(...), $node->types));
         }
 
         if ($node instanceof IntersectionTypeNode) {
-            return andT(...array_map($this->convert(...), $node->types));
+            return andT(...array_map($this->parseTypeNode(...), $node->types));
         }
 
         throw new \LogicException(\sprintf('`%s` is not supported', $node::class));
@@ -85,8 +91,10 @@ public function convert(TypeNode $node): Type
      * @param non-empty-string $name
      * @param list<TypeNode> $genericNodes
      */
-    private function reflectIdentifier(string $name, array $genericNodes = []): Type
+    private function parseIdentifier(string $name, array $genericNodes = []): Type
     {
+        $typeArguments = fn(): array => array_map($this->parseTypeNode(...), $genericNodes);
+
         return match ($name) {
             'never' => neverT,
             'void' => voidT,
@@ -102,8 +110,8 @@ private function reflectIdentifier(string $name, array $genericNodes = []): Type
             'int', 'integer' => match (\count($genericNodes)) {
                 0 => intT,
                 2 => intRangeT(
-                    min: $this->reflectRangeLimit($genericNodes[0], 'min', float: false),
-                    max: $this->reflectRangeLimit($genericNodes[1], 'max', float: false),
+                    min: $this->parseRangeLimit($genericNodes[0], 'min', float: false),
+                    max: $this->parseRangeLimit($genericNodes[1], 'max', float: false),
                 ),
                 default => throw new \LogicException(\sprintf(
                     'int range type should have 2 type arguments, got %d',
@@ -113,30 +121,30 @@ private function reflectIdentifier(string $name, array $genericNodes = []): Type
             'float' => match (\count($genericNodes)) {
                 0 => floatT,
                 2 => floatRangeT(
-                    min: $this->reflectRangeLimit($genericNodes[0], 'min', float: true),
-                    max: $this->reflectRangeLimit($genericNodes[1], 'max', float: true),
+                    min: $this->parseRangeLimit($genericNodes[0], 'min', float: true),
+                    max: $this->parseRangeLimit($genericNodes[1], 'max', float: true),
                 ),
                 default => throw new \LogicException(\sprintf(
                     'float range type should have 2 type arguments, got %d',
                     \count($genericNodes),
                 ))
             },
-            'diff' => diffT($this->convert($genericNodes[0]), $this->convert($genericNodes[1])),
             'string' => stringT,
             'non-empty-string' => nonEmptyStringT,
             'resource' => resourceT,
             'array-key' => arrayKeyT,
             'scalar' => scalarT,
             'mixed' => mixedT,
-            default => throw new \LogicException(),
+            default => $this->customTypeParser->parseCustomType($name, $typeArguments(), $this->context)
+                ?? throw new \LogicException(\sprintf('Unknown identifier `%s`', $name)),
         };
     }
 
     /**
      * @param 'min'|'max' $name
      * @return ?numeric-string
      */
-    private function reflectRangeLimit(TypeNode $type, string $name, bool $float): ?string
+    private function parseRangeLimit(TypeNode $type, string $name, bool $float): ?string
     {
         if ($type instanceof IdentifierTypeNode) {
             if ($type->name === $name) {
@@ -163,7 +171,7 @@ private function reflectRangeLimit(TypeNode $type, string $name, bool $float): ?
         throw new \LogicException();
     }
 
-    private function reflectConstExpr(ConstTypeNode $node): Type
+    private function parseConstExpr(ConstTypeNode $node): Type
     {
         $exprNode = $node->constExpr;
 

src/Internal/TypeConverter.php src/Internal/ContextualTypeParser.phpsrc/Internal/TypeConverter.php renamed to src/Internal/ContextualTypeParser.php

@@ -0,0 +1,49 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Typhoon\PHPStanTypeParser;
+
+use PHPStan\PhpDocParser\Ast\Type\TypeNode;
+use PHPStan\PhpDocParser\Lexer\Lexer;
+use PHPStan\PhpDocParser\Parser\ConstExprParser;
+use PHPStan\PhpDocParser\Parser\TokenIterator;
+use PHPStan\PhpDocParser\Parser\TypeParser;
+use PHPStan\PhpDocParser\ParserConfig;
+use Typhoon\PHPStanTypeParser\Internal\ContextualTypeParser;
+use Typhoon\Type\Type;
+
+/**
+ * @api
+ */
+final class PHPStanTypeParser
+{
+    private readonly CustomTypeParser $customTypeParser;
+
+    /**
+     * @param iterable<CustomTypeParser> $customTypeParsers
+     */
+    public function __construct(
+        iterable $customTypeParsers = [],
+        private readonly Lexer $lexer = new Lexer(new ParserConfig([])),
+        private readonly TypeParser $typeParser = new TypeParser(
+            new ParserConfig([]),
+            new ConstExprParser(new ParserConfig([])),
+        ),
+    ) {
+        $this->customTypeParser = new CustomTypeParsers($customTypeParsers);
+    }
+
+    public function parseString(string $type, TypeContext $context = new RuntimeTypeContext()): Type
+    {
+        $tokens = new TokenIterator($this->lexer->tokenize($type));
+        $typeNode = $this->typeParser->parse($tokens);
+
+        return $this->parseTypeNode($typeNode, $context);
+    }
+
+    public function parseTypeNode(TypeNode $node, TypeContext $context = new RuntimeTypeContext()): Type
+    {
+        return (new ContextualTypeParser($this->customTypeParser, $context))->parseTypeNode($node);
+    }
+}