Array shapes support

doc/grammars/type.abnf

@@ -52,6 +52,12 @@ CallableReturnType
 Array
 	= 1*(TokenSquareBracketOpen TokenSquareBracketClose)
 
+ArrayShape
+    = TokenCurlyBracketOpen ArrayShapeItem *(TokenComma ArrayShapeItem) TokenCurlyBracketClose
+
+ArrayShapeItem
+    = (ConstantString / ConstantInt / TokenIdentifier) TokenNullable TokenColon Type
+    / Type
 
 ; ---------------------------------------------------------------------------- ;
 ;  ConstantExpr                                                                ;
@@ -139,6 +145,12 @@ TokenSquareBracketOpen
 TokenSquareBracketClose
 	= "]" *ByteHorizontalWs
 
+TokenCurlyBracketOpen
+    = "{" *ByteHorizontalWs
+
+TokenCurlyBracketClose
+    = "}" *ByteHorizontalWs
+
 TokenComma
 	= "," *ByteHorizontalWs
 

src/Ast/Type/ArrayShapeItemNode.php

@@ -0,0 +1,44 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\PhpDocParser\Ast\Type;
+
+use PHPStan\PhpDocParser\Ast\ConstExpr\ConstExprIntegerNode;
+
+class ArrayShapeItemNode implements TypeNode
+{
+
+	/** @var ConstExprIntegerNode|IdentifierTypeNode|null */
+	public $keyName;
+
+	/** @var bool */
+	public $optional;
+
+	/** @var TypeNode */
+	public $valueType;
+
+	/**
+	 * @param ConstExprIntegerNode|IdentifierTypeNode|null $keyName
+	 */
+	public function __construct($keyName, bool $optional, TypeNode $valueType)
+	{
+		$this->keyName = $keyName;
+		$this->optional = $optional;
+		$this->valueType = $valueType;
+	}
+
+
+	public function __toString(): string
+	{
+		if ($this->keyName !== null) {
+			return sprintf(
+				'%s%s: %s',
+				(string) $this->keyName,
+				$this->optional ? '?' : '',
+				(string) $this->valueType
+			);
+		}
+
+		return (string) $this->valueType;
+	}
+
+}

src/Ast/Type/ArrayShapeNode.php

@@ -0,0 +1,22 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\PhpDocParser\Ast\Type;
+
+class ArrayShapeNode implements TypeNode
+{
+
+	/** @var ArrayShapeItemNode[] */
+	public $items;
+
+	public function __construct(array $items)
+	{
+		$this->items = $items;
+	}
+
+
+	public function __toString(): string
+	{
+		return 'array{' . implode(', ', $this->items) . '}';
+	}
+
+}

src/Lexer/Lexer.php

@@ -18,6 +18,8 @@ class Lexer
 	public const TOKEN_CLOSE_ANGLE_BRACKET = 7;
 	public const TOKEN_OPEN_SQUARE_BRACKET = 8;
 	public const TOKEN_CLOSE_SQUARE_BRACKET = 9;
+	public const TOKEN_OPEN_CURLY_BRACKET = 30;
+	public const TOKEN_CLOSE_CURLY_BRACKET = 31;
 	public const TOKEN_COMMA = 10;
 	public const TOKEN_COLON = 29;
 	public const TOKEN_VARIADIC = 11;
@@ -50,6 +52,8 @@ class Lexer
 		self::TOKEN_CLOSE_ANGLE_BRACKET => '\'>\'',
 		self::TOKEN_OPEN_SQUARE_BRACKET => '\'[\'',
 		self::TOKEN_CLOSE_SQUARE_BRACKET => '\']\'',
+		self::TOKEN_OPEN_CURLY_BRACKET => '\'{\'',
+		self::TOKEN_CLOSE_CURLY_BRACKET => '\'}\'',
 		self::TOKEN_COMMA => '\',\'',
 		self::TOKEN_COLON => '\':\'',
 		self::TOKEN_VARIADIC => '\'...\'',
@@ -123,6 +127,8 @@ private function initialize(): void
 			self::TOKEN_CLOSE_ANGLE_BRACKET => '>',
 			self::TOKEN_OPEN_SQUARE_BRACKET => '\\[',
 			self::TOKEN_CLOSE_SQUARE_BRACKET => '\\]',
+			self::TOKEN_OPEN_CURLY_BRACKET => '\\{',
+			self::TOKEN_CLOSE_CURLY_BRACKET => '\\}',
 
 			self::TOKEN_COMMA => ',',
 			self::TOKEN_VARIADIC => '\\.\\.\\.',

src/Parser/TokenIterator.php

@@ -64,6 +64,12 @@ public function isCurrentTokenType(int $tokenType): bool
 	}
 
 
+	public function isPrecededByHorizontalWhitespace(): bool
+	{
+		return ($this->tokens[$this->index - 1][Lexer::TYPE_OFFSET] ?? -1) === Lexer::TOKEN_HORIZONTAL_WS;
+	}
+
+
 	/**
 	 * @param  int $tokenType
 	 * @throws \PHPStan\PhpDocParser\Parser\ParserException

src/Parser/TypeParser.php

@@ -53,6 +53,9 @@ private function parseAtomic(TokenIterator $tokens): Ast\Type\TypeNode
 
 			} elseif ($tokens->isCurrentTokenType(Lexer::TOKEN_OPEN_SQUARE_BRACKET)) {
 				$type = $this->tryParseArray($tokens, $type);
+
+			} elseif ($type->name === 'array' && $tokens->isCurrentTokenType(Lexer::TOKEN_OPEN_CURLY_BRACKET) && !$tokens->isPrecededByHorizontalWhitespace()) {
+				$type = $this->parseArrayShape($tokens, $type);
 			}
 		}
 
@@ -93,6 +96,9 @@ private function parseNullable(TokenIterator $tokens): Ast\Type\TypeNode
 
 		if ($tokens->isCurrentTokenType(Lexer::TOKEN_OPEN_ANGLE_BRACKET)) {
 			$type = $this->parseGeneric($tokens, $type);
+
+		} elseif ($type->name === 'array' && $tokens->isCurrentTokenType(Lexer::TOKEN_OPEN_CURLY_BRACKET) && !$tokens->isPrecededByHorizontalWhitespace()) {
+			$type = $this->parseArrayShape($tokens, $type);
 		}
 
 		return new Ast\Type\NullableTypeNode($type);
@@ -167,6 +173,9 @@ private function parseCallableReturnType(TokenIterator $tokens): Ast\Type\TypeNo
 
 			if ($tokens->isCurrentTokenType(Lexer::TOKEN_OPEN_ANGLE_BRACKET)) {
 				$type = $this->parseGeneric($tokens, $type);
+
+			} elseif ($type->name === 'array' && $tokens->isCurrentTokenType(Lexer::TOKEN_OPEN_CURLY_BRACKET) && !$tokens->isPrecededByHorizontalWhitespace()) {
+				$type = $this->parseArrayShape($tokens, $type);
 			}
 		}
 
@@ -208,4 +217,56 @@ private function tryParseArray(TokenIterator $tokens, Ast\Type\TypeNode $type):
 		return $type;
 	}
 
+
+	private function parseArrayShape(TokenIterator $tokens, Ast\Type\TypeNode $type): Ast\Type\TypeNode
+	{
+		$tokens->consumeTokenType(Lexer::TOKEN_OPEN_CURLY_BRACKET);
+		$items = [$this->parseArrayShapeItem($tokens)];
+
+		while ($tokens->tryConsumeTokenType(Lexer::TOKEN_COMMA)) {
+			$items[] = $this->parseArrayShapeItem($tokens);
+		}
+
+		$tokens->consumeTokenType(Lexer::TOKEN_CLOSE_CURLY_BRACKET);
+
+		return new Ast\Type\ArrayShapeNode($items);
+	}
+
+
+	private function parseArrayShapeItem(TokenIterator $tokens): Ast\Type\ArrayShapeItemNode
+	{
+		try {
+			$tokens->pushSavePoint();
+			$key = $this->parseArrayShapeKey($tokens);
+			$optional = $tokens->tryConsumeTokenType(Lexer::TOKEN_NULLABLE);
+			$tokens->consumeTokenType(Lexer::TOKEN_COLON);
+			$value = $this->parse($tokens);
+			$tokens->dropSavePoint();
+
+			return new Ast\Type\ArrayShapeItemNode($key, $optional, $value);
+		} catch (\PHPStan\PhpDocParser\Parser\ParserException $e) {
+			$tokens->rollback();
+			$value = $this->parse($tokens);
+
+			return new Ast\Type\ArrayShapeItemNode(null, false, $value);
+		}
+	}
+
+	/**
+	 * @return Ast\ConstExpr\ConstExprIntegerNode|Ast\Type\IdentifierTypeNode
+	 */
+	private function parseArrayShapeKey(TokenIterator $tokens)
+	{
+		if ($tokens->isCurrentTokenType(Lexer::TOKEN_INTEGER)) {
+			$key = new Ast\ConstExpr\ConstExprIntegerNode($tokens->currentTokenValue());
+			$tokens->next();
+
+		} else {
+			$key = new Ast\Type\IdentifierTypeNode($tokens->currentTokenValue());
+			$tokens->consumeTokenType(Lexer::TOKEN_IDENTIFIER);
+		}
+
+		return $key;
+	}
+
 }