Support list/array shapes

Author: vudaltsov

composer.json

@@ -16,6 +16,7 @@
     "require": {
         "php": "^8.2",
         "phpstan/phpdoc-parser": "^2.1",
+        "symfony/polyfill-php84": "^1.33",
         "typhoon/type": "^0.6@dev"
     },
     "require-dev": {

composer.lock

@@ -13,6 +13,7 @@
 use PHPStan\PhpDocParser\Ast\ConstExpr\ConstExprTrueNode;
 use PHPStan\PhpDocParser\Ast\ConstExpr\ConstFetchNode;
 use PHPStan\PhpDocParser\Ast\PhpDoc\TemplateTagValueNode;
+use PHPStan\PhpDocParser\Ast\Type\ArrayShapeNode;
 use PHPStan\PhpDocParser\Ast\Type\ArrayTypeNode;
 use PHPStan\PhpDocParser\Ast\Type\CallableTypeNode;
 use PHPStan\PhpDocParser\Ast\Type\CallableTypeParameterNode;
@@ -107,6 +108,7 @@ public function parse(TypeNode $node): Type
                 $node instanceof UnionTypeNode => orT(...array_map($this->parse(...), $node->types)),
                 $node instanceof IntersectionTypeNode => andT(...array_map($this->parse(...), $node->types)),
                 $node instanceof ArrayTypeNode => arrayT(value: $this->parse($node->type)),
+                $node instanceof ArrayShapeNode => $this->arrayShape($node),
                 $node instanceof OffsetAccessTypeNode => offsetT($this->parse($node->type), $this->parse($node->offset)),
                 $node instanceof CallableTypeNode => $this->callable($node),
                 default => throw new \LogicException(\sprintf('`%s` is not supported', $node::class)),
@@ -303,6 +305,56 @@ private function list(array $templateArguments, bool $isNonEmpty = false): ListT
         };
     }
 
+    private function arrayShape(ArrayShapeNode $node): Type
+    {
+        $elements = [];
+
+        foreach ($node->items as $item) {
+            $elements[] = new Type\ArrayElement(
+                key: match (true) {
+                    $item->keyName === null => \count($elements),
+                    $item->keyName instanceof ConstExprIntegerNode => (int) $item->keyName->value,
+                    $item->keyName instanceof ConstExprStringNode => $item->keyName->value,
+                    $item->keyName instanceof IdentifierTypeNode => $item->keyName->name,
+                    default => throw new \LogicException(),
+                },
+                type: $this->parse($item->valueType),
+                isOptional: $item->optional,
+            );
+        }
+
+        $valueType = match (true) {
+            $node->sealed => neverT,
+            $node->unsealedType === null => mixedT,
+            default => $this->parse($node->unsealedType->valueType),
+        };
+
+        if (($node->kind === ArrayShapeNode::KIND_NON_EMPTY_LIST || $node->kind === ArrayShapeNode::KIND_LIST)
+            && $node->unsealedType?->keyType === null
+            && array_column($elements, 'key') === array_keys($elements)
+            && array_all($elements, static fn(Type\ArrayElement $e): bool => !$e->isOptional)
+        ) {
+            return new ListT(
+                valueType: $valueType,
+                elementTypes: array_column($elements, 'type'),
+                isNonEmpty: $node->kind === ArrayShapeNode::KIND_NON_EMPTY_LIST,
+            );
+        }
+
+        $keyType = match (true) {
+            $node->sealed => neverT,
+            $node->unsealedType?->keyType === null => arrayKeyT,
+            default => $this->parse($node->unsealedType->keyType),
+        };
+
+        return new ArrayT(
+            keyType: $keyType,
+            valueType: $valueType,
+            elements: $elements,
+            isNonEmpty: $node->kind === ArrayShapeNode::KIND_NON_EMPTY_LIST,
+        );
+    }
+
     /**
      * @param list<Type> $templateArguments
      */

src/Internal/ContextualParser.php

@@ -10,6 +10,7 @@
 use Typhoon\PHPStanTypeParser\Internal\ContextualParser;
 use Typhoon\Type;
 use function Typhoon\Type\andT;
+use function Typhoon\Type\arrayShapeT;
 use function Typhoon\Type\arrayT;
 use function Typhoon\Type\callableT;
 use function Typhoon\Type\classConstantMaskT;
@@ -20,15 +21,19 @@
 use function Typhoon\Type\intRangeT;
 use function Typhoon\Type\intT;
 use function Typhoon\Type\iterableT;
+use function Typhoon\Type\listShapeT;
 use function Typhoon\Type\listT;
 use function Typhoon\Type\namedObjectT;
 use function Typhoon\Type\nonEmptyArrayT;
 use function Typhoon\Type\nonEmptyListT;
 use function Typhoon\Type\nullOrT;
 use function Typhoon\Type\offsetT;
+use function Typhoon\Type\optional;
 use function Typhoon\Type\orT;
 use function Typhoon\Type\stringT;
 use function Typhoon\Type\template;
+use function Typhoon\Type\unsealedArrayShapeT;
+use function Typhoon\Type\unsealedListShapeT;
 use const Typhoon\Type\arrayKeyT;
 use const Typhoon\Type\arrayT;
 use const Typhoon\Type\boolT;
@@ -122,10 +127,24 @@ private static function cases(): \Generator
         yield 'int&string' => andT(intT, stringT);
         yield '(int&string)&float' => andT(andT(intT, stringT), floatT);
         yield 'list' => listT();
+        yield 'list{}' => listShapeT();
+        yield 'list{int}' => listShapeT([intT]);
+        yield 'list{a: int}' => arrayShapeT(['a' => intT]);
+        yield 'list{int, ...}' => unsealedListShapeT([intT]);
+        yield 'list{int, ...<string>}' => unsealedListShapeT([intT], stringT);
+        yield 'list{int, 1?: float, ...<string>}' => unsealedArrayShapeT([intT, optional(floatT)], value: stringT);
         yield 'non-empty-list' => nonEmptyListT();
         yield 'list<string>' => listT(stringT);
         yield 'non-empty-list<string>' => nonEmptyListT(stringT);
         yield 'array' => arrayT;
+        yield 'array{}' => arrayShapeT();
+        yield 'array{a: int}' => arrayShapeT(['a' => intT]);
+        yield 'array{"a": int}' => arrayShapeT(['a' => intT]);
+        yield "array{'a': int}" => arrayShapeT(['a' => intT]);
+        yield 'array{int}' => arrayShapeT([intT]);
+        yield 'array{int, ...}' => unsealedArrayShapeT([intT]);
+        yield 'array{int, ...<string>}' => unsealedArrayShapeT([intT], value: stringT);
+        yield 'array{float, ...<int, string>}' => unsealedArrayShapeT([floatT], intT, stringT);
         yield 'string[]' => arrayT(value: stringT);
         yield 'array<string>' => arrayT(value: stringT);
         yield 'array<int, string>' => arrayT(intT, stringT);