TypeParser - give all types the line and index attributes

Author: ondrejmirtes

src/Parser/TypeParser.php

@@ -57,6 +57,12 @@ public function parse(TokenIterator $tokens): Ast\Type\TypeNode
 				$type = $this->parseIntersection($tokens, $type);
 			}
 		}
+
+		return $this->enrichWithAttributes($tokens, $type, $startLine, $startIndex);
+	}
+
+	private function enrichWithAttributes(TokenIterator $tokens, Ast\Type\TypeNode $type, int $startLine, int $startIndex): Ast\Type\TypeNode
+	{
 		$endLine = $tokens->currentTokenLine();
 		$endIndex = $tokens->currentTokenIndex();
 
@@ -76,6 +82,9 @@ public function parse(TokenIterator $tokens): Ast\Type\TypeNode
 	/** @phpstan-impure */
 	private function subParse(TokenIterator $tokens): Ast\Type\TypeNode
 	{
+		$startLine = $tokens->currentTokenLine();
+		$startIndex = $tokens->currentTokenIndex();
+
 		if ($tokens->isCurrentTokenType(Lexer::TOKEN_NULLABLE)) {
 			$type = $this->parseNullable($tokens);
 
@@ -99,13 +108,16 @@ private function subParse(TokenIterator $tokens): Ast\Type\TypeNode
 			}
 		}
 
-		return $type;
+		return $this->enrichWithAttributes($tokens, $type, $startLine, $startIndex);
 	}
 
 
 	/** @phpstan-impure */
 	private function parseAtomic(TokenIterator $tokens): Ast\Type\TypeNode
 	{
+		$startLine = $tokens->currentTokenLine();
+		$startIndex = $tokens->currentTokenIndex();
+
 		if ($tokens->tryConsumeTokenType(Lexer::TOKEN_OPEN_PARENTHESES)) {
 			$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
 			$type = $this->subParse($tokens);
@@ -114,20 +126,20 @@ private function parseAtomic(TokenIterator $tokens): Ast\Type\TypeNode
 			$tokens->consumeTokenType(Lexer::TOKEN_CLOSE_PARENTHESES);
 
 			if ($tokens->isCurrentTokenType(Lexer::TOKEN_OPEN_SQUARE_BRACKET)) {
-				return $this->tryParseArrayOrOffsetAccess($tokens, $type);
+				$type = $this->tryParseArrayOrOffsetAccess($tokens, $type);
 			}
 
-			return $type;
+			return $this->enrichWithAttributes($tokens, $type, $startLine, $startIndex);
 		}
 
 		if ($tokens->tryConsumeTokenType(Lexer::TOKEN_THIS_VARIABLE)) {
 			$type = new Ast\Type\ThisTypeNode();
 
 			if ($tokens->isCurrentTokenType(Lexer::TOKEN_OPEN_SQUARE_BRACKET)) {
-				return $this->tryParseArrayOrOffsetAccess($tokens, $type);
+				$type = $this->tryParseArrayOrOffsetAccess($tokens, $type);
 			}
 
-			return $type;
+			return $this->enrichWithAttributes($tokens, $type, $startLine, $startIndex);
 		}
 
 		$currentTokenValue = $tokens->currentTokenValue();
@@ -143,7 +155,7 @@ private function parseAtomic(TokenIterator $tokens): Ast\Type\TypeNode
 					$isHtml = $this->isHtml($tokens);
 					$tokens->rollback();
 					if ($isHtml) {
-						return $type;
+						return $this->enrichWithAttributes($tokens, $type, $startLine, $startIndex);
 					}
 
 					$type = $this->parseGeneric($tokens, $type);
@@ -169,7 +181,7 @@ private function parseAtomic(TokenIterator $tokens): Ast\Type\TypeNode
 					}
 				}
 
-				return $type;
+				return $this->enrichWithAttributes($tokens, $type, $startLine, $startIndex);
 			} else {
 				$tokens->rollback(); // because of ConstFetchNode
 			}
@@ -196,7 +208,7 @@ private function parseAtomic(TokenIterator $tokens): Ast\Type\TypeNode
 				throw $exception;
 			}
 
-			return new Ast\Type\ConstTypeNode($constExpr);
+			return $this->enrichWithAttributes($tokens, new Ast\Type\ConstTypeNode($constExpr), $startLine, $startIndex);
 		} catch (LogicException $e) {
 			throw $exception;
 		}

tests/PHPStan/Parser/TypeParserTest.php

@@ -1909,39 +1909,76 @@ public function dataLinesAndIndexes(): iterable
 	{
 		yield [
 			'int | object{foo: int}[]',
-			1,
-			1,
-			0,
-			13,
+			[
+				[
+					static function (TypeNode $typeNode): TypeNode {
+						return $typeNode;
+					},
+					1,
+					1,
+					0,
+					13,
+				],
+				[
+					static function (UnionTypeNode $typeNode): TypeNode {
+						return $typeNode->types[0];
+					},
+					1,
+					1,
+					0,
+					2,
+				],
+				[
+					static function (UnionTypeNode $typeNode): TypeNode {
+						return $typeNode->types[1];
+					},
+					1,
+					1,
+					4,
+					13,
+				],
+			],
 		];
 
 		yield [
 			'array{
 				a: int,
 				b: string
 			 }',
-			1,
-			4,
-			0,
-			15,
+			[
+				[
+					static function (TypeNode $typeNode): TypeNode {
+						return $typeNode;
+					},
+					1,
+					4,
+					0,
+					15,
+				],
+			],
 		];
 	}
 
 	/**
 	 * @dataProvider dataLinesAndIndexes
+	 * @param list<array{callable(TypeNode): TypeNode, int, int, int, int}> $assertions
 	 */
-	public function testLinesAndIndexes(string $input, int $startLine, int $endLine, int $startIndex, int $endIndex): void
+	public function testLinesAndIndexes(string $input, array $assertions): void
 	{
 		$tokens = new TokenIterator($this->lexer->tokenize($input));
 		$typeParser = new TypeParser(new ConstExprParser(true, true), true, [
 			'lines' => true,
 			'indexes' => true,
 		]);
 		$typeNode = $typeParser->parse($tokens);
-		$this->assertSame($startLine, $typeNode->getAttribute(Attribute::START_LINE));
-		$this->assertSame($endLine, $typeNode->getAttribute(Attribute::END_LINE));
-		$this->assertSame($startIndex, $typeNode->getAttribute(Attribute::START_INDEX));
-		$this->assertSame($endIndex, $typeNode->getAttribute(Attribute::END_INDEX));
+
+		foreach ($assertions as [$callable, $startLine, $endLine, $startIndex, $endIndex]) {
+			$typeToAssert = $callable($typeNode);
+			$this->assertSame($startLine, $typeToAssert->getAttribute(Attribute::START_LINE));
+			$this->assertSame($endLine, $typeToAssert->getAttribute(Attribute::END_LINE));
+			$this->assertSame($startIndex, $typeToAssert->getAttribute(Attribute::START_INDEX));
+			$this->assertSame($endIndex, $typeToAssert->getAttribute(Attribute::END_INDEX));
+		}
 	}
 
 }