ConstFetchNode - supports all constants wildcard

Author: ondrejmirtes

src/Parser/ConstExprParser.php

@@ -53,8 +53,18 @@ public function parse(TokenIterator $tokens, bool $trimStrings = false): Ast\Con
 			}
 
 			if ($tokens->tryConsumeTokenType(Lexer::TOKEN_DOUBLE_COLON)) {
-				$classConstantName = $tokens->currentTokenValue();
-				$tokens->consumeTokenType(Lexer::TOKEN_IDENTIFIER);
+				$classConstantName = '';
+				if ($tokens->currentTokenType() === Lexer::TOKEN_IDENTIFIER) {
+					$classConstantName .= $tokens->currentTokenValue();
+					$tokens->consumeTokenType(Lexer::TOKEN_IDENTIFIER);
+					if ($tokens->tryConsumeTokenValue('*')) {
+						$classConstantName .= '*';
+					}
+				} else {
+					$tokens->consumeTokenValue('*');
+					$classConstantName .= '*';
+				}
+
 				return new Ast\ConstExpr\ConstFetchNode($identifier, $classConstantName);
 
 			}

src/Parser/ParserException.php

@@ -19,27 +19,43 @@ class ParserException extends \Exception
 	/** @var int */
 	private $expectedTokenType;
 
+	/** @var string */
+	private $expectedTokenValue;
+
 	public function __construct(
 		string $currentTokenValue,
 		int $currentTokenType,
 		int $currentOffset,
-		int $expectedTokenType
+		?int $expectedTokenType,
+		?string $expectedTokenValue = null
 	)
 	{
 		$this->currentTokenValue = $currentTokenValue;
 		$this->currentTokenType = $currentTokenType;
 		$this->currentOffset = $currentOffset;
 		$this->expectedTokenType = $expectedTokenType;
+		$this->expectedTokenValue = $expectedTokenValue;
 
 		$json = json_encode($currentTokenValue, JSON_UNESCAPED_UNICODE | JSON_UNESCAPED_SLASHES);
 		assert($json !== false);
 
-		parent::__construct(sprintf(
-			'Unexpected token %s, expected %s at offset %d',
-			$json,
-			Lexer::TOKEN_LABELS[$expectedTokenType],
-			$currentOffset
-		));
+		if ($expectedTokenType !== null) {
+			parent::__construct(sprintf(
+				'Unexpected token %s, expected %s at offset %d',
+				$json,
+				Lexer::TOKEN_LABELS[$expectedTokenType],
+				$currentOffset
+			));
+		} elseif ($expectedTokenValue !== null) {
+			parent::__construct(sprintf(
+				'Unexpected token value %s, expected value %s at offset %d',
+				$json,
+				$expectedTokenValue,
+				$currentOffset
+			));
+		} else {
+			throw new \LogicException();
+		}
 	}
 
 
@@ -66,4 +82,9 @@ public function getExpectedTokenType(): int
 		return $this->expectedTokenType;
 	}
 
+	public function getExpectedTokenValue(): string
+	{
+		return $this->expectedTokenValue;
+	}
+
 }

src/Parser/TokenIterator.php

@@ -69,6 +69,25 @@ public function isPrecededByHorizontalWhitespace(): bool
 		return ($this->tokens[$this->index - 1][Lexer::TYPE_OFFSET] ?? -1) === Lexer::TOKEN_HORIZONTAL_WS;
 	}
 
+	/**
+	 * @param  string $tokenValue
+	 * @throws \PHPStan\PhpDocParser\Parser\ParserException
+	 */
+	public function consumeTokenValue(string $tokenValue): void
+	{
+		if ($this->tokens[$this->index][Lexer::VALUE_OFFSET] !== $tokenValue) {
+			$this->throwError(null, $tokenValue);
+		}
+
+		$this->index++;
+
+		if (($this->tokens[$this->index][Lexer::TYPE_OFFSET] ?? -1) !== Lexer::TOKEN_HORIZONTAL_WS) {
+			return;
+		}
+
+		$this->index++;
+	}
+
 
 	/**
 	 * @param  int $tokenType
@@ -77,7 +96,7 @@ public function isPrecededByHorizontalWhitespace(): bool
 	public function consumeTokenType(int $tokenType): void
 	{
 		if ($this->tokens[$this->index][Lexer::TYPE_OFFSET] !== $tokenType) {
-			$this->throwError($tokenType);
+			$this->throwError($tokenType, null);
 		}
 
 		$this->index++;
@@ -175,16 +194,18 @@ public function rollback(): void
 
 
 	/**
-	 * @param  int $expectedTokenType
+	 * @param  int|null $expectedTokenType
+	 * @param  string|null $expectedTokenValue
 	 * @throws \PHPStan\PhpDocParser\Parser\ParserException
 	 */
-	private function throwError(int $expectedTokenType): void
+	private function throwError(?int $expectedTokenType, ?string $expectedTokenValue): void
 	{
 		throw new \PHPStan\PhpDocParser\Parser\ParserException(
 			$this->currentTokenValue(),
 			$this->currentTokenType(),
 			$this->currentTokenOffset(),
-			$expectedTokenType
+			$expectedTokenType,
+			$expectedTokenValue
 		);
 	}
 

src/Parser/TypeParser.php

@@ -108,12 +108,7 @@ private function parseAtomic(TokenIterator $tokens): Ast\Type\TypeNode
 			if ($constExpr instanceof Ast\ConstExpr\ConstExprArrayNode) {
 				throw $exception;
 			}
-			if ($constExpr instanceof Ast\ConstExpr\ConstFetchNode) {
-				if ($tokens->currentTokenValue() === '*') {
-					$tokens->consumeTokenType($tokens->currentTokenType());
-					$constExpr = new Ast\ConstExpr\ConstFetchNode($constExpr->className, $constExpr->name . '*');
-				}
-			}
+
 			return new Ast\Type\ConstTypeNode($constExpr);
 		} catch (\LogicException $e) {
 			throw $exception;

tests/PHPStan/Parser/TypeParserTest.php

@@ -858,6 +858,20 @@ public function provideParseData(): array
 				'Foo::FOO_*',
 				new ConstTypeNode(new ConstFetchNode('Foo', 'FOO_*')),
 			],
+			[
+				'Foo::*',
+				new ConstTypeNode(new ConstFetchNode('Foo', '*')),
+			],
+			[
+				'Foo::**',
+				new \PHPStan\PhpDocParser\Parser\ParserException(
+					'**',
+					Lexer::TOKEN_END,
+					5,
+					null,
+					'*'
+				),
+			],
 			[
 				'( "foo" | Foo::FOO_* )',
 				new UnionTypeNode([