Callable parameter and return type have attributes

Author: ondrejmirtes

src/Parser/TypeParser.php

@@ -61,7 +61,12 @@ public function parse(TokenIterator $tokens): Ast\Type\TypeNode
 		return $this->enrichWithAttributes($tokens, $type, $startLine, $startIndex);
 	}
 
-	private function enrichWithAttributes(TokenIterator $tokens, Ast\Type\TypeNode $type, int $startLine, int $startIndex): Ast\Type\TypeNode
+	/**
+	 * @template T of Ast\Node
+	 * @param T $type
+	 * @return T
+	 */
+	private function enrichWithAttributes(TokenIterator $tokens, Ast\Node $type, int $startLine, int $startIndex): Ast\Node
 	{
 		$endLine = $tokens->currentTokenLine();
 		$endIndex = $tokens->currentTokenIndex();
@@ -139,7 +144,7 @@ private function parseAtomic(TokenIterator $tokens): Ast\Type\TypeNode
 		}
 
 		if ($tokens->tryConsumeTokenType(Lexer::TOKEN_THIS_VARIABLE)) {
-			$type = new Ast\Type\ThisTypeNode();
+			$type = $this->enrichWithAttributes($tokens, new Ast\Type\ThisTypeNode(), $startLine, $startIndex);
 
 			if ($tokens->isCurrentTokenType(Lexer::TOKEN_OPEN_SQUARE_BRACKET)) {
 				$type = $this->tryParseArrayOrOffsetAccess($tokens, $type);
@@ -151,7 +156,7 @@ private function parseAtomic(TokenIterator $tokens): Ast\Type\TypeNode
 		$currentTokenValue = $tokens->currentTokenValue();
 		$tokens->pushSavePoint(); // because of ConstFetchNode
 		if ($tokens->tryConsumeTokenType(Lexer::TOKEN_IDENTIFIER)) {
-			$type = new Ast\Type\IdentifierTypeNode($currentTokenValue);
+			$type = $this->enrichWithAttributes($tokens, new Ast\Type\IdentifierTypeNode($currentTokenValue), $startLine, $startIndex);
 
 			if (!$tokens->isCurrentTokenType(Lexer::TOKEN_DOUBLE_COLON)) {
 				$tokens->dropSavePoint(); // because of ConstFetchNode
@@ -454,7 +459,10 @@ private function parseCallable(TokenIterator $tokens, Ast\Type\IdentifierTypeNod
 
 		$tokens->consumeTokenType(Lexer::TOKEN_CLOSE_PARENTHESES);
 		$tokens->consumeTokenType(Lexer::TOKEN_COLON);
-		$returnType = $this->parseCallableReturnType($tokens);
+
+		$startLine = $tokens->currentTokenLine();
+		$startIndex = $tokens->currentTokenIndex();
+		$returnType = $this->enrichWithAttributes($tokens, $this->parseCallableReturnType($tokens), $startLine, $startIndex);
 
 		return new Ast\Type\CallableTypeNode($identifier, $parameters, $returnType);
 	}
@@ -463,6 +471,8 @@ private function parseCallable(TokenIterator $tokens, Ast\Type\IdentifierTypeNod
 	/** @phpstan-impure */
 	private function parseCallableParameter(TokenIterator $tokens): Ast\Type\CallableTypeParameterNode
 	{
+		$startLine = $tokens->currentTokenLine();
+		$startIndex = $tokens->currentTokenIndex();
 		$type = $this->parse($tokens);
 		$isReference = $tokens->tryConsumeTokenType(Lexer::TOKEN_REFERENCE);
 		$isVariadic = $tokens->tryConsumeTokenType(Lexer::TOKEN_VARIADIC);
@@ -476,7 +486,12 @@ private function parseCallableParameter(TokenIterator $tokens): Ast\Type\Callabl
 		}
 
 		$isOptional = $tokens->tryConsumeTokenType(Lexer::TOKEN_EQUAL);
-		return new Ast\Type\CallableTypeParameterNode($type, $isReference, $isVariadic, $parameterName, $isOptional);
+		return $this->enrichWithAttributes(
+			$tokens,
+			new Ast\Type\CallableTypeParameterNode($type, $isReference, $isVariadic, $parameterName, $isOptional),
+			$startLine,
+			$startIndex
+		);
 	}
 
 

tests/PHPStan/Parser/TypeParserTest.php

@@ -8,6 +8,7 @@
 use PHPStan\PhpDocParser\Ast\ConstExpr\ConstExprIntegerNode;
 use PHPStan\PhpDocParser\Ast\ConstExpr\ConstFetchNode;
 use PHPStan\PhpDocParser\Ast\ConstExpr\QuoteAwareConstExprStringNode;
+use PHPStan\PhpDocParser\Ast\Node;
 use PHPStan\PhpDocParser\Ast\Type\ArrayShapeItemNode;
 use PHPStan\PhpDocParser\Ast\Type\ArrayShapeNode;
 use PHPStan\PhpDocParser\Ast\Type\ArrayTypeNode;
@@ -2006,11 +2007,73 @@ static function (TypeNode $typeNode): TypeNode {
 				],
 			],
 		];
+
+		yield [
+			'callable(Foo, Bar): void',
+			[
+				[
+					static function (TypeNode $typeNode): TypeNode {
+						return $typeNode;
+					},
+					'callable(Foo, Bar): void',
+					1,
+					1,
+					0,
+					9,
+				],
+				[
+					static function (CallableTypeNode $typeNode): TypeNode {
+						return $typeNode->identifier;
+					},
+					'callable',
+					1,
+					1,
+					0,
+					0,
+				],
+				[
+					static function (CallableTypeNode $typeNode): Node {
+						return $typeNode->parameters[0];
+					},
+					'Foo',
+					1,
+					1,
+					2,
+					2,
+				],
+				[
+					static function (CallableTypeNode $typeNode): TypeNode {
+						return $typeNode->returnType;
+					},
+					'void',
+					1,
+					1,
+					9,
+					9,
+				],
+			],
+		];
+
+		yield [
+			'$this',
+			[
+				[
+					static function (TypeNode $typeNode): TypeNode {
+						return $typeNode;
+					},
+					'$this',
+					1,
+					1,
+					0,
+					0,
+				],
+			],
+		];
 	}
 
 	/**
 	 * @dataProvider dataLinesAndIndexes
-	 * @param list<array{callable(TypeNode): TypeNode, string, int, int, int, int}> $assertions
+	 * @param list<array{callable(Node): Node, string, int, int, int, int}> $assertions
 	 */
 	public function testLinesAndIndexes(string $input, array $assertions): void
 	{
@@ -2025,16 +2088,16 @@ public function testLinesAndIndexes(string $input, array $assertions): void
 		foreach ($assertions as [$callable, $expectedContent, $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));
+
 			$content = '';
 			for ($i = $startIndex; $i <= $endIndex; $i++) {
 				$content .= $tokensArray[$i][Lexer::VALUE_OFFSET];
 			}
-
 			$this->assertSame($expectedContent, $content);
-			$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));
 		}
 	}