composer local test update

vendor/phpstan/phpdoc-parser/README.md

@@ -15,6 +15,8 @@ For the complete list of supported PHPDoc features check out PHPStan documentati
 * [PHPDoc Types](https://phpstan.org/writing-php-code/phpdoc-types) (list of PHPDoc types)
 * [phpdoc-parser API Reference](https://phpstan.github.io/phpdoc-parser/namespace-PHPStan.PhpDocParser.html) with all the AST node types etc.
 
+This parser also supports parsing [Doctrine Annotations](https://github.com/doctrine/annotations). The AST nodes live in the [PHPStan\PhpDocParser\Ast\PhpDoc\Doctrine namespace](https://phpstan.github.io/phpdoc-parser/namespace-PHPStan.PhpDocParser.Ast.PhpDoc.Doctrine.html). The support needs to be turned on by setting `bool $parseDoctrineAnnotations` to `true` in `Lexer` and `PhpDocParser` class constructors.
+
 ## Installation
 
 ```

vendor/phpstan/phpdoc-parser/composer.json

@@ -6,6 +6,7 @@
 		"php": "^7.2 || ^8.0"
 	},
 	"require-dev": {
+		"doctrine/annotations": "^2.0",
 		"nikic/php-parser": "^4.15",
 		"php-parallel-lint/php-parallel-lint": "^1.2",
 		"phpstan/extension-installer": "^1.0",

vendor/phpstan/phpdoc-parser/src/Ast/ConstExpr/DoctrineConstExprStringNode.php

@@ -0,0 +1,42 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\PhpDocParser\Ast\ConstExpr;
+
+use PHPStan\PhpDocParser\Ast\NodeAttributes;
+use function sprintf;
+use function str_replace;
+use function strlen;
+use function substr;
+
+class DoctrineConstExprStringNode extends ConstExprStringNode
+{
+
+	use NodeAttributes;
+
+	/** @var string */
+	public $value;
+
+	public function __construct(string $value)
+	{
+		parent::__construct($value);
+		$this->value = $value;
+	}
+
+	public function __toString(): string
+	{
+		return self::escape($this->value);
+	}
+
+	public static function unescape(string $value): string
+	{
+		// from https://github.com/doctrine/annotations/blob/a9ec7af212302a75d1f92fa65d3abfbd16245a2a/lib/Doctrine/Common/Annotations/DocLexer.php#L103-L107
+		return str_replace('""', '"', substr($value, 1, strlen($value) - 2));
+	}
+
+	private static function escape(string $value): string
+	{
+		// from https://github.com/phpstan/phpdoc-parser/issues/205#issuecomment-1662323656
+		return sprintf('"%s"', str_replace('"', '""', $value));
+	}
+
+}

vendor/phpstan/phpdoc-parser/src/Ast/PhpDoc/Doctrine/DoctrineAnnotation.php

@@ -0,0 +1,35 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\PhpDocParser\Ast\PhpDoc\Doctrine;
+
+use PHPStan\PhpDocParser\Ast\Node;
+use PHPStan\PhpDocParser\Ast\NodeAttributes;
+use function implode;
+
+class DoctrineAnnotation implements Node
+{
+
+	use NodeAttributes;
+
+	/** @var string */
+	public $name;
+
+	/** @var list<DoctrineArgument> */
+	public $arguments;
+
+	/**
+	 * @param list<DoctrineArgument> $arguments
+	 */
+	public function __construct(string $name, array $arguments)
+	{
+		$this->name = $name;
+		$this->arguments = $arguments;
+	}
+
+	public function __toString(): string
+	{
+		$arguments = implode(', ', $this->arguments);
+		return $this->name . '(' . $arguments . ')';
+	}
+
+}

vendor/phpstan/phpdoc-parser/src/Ast/PhpDoc/Doctrine/DoctrineArgument.php

@@ -0,0 +1,43 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\PhpDocParser\Ast\PhpDoc\Doctrine;
+
+use PHPStan\PhpDocParser\Ast\ConstExpr\ConstExprNode;
+use PHPStan\PhpDocParser\Ast\Node;
+use PHPStan\PhpDocParser\Ast\NodeAttributes;
+use PHPStan\PhpDocParser\Ast\Type\IdentifierTypeNode;
+
+/**
+ * @phpstan-type ValueType = DoctrineAnnotation|IdentifierTypeNode|DoctrineArray|ConstExprNode
+ */
+class DoctrineArgument implements Node
+{
+
+	use NodeAttributes;
+
+	/** @var IdentifierTypeNode|null */
+	public $key;
+
+	/** @var ValueType */
+	public $value;
+
+	/**
+	 * @param ValueType $value
+	 */
+	public function __construct(?IdentifierTypeNode $key, $value)
+	{
+		$this->key = $key;
+		$this->value = $value;
+	}
+
+
+	public function __toString(): string
+	{
+		if ($this->key === null) {
+			return (string) $this->value;
+		}
+
+		return $this->key . '=' . $this->value;
+	}
+
+}

vendor/phpstan/phpdoc-parser/src/Ast/PhpDoc/Doctrine/DoctrineArray.php

@@ -0,0 +1,32 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\PhpDocParser\Ast\PhpDoc\Doctrine;
+
+use PHPStan\PhpDocParser\Ast\Node;
+use PHPStan\PhpDocParser\Ast\NodeAttributes;
+use function implode;
+
+class DoctrineArray implements Node
+{
+
+	use NodeAttributes;
+
+	/** @var list<DoctrineArrayItem> */
+	public $items;
+
+	/**
+	 * @param list<DoctrineArrayItem> $items
+	 */
+	public function __construct(array $items)
+	{
+		$this->items = $items;
+	}
+
+	public function __toString(): string
+	{
+		$items = implode(', ', $this->items);
+
+		return '{' . $items . '}';
+	}
+
+}

vendor/phpstan/phpdoc-parser/src/Ast/PhpDoc/Doctrine/DoctrineArrayItem.php

@@ -0,0 +1,47 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\PhpDocParser\Ast\PhpDoc\Doctrine;
+
+use PHPStan\PhpDocParser\Ast\ConstExpr\ConstExprIntegerNode;
+use PHPStan\PhpDocParser\Ast\ConstExpr\ConstExprStringNode;
+use PHPStan\PhpDocParser\Ast\ConstExpr\ConstFetchNode;
+use PHPStan\PhpDocParser\Ast\Node;
+use PHPStan\PhpDocParser\Ast\NodeAttributes;
+use PHPStan\PhpDocParser\Ast\Type\IdentifierTypeNode;
+
+/**
+ * @phpstan-import-type ValueType from DoctrineArgument
+ * @phpstan-type KeyType = ConstExprIntegerNode|ConstExprStringNode|IdentifierTypeNode|ConstFetchNode|null
+ */
+class DoctrineArrayItem implements Node
+{
+
+	use NodeAttributes;
+
+	/** @var KeyType */
+	public $key;
+
+	/** @var ValueType */
+	public $value;
+
+	/**
+	 * @param KeyType $key
+	 * @param ValueType $value
+	 */
+	public function __construct($key, $value)
+	{
+		$this->key = $key;
+		$this->value = $value;
+	}
+
+
+	public function __toString(): string
+	{
+		if ($this->key === null) {
+			return (string) $this->value;
+		}
+
+		return $this->key . '=' . $this->value;
+	}
+
+}

vendor/phpstan/phpdoc-parser/src/Ast/PhpDoc/Doctrine/DoctrineTagValueNode.php

@@ -0,0 +1,36 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\PhpDocParser\Ast\PhpDoc\Doctrine;
+
+use PHPStan\PhpDocParser\Ast\NodeAttributes;
+use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocTagValueNode;
+use function trim;
+
+class DoctrineTagValueNode implements PhpDocTagValueNode
+{
+
+	use NodeAttributes;
+
+	/** @var DoctrineAnnotation */
+	public $annotation;
+
+	/** @var string (may be empty) */
+	public $description;
+
+
+	public function __construct(
+		DoctrineAnnotation $annotation,
+		string $description
+	)
+	{
+		$this->annotation = $annotation;
+		$this->description = $description;
+	}
+
+
+	public function __toString(): string
+	{
+		return trim("{$this->annotation} {$this->description}");
+	}
+
+}

vendor/phpstan/phpdoc-parser/src/Ast/PhpDoc/PhpDocTagNode.php

@@ -3,6 +3,7 @@
 namespace PHPStan\PhpDocParser\Ast\PhpDoc;
 
 use PHPStan\PhpDocParser\Ast\NodeAttributes;
+use PHPStan\PhpDocParser\Ast\PhpDoc\Doctrine\DoctrineTagValueNode;
 use function trim;
 
 class PhpDocTagNode implements PhpDocChildNode
@@ -25,6 +26,10 @@ class PhpDocTagNode implements PhpDocChildNode
 
 	public function __toString(): string
 	{
+		if ($this->value instanceof DoctrineTagValueNode) {
+			return (string) $this->value;
+		}
+
 		return trim("{$this->name} {$this->value}");
 	}
 

vendor/phpstan/phpdoc-parser/src/Lexer/Lexer.php

@@ -30,23 +30,25 @@ class Lexer
 	public const TOKEN_OPEN_PHPDOC = 15;
 	public const TOKEN_CLOSE_PHPDOC = 16;
 	public const TOKEN_PHPDOC_TAG = 17;
-	public const TOKEN_FLOAT = 18;
-	public const TOKEN_INTEGER = 19;
-	public const TOKEN_SINGLE_QUOTED_STRING = 20;
-	public const TOKEN_DOUBLE_QUOTED_STRING = 21;
-	public const TOKEN_IDENTIFIER = 22;
-	public const TOKEN_THIS_VARIABLE = 23;
-	public const TOKEN_VARIABLE = 24;
-	public const TOKEN_HORIZONTAL_WS = 25;
-	public const TOKEN_PHPDOC_EOL = 26;
-	public const TOKEN_OTHER = 27;
-	public const TOKEN_END = 28;
-	public const TOKEN_COLON = 29;
-	public const TOKEN_WILDCARD = 30;
-	public const TOKEN_OPEN_CURLY_BRACKET = 31;
-	public const TOKEN_CLOSE_CURLY_BRACKET = 32;
-	public const TOKEN_NEGATED = 33;
-	public const TOKEN_ARROW = 34;
+	public const TOKEN_DOCTRINE_TAG = 18;
+	public const TOKEN_FLOAT = 19;
+	public const TOKEN_INTEGER = 20;
+	public const TOKEN_SINGLE_QUOTED_STRING = 21;
+	public const TOKEN_DOUBLE_QUOTED_STRING = 22;
+	public const TOKEN_DOCTRINE_ANNOTATION_STRING = 23;
+	public const TOKEN_IDENTIFIER = 24;
+	public const TOKEN_THIS_VARIABLE = 25;
+	public const TOKEN_VARIABLE = 26;
+	public const TOKEN_HORIZONTAL_WS = 27;
+	public const TOKEN_PHPDOC_EOL = 28;
+	public const TOKEN_OTHER = 29;
+	public const TOKEN_END = 30;
+	public const TOKEN_COLON = 31;
+	public const TOKEN_WILDCARD = 32;
+	public const TOKEN_OPEN_CURLY_BRACKET = 33;
+	public const TOKEN_CLOSE_CURLY_BRACKET = 34;
+	public const TOKEN_NEGATED = 35;
+	public const TOKEN_ARROW = 36;
 
 	public const TOKEN_LABELS = [
 		self::TOKEN_REFERENCE => '\'&\'',
@@ -72,11 +74,13 @@ class Lexer
 		self::TOKEN_OPEN_PHPDOC => '\'/**\'',
 		self::TOKEN_CLOSE_PHPDOC => '\'*/\'',
 		self::TOKEN_PHPDOC_TAG => 'TOKEN_PHPDOC_TAG',
+		self::TOKEN_DOCTRINE_TAG => 'TOKEN_DOCTRINE_TAG',
 		self::TOKEN_PHPDOC_EOL => 'TOKEN_PHPDOC_EOL',
 		self::TOKEN_FLOAT => 'TOKEN_FLOAT',
 		self::TOKEN_INTEGER => 'TOKEN_INTEGER',
 		self::TOKEN_SINGLE_QUOTED_STRING => 'TOKEN_SINGLE_QUOTED_STRING',
 		self::TOKEN_DOUBLE_QUOTED_STRING => 'TOKEN_DOUBLE_QUOTED_STRING',
+		self::TOKEN_DOCTRINE_ANNOTATION_STRING => 'TOKEN_DOCTRINE_ANNOTATION_STRING',
 		self::TOKEN_IDENTIFIER => 'type',
 		self::TOKEN_THIS_VARIABLE => '\'$this\'',
 		self::TOKEN_VARIABLE => 'variable',
@@ -90,9 +94,17 @@ class Lexer
 	public const TYPE_OFFSET = 1;
 	public const LINE_OFFSET = 2;
 
+	/** @var bool */
+	private $parseDoctrineAnnotations;
+
 	/** @var string|null */
 	private $regexp;
 
+	public function __construct(bool $parseDoctrineAnnotations = false)
+	{
+		$this->parseDoctrineAnnotations = $parseDoctrineAnnotations;
+	}
+
 	/**
 	 * @return list<array{string, int, int}>
 	 */
@@ -160,17 +172,22 @@ class Lexer
 			self::TOKEN_PHPDOC_TAG => '@(?:[a-z][a-z0-9-\\\\]+:)?[a-z][a-z0-9-\\\\]*+',
 			self::TOKEN_PHPDOC_EOL => '\\r?+\\n[\\x09\\x20]*+(?:\\*(?!/)\\x20?+)?',
 
-			self::TOKEN_FLOAT => '(?:-?[0-9]++(_[0-9]++)*\\.[0-9]*(_[0-9]++)*+(?:e-?[0-9]++(_[0-9]++)*)?)|(?:-?[0-9]*+(_[0-9]++)*\\.[0-9]++(_[0-9]++)*(?:e-?[0-9]++(_[0-9]++)*)?)|(?:-?[0-9]++(_[0-9]++)*e-?[0-9]++(_[0-9]++)*)',
-			self::TOKEN_INTEGER => '-?(?:(?:0b[0-1]++(_[0-1]++)*)|(?:0o[0-7]++(_[0-7]++)*)|(?:0x[0-9a-f]++(_[0-9a-f]++)*)|(?:[0-9]++(_[0-9]++)*))',
+			self::TOKEN_FLOAT => '[+\-]?(?:(?:[0-9]++(_[0-9]++)*\\.[0-9]*+(_[0-9]++)*(?:e[+\-]?[0-9]++(_[0-9]++)*)?)|(?:[0-9]*+(_[0-9]++)*\\.[0-9]++(_[0-9]++)*(?:e[+\-]?[0-9]++(_[0-9]++)*)?)|(?:[0-9]++(_[0-9]++)*e[+\-]?[0-9]++(_[0-9]++)*))',
+			self::TOKEN_INTEGER => '[+\-]?(?:(?:0b[0-1]++(_[0-1]++)*)|(?:0o[0-7]++(_[0-7]++)*)|(?:0x[0-9a-f]++(_[0-9a-f]++)*)|(?:[0-9]++(_[0-9]++)*))',
 			self::TOKEN_SINGLE_QUOTED_STRING => '\'(?:\\\\[^\\r\\n]|[^\'\\r\\n\\\\])*+\'',
 			self::TOKEN_DOUBLE_QUOTED_STRING => '"(?:\\\\[^\\r\\n]|[^"\\r\\n\\\\])*+"',
 
 			self::TOKEN_WILDCARD => '\\*',
-
-			// anything but TOKEN_CLOSE_PHPDOC or TOKEN_HORIZONTAL_WS or TOKEN_EOL
-			self::TOKEN_OTHER => '(?:(?!\\*/)[^\\s])++',
 		];
 
+		if ($this->parseDoctrineAnnotations) {
+			$patterns[self::TOKEN_DOCTRINE_TAG] = '@[a-z_\\\\][a-z0-9_\:\\\\]*[a-z_][a-z0-9_]*';
+			$patterns[self::TOKEN_DOCTRINE_ANNOTATION_STRING] = '"(?:""|[^"])*+"';
+		}
+
+		// anything but TOKEN_CLOSE_PHPDOC or TOKEN_HORIZONTAL_WS or TOKEN_EOL
+		$patterns[self::TOKEN_OTHER] = '(?:(?!\\*/)[^\\s])++';
+
 		foreach ($patterns as $type => &$pattern) {
 			$pattern = '(?:' . $pattern . ')(*MARK:' . $type . ')';
 		}

vendor/phpstan/phpdoc-parser/src/Parser/ConstExprParser.php

@@ -23,6 +23,9 @@ class ConstExprParser
 	/** @var bool */
 	private $useIndexAttributes;
 
+	/** @var bool */
+	private $parseDoctrineStrings;
+
 	/**
 	 * @param array{lines?: bool, indexes?: bool} $usedAttributes
 	 */
@@ -36,6 +39,24 @@ class ConstExprParser
 		$this->quoteAwareConstExprString = $quoteAwareConstExprString;
 		$this->useLinesAttributes = $usedAttributes['lines'] ?? false;
 		$this->useIndexAttributes = $usedAttributes['indexes'] ?? false;
+		$this->parseDoctrineStrings = false;
+	}
+
+	/**
+	 * @internal
+	 */
+	public function toDoctrine(): self
+	{
+		$self = new self(
+			$this->unescapeStrings,
+			$this->quoteAwareConstExprString,
+			[
+				'lines' => $this->useLinesAttributes,
+				'indexes' => $this->useIndexAttributes,
+			]
+		);
+		$self->parseDoctrineStrings = true;
+		return $self;
 	}
 
 	public function parse(TokenIterator $tokens, bool $trimStrings = false): Ast\ConstExpr\ConstExprNode
@@ -66,7 +87,41 @@ class ConstExprParser
 			);
 		}
 
+		if ($this->parseDoctrineStrings && $tokens->isCurrentTokenType(Lexer::TOKEN_DOCTRINE_ANNOTATION_STRING)) {
+			$value = $tokens->currentTokenValue();
+			$tokens->next();
+
+			return $this->enrichWithAttributes(
+				$tokens,
+				new Ast\ConstExpr\DoctrineConstExprStringNode(Ast\ConstExpr\DoctrineConstExprStringNode::unescape($value)),
+				$startLine,
+				$startIndex
+			);
+		}
+
 		if ($tokens->isCurrentTokenType(Lexer::TOKEN_SINGLE_QUOTED_STRING, Lexer::TOKEN_DOUBLE_QUOTED_STRING)) {
+			if ($this->parseDoctrineStrings) {
+				if ($tokens->isCurrentTokenType(Lexer::TOKEN_SINGLE_QUOTED_STRING)) {
+					throw new ParserException(
+						$tokens->currentTokenValue(),
+						$tokens->currentTokenType(),
+						$tokens->currentTokenOffset(),
+						Lexer::TOKEN_DOUBLE_QUOTED_STRING,
+						null,
+						$tokens->currentTokenLine()
+					);
+				}
+
+				$value = $tokens->currentTokenValue();
+				$tokens->next();
+
+				return $this->enrichWithAttributes(
+					$tokens,
+					$this->parseDoctrineString($value, $tokens),
+					$startLine,
+					$startIndex
+				);
+			}
 			$value = $tokens->currentTokenValue();
 			$type = $tokens->currentTokenType();
 			if ($trimStrings) {
@@ -214,6 +269,23 @@ class ConstExprParser
 	}
 
 
+	/**
+	 * This method is supposed to be called with TokenIterator after reading TOKEN_DOUBLE_QUOTED_STRING and shifting
+	 * to the next token.
+	 */
+	public function parseDoctrineString(string $text, TokenIterator $tokens): Ast\ConstExpr\DoctrineConstExprStringNode
+	{
+		// Because of how Lexer works, a valid Doctrine string
+		// can consist of a sequence of TOKEN_DOUBLE_QUOTED_STRING and TOKEN_DOCTRINE_ANNOTATION_STRING
+		while ($tokens->isCurrentTokenType(Lexer::TOKEN_DOUBLE_QUOTED_STRING, Lexer::TOKEN_DOCTRINE_ANNOTATION_STRING)) {
+			$text .= $tokens->currentTokenValue();
+			$tokens->next();
+		}
+
+		return new Ast\ConstExpr\DoctrineConstExprStringNode(Ast\ConstExpr\DoctrineConstExprStringNode::unescape($text));
+	}
+
+
 	private function parseArrayItem(TokenIterator $tokens): Ast\ConstExpr\ConstExprArrayItemNode
 	{
 		$startLine = $tokens->currentTokenLine();
@@ -245,22 +317,14 @@ class ConstExprParser
 	 */
 	private function enrichWithAttributes(TokenIterator $tokens, Ast\ConstExpr\ConstExprNode $node, int $startLine, int $startIndex): Ast\ConstExpr\ConstExprNode
 	{
-		$endLine = $tokens->currentTokenLine();
-		$endIndex = $tokens->currentTokenIndex();
 		if ($this->useLinesAttributes) {
 			$node->setAttribute(Ast\Attribute::START_LINE, $startLine);
-			$node->setAttribute(Ast\Attribute::END_LINE, $endLine);
+			$node->setAttribute(Ast\Attribute::END_LINE, $tokens->currentTokenLine());
 		}
 
 		if ($this->useIndexAttributes) {
-			$tokensArray = $tokens->getTokens();
-			$endIndex--;
-			if ($tokensArray[$endIndex][Lexer::TYPE_OFFSET] === Lexer::TOKEN_HORIZONTAL_WS) {
-				$endIndex--;
-			}
-
 			$node->setAttribute(Ast\Attribute::START_INDEX, $startIndex);
-			$node->setAttribute(Ast\Attribute::END_INDEX, $endIndex);
+			$node->setAttribute(Ast\Attribute::END_INDEX, $tokens->endIndexOfLastRelevantToken());
 		}
 
 		return $node;

vendor/phpstan/phpdoc-parser/src/Parser/PhpDocParser.php

@@ -2,15 +2,25 @@
 
 namespace PHPStan\PhpDocParser\Parser;
 
+use LogicException;
 use PHPStan\PhpDocParser\Ast;
+use PHPStan\PhpDocParser\Ast\ConstExpr\ConstExprIntegerNode;
+use PHPStan\PhpDocParser\Ast\ConstExpr\ConstExprStringNode;
+use PHPStan\PhpDocParser\Ast\ConstExpr\ConstFetchNode;
+use PHPStan\PhpDocParser\Ast\PhpDoc\Doctrine;
 use PHPStan\PhpDocParser\Ast\Type\IdentifierTypeNode;
 use PHPStan\PhpDocParser\Lexer\Lexer;
 use PHPStan\ShouldNotHappenException;
 use function array_key_exists;
 use function array_values;
 use function count;
+use function rtrim;
+use function str_replace;
 use function trim;
 
+/**
+ * @phpstan-import-type ValueType from Doctrine\DoctrineArgument as DoctrineValueType
+ */
 class PhpDocParser
 {
 
@@ -25,18 +35,27 @@ class PhpDocParser
 	/** @var ConstExprParser */
 	private $constantExprParser;
 
+	/** @var ConstExprParser */
+	private $doctrineConstantExprParser;
+
 	/** @var bool */
 	private $requireWhitespaceBeforeDescription;
 
 	/** @var bool */
 	private $preserveTypeAliasesWithInvalidTypes;
 
+	/** @var bool */
+	private $parseDoctrineAnnotations;
+
 	/** @var bool */
 	private $useLinesAttributes;
 
 	/** @var bool */
 	private $useIndexAttributes;
 
+	/** @var bool */
+	private $textBetweenTagsBelongsToDescription;
+
 	/**
 	 * @param array{lines?: bool, indexes?: bool} $usedAttributes
 	 */
@@ -45,15 +64,20 @@ class PhpDocParser
 		ConstExprParser $constantExprParser,
 		bool $requireWhitespaceBeforeDescription = false,
 		bool $preserveTypeAliasesWithInvalidTypes = false,
-		array $usedAttributes = []
+		array $usedAttributes = [],
+		bool $parseDoctrineAnnotations = false,
+		bool $textBetweenTagsBelongsToDescription = false
 	)
 	{
 		$this->typeParser = $typeParser;
 		$this->constantExprParser = $constantExprParser;
+		$this->doctrineConstantExprParser = $constantExprParser->toDoctrine();
 		$this->requireWhitespaceBeforeDescription = $requireWhitespaceBeforeDescription;
 		$this->preserveTypeAliasesWithInvalidTypes = $preserveTypeAliasesWithInvalidTypes;
+		$this->parseDoctrineAnnotations = $parseDoctrineAnnotations;
 		$this->useLinesAttributes = $usedAttributes['lines'] ?? false;
 		$this->useIndexAttributes = $usedAttributes['indexes'] ?? false;
+		$this->textBetweenTagsBelongsToDescription = $textBetweenTagsBelongsToDescription;
 	}
 
 
@@ -64,10 +88,44 @@ class PhpDocParser
 
 		$children = [];
 
-		if (!$tokens->isCurrentTokenType(Lexer::TOKEN_CLOSE_PHPDOC)) {
-			$children[] = $this->parseChild($tokens);
-			while ($tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL) && !$tokens->isCurrentTokenType(Lexer::TOKEN_CLOSE_PHPDOC)) {
+		if ($this->parseDoctrineAnnotations) {
+			if (!$tokens->isCurrentTokenType(Lexer::TOKEN_CLOSE_PHPDOC)) {
+				$lastChild = $this->parseChild($tokens);
+				$children[] = $lastChild;
+				while (!$tokens->isCurrentTokenType(Lexer::TOKEN_CLOSE_PHPDOC)) {
+					if (
+						$lastChild instanceof Ast\PhpDoc\PhpDocTagNode
+						&& (
+							$lastChild->value instanceof Doctrine\DoctrineTagValueNode
+							|| $lastChild->value instanceof Ast\PhpDoc\GenericTagValueNode
+						)
+					) {
+						$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
+						if ($tokens->isCurrentTokenType(Lexer::TOKEN_CLOSE_PHPDOC)) {
+							break;
+						}
+						$lastChild = $this->parseChild($tokens);
+						$children[] = $lastChild;
+						continue;
+					}
+
+					if (!$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL)) {
+						break;
+					}
+					if ($tokens->isCurrentTokenType(Lexer::TOKEN_CLOSE_PHPDOC)) {
+						break;
+					}
+
+					$lastChild = $this->parseChild($tokens);
+					$children[] = $lastChild;
+				}
+			}
+		} else {
+			if (!$tokens->isCurrentTokenType(Lexer::TOKEN_CLOSE_PHPDOC)) {
 				$children[] = $this->parseChild($tokens);
+				while ($tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL) && !$tokens->isCurrentTokenType(Lexer::TOKEN_CLOSE_PHPDOC)) {
+					$children[] = $this->parseChild($tokens);
+				}
 			}
 		}
 
@@ -105,6 +163,7 @@ class PhpDocParser
 	}
 
 
+	/** @phpstan-impure */
 	private function parseChild(TokenIterator $tokens): Ast\PhpDoc\PhpDocChildNode
 	{
 		if ($tokens->isCurrentTokenType(Lexer::TOKEN_PHPDOC_TAG)) {
@@ -113,6 +172,26 @@ class PhpDocParser
 			return $this->enrichWithAttributes($tokens, $this->parseTag($tokens), $startLine, $startIndex);
 		}
 
+		if ($tokens->isCurrentTokenType(Lexer::TOKEN_DOCTRINE_TAG)) {
+			$startLine = $tokens->currentTokenLine();
+			$startIndex = $tokens->currentTokenIndex();
+			$tag = $tokens->currentTokenValue();
+			$tokens->next();
+
+			$tagStartLine = $tokens->currentTokenLine();
+			$tagStartIndex = $tokens->currentTokenIndex();
+
+			return $this->enrichWithAttributes($tokens, new Ast\PhpDoc\PhpDocTagNode(
+				$tag,
+				$this->enrichWithAttributes(
+					$tokens,
+					$this->parseDoctrineTagValue($tokens, $tag),
+					$tagStartLine,
+					$tagStartIndex
+				)
+			), $startLine, $startIndex);
+		}
+
 		$startLine = $tokens->currentTokenLine();
 		$startIndex = $tokens->currentTokenIndex();
 		$text = $this->parseText($tokens);
@@ -127,23 +206,14 @@ class PhpDocParser
 	 */
 	private function enrichWithAttributes(TokenIterator $tokens, Ast\Node $tag, int $startLine, int $startIndex): Ast\Node
 	{
-		$endLine = $tokens->currentTokenLine();
-		$endIndex = $tokens->currentTokenIndex();
-
 		if ($this->useLinesAttributes) {
 			$tag->setAttribute(Ast\Attribute::START_LINE, $startLine);
-			$tag->setAttribute(Ast\Attribute::END_LINE, $endLine);
+			$tag->setAttribute(Ast\Attribute::END_LINE, $tokens->currentTokenLine());
 		}
 
 		if ($this->useIndexAttributes) {
-			$tokensArray = $tokens->getTokens();
-			$endIndex--;
-			if ($tokensArray[$endIndex][Lexer::TYPE_OFFSET] === Lexer::TOKEN_HORIZONTAL_WS) {
-				$endIndex--;
-			}
-
 			$tag->setAttribute(Ast\Attribute::START_INDEX, $startIndex);
-			$tag->setAttribute(Ast\Attribute::END_INDEX, $endIndex);
+			$tag->setAttribute(Ast\Attribute::END_INDEX, $tokens->endIndexOfLastRelevantToken());
 		}
 
 		return $tag;
@@ -154,29 +224,144 @@ class PhpDocParser
 	{
 		$text = '';
 
-		while (!$tokens->isCurrentTokenType(Lexer::TOKEN_PHPDOC_EOL)) {
-			$text .= $tokens->getSkippedHorizontalWhiteSpaceIfAny() . $tokens->joinUntil(Lexer::TOKEN_PHPDOC_EOL, Lexer::TOKEN_CLOSE_PHPDOC, Lexer::TOKEN_END);
+		$endTokens = [Lexer::TOKEN_PHPDOC_EOL, Lexer::TOKEN_CLOSE_PHPDOC, Lexer::TOKEN_END];
+		if ($this->textBetweenTagsBelongsToDescription) {
+			$endTokens = [Lexer::TOKEN_CLOSE_PHPDOC, Lexer::TOKEN_END];
+		}
 
+		$savepoint = false;
+
+		// if the next token is EOL, everything below is skipped and empty string is returned
+		while ($this->textBetweenTagsBelongsToDescription || !$tokens->isCurrentTokenType(Lexer::TOKEN_PHPDOC_EOL)) {
+			$tmpText = $tokens->getSkippedHorizontalWhiteSpaceIfAny() . $tokens->joinUntil(Lexer::TOKEN_PHPDOC_EOL, ...$endTokens);
+			$text .= $tmpText;
+
+			// stop if we're not at EOL - meaning it's the end of PHPDoc
 			if (!$tokens->isCurrentTokenType(Lexer::TOKEN_PHPDOC_EOL)) {
 				break;
 			}
 
+			if ($this->textBetweenTagsBelongsToDescription) {
+				if (!$savepoint) {
+					$tokens->pushSavePoint();
+					$savepoint = true;
+				} elseif ($tmpText !== '') {
+					$tokens->dropSavePoint();
+					$tokens->pushSavePoint();
+				}
+			}
+
 			$tokens->pushSavePoint();
 			$tokens->next();
 
-			if ($tokens->isCurrentTokenType(Lexer::TOKEN_PHPDOC_TAG, Lexer::TOKEN_PHPDOC_EOL, Lexer::TOKEN_CLOSE_PHPDOC, Lexer::TOKEN_END)) {
+			// if we're at EOL, check what's next
+			// if next is a PHPDoc tag, EOL, or end of PHPDoc, stop
+			if ($tokens->isCurrentTokenType(Lexer::TOKEN_PHPDOC_TAG, Lexer::TOKEN_DOCTRINE_TAG, ...$endTokens)) {
 				$tokens->rollback();
 				break;
 			}
 
+			// otherwise if the next is text, continue building the description string
+
 			$tokens->dropSavePoint();
-			$text .= "\n";
+			$text .= $tokens->getDetectedNewline() ?? "\n";
+		}
+
+		if ($savepoint) {
+			$tokens->rollback();
+			$text = rtrim($text, $tokens->getDetectedNewline() ?? "\n");
 		}
 
 		return new Ast\PhpDoc\PhpDocTextNode(trim($text, " \t"));
 	}
 
 
+	private function parseOptionalDescriptionAfterDoctrineTag(TokenIterator $tokens): string
+	{
+		$text = '';
+
+		$endTokens = [Lexer::TOKEN_PHPDOC_EOL, Lexer::TOKEN_CLOSE_PHPDOC, Lexer::TOKEN_END];
+		if ($this->textBetweenTagsBelongsToDescription) {
+			$endTokens = [Lexer::TOKEN_CLOSE_PHPDOC, Lexer::TOKEN_END];
+		}
+
+		$savepoint = false;
+
+		// if the next token is EOL, everything below is skipped and empty string is returned
+		while ($this->textBetweenTagsBelongsToDescription || !$tokens->isCurrentTokenType(Lexer::TOKEN_PHPDOC_EOL)) {
+			$tmpText = $tokens->getSkippedHorizontalWhiteSpaceIfAny() . $tokens->joinUntil(Lexer::TOKEN_PHPDOC_TAG, Lexer::TOKEN_DOCTRINE_TAG, Lexer::TOKEN_PHPDOC_EOL, ...$endTokens);
+			$text .= $tmpText;
+
+			// stop if we're not at EOL - meaning it's the end of PHPDoc
+			if (!$tokens->isCurrentTokenType(Lexer::TOKEN_PHPDOC_EOL)) {
+				if (!$tokens->isPrecededByHorizontalWhitespace()) {
+					return trim($text . $this->parseText($tokens)->text, " \t");
+				}
+				if ($tokens->isCurrentTokenType(Lexer::TOKEN_PHPDOC_TAG)) {
+					$tokens->pushSavePoint();
+					$child = $this->parseChild($tokens);
+					if ($child instanceof Ast\PhpDoc\PhpDocTagNode) {
+						if (
+							$child->value instanceof Ast\PhpDoc\GenericTagValueNode
+							|| $child->value instanceof Doctrine\DoctrineTagValueNode
+						) {
+							$tokens->rollback();
+							break;
+						}
+						if ($child->value instanceof Ast\PhpDoc\InvalidTagValueNode) {
+							$tokens->rollback();
+							$tokens->pushSavePoint();
+							$tokens->next();
+							if ($tokens->isCurrentTokenType(Lexer::TOKEN_OPEN_PARENTHESES)) {
+								$tokens->rollback();
+								break;
+							}
+							$tokens->rollback();
+							return trim($text . $this->parseText($tokens)->text, " \t");
+						}
+					}
+
+					$tokens->rollback();
+					return trim($text . $this->parseText($tokens)->text, " \t");
+				}
+				break;
+			}
+
+			if ($this->textBetweenTagsBelongsToDescription) {
+				if (!$savepoint) {
+					$tokens->pushSavePoint();
+					$savepoint = true;
+				} elseif ($tmpText !== '') {
+					$tokens->dropSavePoint();
+					$tokens->pushSavePoint();
+				}
+			}
+
+			$tokens->pushSavePoint();
+			$tokens->next();
+
+			// if we're at EOL, check what's next
+			// if next is a PHPDoc tag, EOL, or end of PHPDoc, stop
+			if ($tokens->isCurrentTokenType(Lexer::TOKEN_PHPDOC_TAG, Lexer::TOKEN_DOCTRINE_TAG, ...$endTokens)) {
+				$tokens->rollback();
+				break;
+			}
+
+			// otherwise if the next is text, continue building the description string
+
+			$tokens->dropSavePoint();
+			$text .= $tokens->getDetectedNewline() ?? "\n";
+		}
+
+		if ($savepoint) {
+			$tokens->rollback();
+			$text = rtrim($text, $tokens->getDetectedNewline() ?? "\n");
+		}
+
+		return trim($text, " \t");
+	}
+
+
 	public function parseTag(TokenIterator $tokens): Ast\PhpDoc\PhpDocTagNode
 	{
 		$tag = $tokens->currentTokenValue();
@@ -308,7 +493,17 @@ class PhpDocParser
 					break;
 
 				default:
+					if ($this->parseDoctrineAnnotations) {
+						if ($tokens->isCurrentTokenType(Lexer::TOKEN_OPEN_PARENTHESES)) {
+							$tagValue = $this->parseDoctrineTagValue($tokens, $tag);
+						} else {
+							$tagValue = new Ast\PhpDoc\GenericTagValueNode($this->parseOptionalDescriptionAfterDoctrineTag($tokens));
+						}
+						break;
+					}
+
 					$tagValue = new Ast\PhpDoc\GenericTagValueNode($this->parseOptionalDescription($tokens));
+
 					break;
 			}
 
@@ -323,6 +518,308 @@ class PhpDocParser
 	}
 
 
+	private function parseDoctrineTagValue(TokenIterator $tokens, string $tag): Ast\PhpDoc\PhpDocTagValueNode
+	{
+		$startLine = $tokens->currentTokenLine();
+		$startIndex = $tokens->currentTokenIndex();
+
+		return new Doctrine\DoctrineTagValueNode(
+			$this->enrichWithAttributes(
+				$tokens,
+				new Doctrine\DoctrineAnnotation($tag, $this->parseDoctrineArguments($tokens, false)),
+				$startLine,
+				$startIndex
+			),
+			$this->parseOptionalDescriptionAfterDoctrineTag($tokens)
+		);
+	}
+
+
+	/**
+	 * @return list<Doctrine\DoctrineArgument>
+	 */
+	private function parseDoctrineArguments(TokenIterator $tokens, bool $deep): array
+	{
+		if (!$tokens->isCurrentTokenType(Lexer::TOKEN_OPEN_PARENTHESES)) {
+			return [];
+		}
+
+		if (!$deep) {
+			$tokens->addEndOfLineToSkippedTokens();
+		}
+
+		$arguments = [];
+
+		try {
+			$tokens->consumeTokenType(Lexer::TOKEN_OPEN_PARENTHESES);
+
+			do {
+				if ($tokens->isCurrentTokenType(Lexer::TOKEN_CLOSE_PARENTHESES)) {
+					break;
+				}
+				$arguments[] = $this->parseDoctrineArgument($tokens);
+			} while ($tokens->tryConsumeTokenType(Lexer::TOKEN_COMMA));
+		} finally {
+			if (!$deep) {
+				$tokens->removeEndOfLineFromSkippedTokens();
+			}
+		}
+
+		$tokens->consumeTokenType(Lexer::TOKEN_CLOSE_PARENTHESES);
+
+		return $arguments;
+	}
+
+
+	private function parseDoctrineArgument(TokenIterator $tokens): Doctrine\DoctrineArgument
+	{
+		if (!$tokens->isCurrentTokenType(Lexer::TOKEN_IDENTIFIER)) {
+			$startLine = $tokens->currentTokenLine();
+			$startIndex = $tokens->currentTokenIndex();
+
+			return $this->enrichWithAttributes(
+				$tokens,
+				new Doctrine\DoctrineArgument(null, $this->parseDoctrineArgumentValue($tokens)),
+				$startLine,
+				$startIndex
+			);
+		}
+
+		$startLine = $tokens->currentTokenLine();
+		$startIndex = $tokens->currentTokenIndex();
+
+		try {
+			$tokens->pushSavePoint();
+			$currentValue = $tokens->currentTokenValue();
+			$tokens->consumeTokenType(Lexer::TOKEN_IDENTIFIER);
+
+			$key = $this->enrichWithAttributes(
+				$tokens,
+				new IdentifierTypeNode($currentValue),
+				$startLine,
+				$startIndex
+			);
+			$tokens->consumeTokenType(Lexer::TOKEN_EQUAL);
+
+			$value = $this->parseDoctrineArgumentValue($tokens);
+
+			$tokens->dropSavePoint();
+
+			return $this->enrichWithAttributes(
+				$tokens,
+				new Doctrine\DoctrineArgument($key, $value),
+				$startLine,
+				$startIndex
+			);
+		} catch (ParserException $e) {
+			$tokens->rollback();
+
+			return $this->enrichWithAttributes(
+				$tokens,
+				new Doctrine\DoctrineArgument(null, $this->parseDoctrineArgumentValue($tokens)),
+				$startLine,
+				$startIndex
+			);
+		}
+	}
+
+
+	/**
+	 * @return DoctrineValueType
+	 */
+	private function parseDoctrineArgumentValue(TokenIterator $tokens)
+	{
+		$startLine = $tokens->currentTokenLine();
+		$startIndex = $tokens->currentTokenIndex();
+
+		if ($tokens->isCurrentTokenType(Lexer::TOKEN_PHPDOC_TAG, Lexer::TOKEN_DOCTRINE_TAG)) {
+			$name = $tokens->currentTokenValue();
+			$tokens->next();
+
+			return $this->enrichWithAttributes(
+				$tokens,
+				new Doctrine\DoctrineAnnotation($name, $this->parseDoctrineArguments($tokens, true)),
+				$startLine,
+				$startIndex
+			);
+		}
+
+		if ($tokens->tryConsumeTokenType(Lexer::TOKEN_OPEN_CURLY_BRACKET)) {
+			$items = [];
+			do {
+				if ($tokens->isCurrentTokenType(Lexer::TOKEN_CLOSE_CURLY_BRACKET)) {
+					break;
+				}
+				$items[] = $this->parseDoctrineArrayItem($tokens);
+			} while ($tokens->tryConsumeTokenType(Lexer::TOKEN_COMMA));
+
+			$tokens->consumeTokenType(Lexer::TOKEN_CLOSE_CURLY_BRACKET);
+
+			return $this->enrichWithAttributes(
+				$tokens,
+				new Doctrine\DoctrineArray($items),
+				$startLine,
+				$startIndex
+			);
+		}
+
+		$currentTokenValue = $tokens->currentTokenValue();
+		$tokens->pushSavePoint(); // because of ConstFetchNode
+		if ($tokens->tryConsumeTokenType(Lexer::TOKEN_IDENTIFIER)) {
+			$identifier = $this->enrichWithAttributes(
+				$tokens,
+				new Ast\Type\IdentifierTypeNode($currentTokenValue),
+				$startLine,
+				$startIndex
+			);
+			if (!$tokens->isCurrentTokenType(Lexer::TOKEN_DOUBLE_COLON)) {
+				$tokens->dropSavePoint();
+				return $identifier;
+			}
+
+			$tokens->rollback(); // because of ConstFetchNode
+		} else {
+			$tokens->dropSavePoint(); // because of ConstFetchNode
+		}
+
+		$currentTokenValue = $tokens->currentTokenValue();
+		$currentTokenType = $tokens->currentTokenType();
+		$currentTokenOffset = $tokens->currentTokenOffset();
+		$currentTokenLine = $tokens->currentTokenLine();
+
+		try {
+			$constExpr = $this->doctrineConstantExprParser->parse($tokens, true);
+			if ($constExpr instanceof Ast\ConstExpr\ConstExprArrayNode) {
+				throw new ParserException(
+					$currentTokenValue,
+					$currentTokenType,
+					$currentTokenOffset,
+					Lexer::TOKEN_IDENTIFIER,
+					null,
+					$currentTokenLine
+				);
+			}
+
+			return $constExpr;
+		} catch (LogicException $e) {
+			throw new ParserException(
+				$currentTokenValue,
+				$currentTokenType,
+				$currentTokenOffset,
+				Lexer::TOKEN_IDENTIFIER,
+				null,
+				$currentTokenLine
+			);
+		}
+	}
+
+
+	private function parseDoctrineArrayItem(TokenIterator $tokens): Doctrine\DoctrineArrayItem
+	{
+		$startLine = $tokens->currentTokenLine();
+		$startIndex = $tokens->currentTokenIndex();
+
+		try {
+			$tokens->pushSavePoint();
+
+			$key = $this->parseDoctrineArrayKey($tokens);
+			if (!$tokens->tryConsumeTokenType(Lexer::TOKEN_EQUAL)) {
+				if (!$tokens->tryConsumeTokenType(Lexer::TOKEN_COLON)) {
+					$tokens->consumeTokenType(Lexer::TOKEN_EQUAL); // will throw exception
+				}
+			}
+
+			$value = $this->parseDoctrineArgumentValue($tokens);
+
+			$tokens->dropSavePoint();
+
+			return $this->enrichWithAttributes(
+				$tokens,
+				new Doctrine\DoctrineArrayItem($key, $value),
+				$startLine,
+				$startIndex
+			);
+		} catch (ParserException $e) {
+			$tokens->rollback();
+
+			return $this->enrichWithAttributes(
+				$tokens,
+				new Doctrine\DoctrineArrayItem(null, $this->parseDoctrineArgumentValue($tokens)),
+				$startLine,
+				$startIndex
+			);
+		}
+	}
+
+
+	/**
+	 * @return ConstExprIntegerNode|ConstExprStringNode|IdentifierTypeNode|ConstFetchNode
+	 */
+	private function parseDoctrineArrayKey(TokenIterator $tokens)
+	{
+		$startLine = $tokens->currentTokenLine();
+		$startIndex = $tokens->currentTokenIndex();
+
+		if ($tokens->isCurrentTokenType(Lexer::TOKEN_INTEGER)) {
+			$key = new Ast\ConstExpr\ConstExprIntegerNode(str_replace('_', '', $tokens->currentTokenValue()));
+			$tokens->next();
+
+		} elseif ($tokens->isCurrentTokenType(Lexer::TOKEN_DOCTRINE_ANNOTATION_STRING)) {
+			$key = new Ast\ConstExpr\DoctrineConstExprStringNode(Ast\ConstExpr\DoctrineConstExprStringNode::unescape($tokens->currentTokenValue()));
+
+			$tokens->next();
+
+		} elseif ($tokens->isCurrentTokenType(Lexer::TOKEN_DOUBLE_QUOTED_STRING)) {
+			$value = $tokens->currentTokenValue();
+			$tokens->next();
+			$key = $this->doctrineConstantExprParser->parseDoctrineString($value, $tokens);
+
+		} else {
+			$currentTokenValue = $tokens->currentTokenValue();
+			$tokens->pushSavePoint(); // because of ConstFetchNode
+			if (!$tokens->tryConsumeTokenType(Lexer::TOKEN_IDENTIFIER)) {
+				$tokens->dropSavePoint();
+				throw new ParserException(
+					$tokens->currentTokenValue(),
+					$tokens->currentTokenType(),
+					$tokens->currentTokenOffset(),
+					Lexer::TOKEN_IDENTIFIER,
+					null,
+					$tokens->currentTokenLine()
+				);
+			}
+
+			if (!$tokens->isCurrentTokenType(Lexer::TOKEN_DOUBLE_COLON)) {
+				$tokens->dropSavePoint();
+
+				return $this->enrichWithAttributes(
+					$tokens,
+					new IdentifierTypeNode($currentTokenValue),
+					$startLine,
+					$startIndex
+				);
+			}
+
+			$tokens->rollback();
+			$constExpr = $this->doctrineConstantExprParser->parse($tokens, true);
+			if (!$constExpr instanceof Ast\ConstExpr\ConstFetchNode) {
+				throw new ParserException(
+					$tokens->currentTokenValue(),
+					$tokens->currentTokenType(),
+					$tokens->currentTokenOffset(),
+					Lexer::TOKEN_IDENTIFIER,
+					null,
+					$tokens->currentTokenLine()
+				);
+			}
+
+			return $constExpr;
+		}
+
+		return $this->enrichWithAttributes($tokens, $key, $startLine, $startIndex);
+	}
+
+
 	/**
 	 * @return Ast\PhpDoc\ParamTagValueNode|Ast\PhpDoc\TypelessParamTagValueNode
 	 */
@@ -630,15 +1127,13 @@ class PhpDocParser
 	{
 		if ($tokens->isCurrentTokenType(Lexer::TOKEN_THIS_VARIABLE)) {
 			$parameter = '$this';
-			$requirePropertyOrMethod = true;
 			$tokens->next();
 		} else {
 			$parameter = $tokens->currentTokenValue();
-			$requirePropertyOrMethod = false;
 			$tokens->consumeTokenType(Lexer::TOKEN_VARIABLE);
 		}
 
-		if ($requirePropertyOrMethod || $tokens->isCurrentTokenType(Lexer::TOKEN_ARROW)) {
+		if ($tokens->isCurrentTokenType(Lexer::TOKEN_ARROW)) {
 			$tokens->consumeTokenType(Lexer::TOKEN_ARROW);
 
 			$propertyOrMethod = $tokens->currentTokenValue();

vendor/phpstan/phpdoc-parser/src/Parser/TokenIterator.php

@@ -9,6 +9,7 @@ use function assert;
 use function count;
 use function in_array;
 use function strlen;
+use function substr;
 
 class TokenIterator
 {
@@ -22,6 +23,12 @@ class TokenIterator
 	/** @var int[] */
 	private $savePoints = [];
 
+	/** @var list<int> */
+	private $skippedTokenTypes = [Lexer::TOKEN_HORIZONTAL_WS];
+
+	/** @var string|null */
+	private $newline = null;
+
 	/**
 	 * @param list<array{string, int, int}> $tokens
 	 */
@@ -30,11 +37,7 @@ class TokenIterator
 		$this->tokens = $tokens;
 		$this->index = $index;
 
-		if ($this->tokens[$this->index][Lexer::TYPE_OFFSET] !== Lexer::TOKEN_HORIZONTAL_WS) {
-			return;
-		}
-
-		$this->index++;
+		$this->skipIrrelevantTokens();
 	}
 
 
@@ -103,6 +106,21 @@ class TokenIterator
 	}
 
 
+	public function endIndexOfLastRelevantToken(): int
+	{
+		$endIndex = $this->currentTokenIndex();
+		$endIndex--;
+		while (in_array($this->tokens[$endIndex][Lexer::TYPE_OFFSET], $this->skippedTokenTypes, true)) {
+			if (!isset($this->tokens[$endIndex - 1])) {
+				break;
+			}
+			$endIndex--;
+		}
+
+		return $endIndex;
+	}
+
+
 	public function isCurrentTokenValue(string $tokenValue): bool
 	{
 		return $this->tokens[$this->index][Lexer::VALUE_OFFSET] === $tokenValue;
@@ -130,13 +148,14 @@ class TokenIterator
 			$this->throwError($tokenType);
 		}
 
-		$this->index++;
-
-		if (($this->tokens[$this->index][Lexer::TYPE_OFFSET] ?? -1) !== Lexer::TOKEN_HORIZONTAL_WS) {
-			return;
+		if ($tokenType === Lexer::TOKEN_PHPDOC_EOL) {
+			if ($this->newline === null) {
+				$this->detectNewline();
+			}
 		}
 
 		$this->index++;
+		$this->skipIrrelevantTokens();
 	}
 
 
@@ -150,12 +169,7 @@ class TokenIterator
 		}
 
 		$this->index++;
-
-		if (($this->tokens[$this->index][Lexer::TYPE_OFFSET] ?? -1) !== Lexer::TOKEN_HORIZONTAL_WS) {
-			return;
-		}
-
-		$this->index++;
+		$this->skipIrrelevantTokens();
 	}
 
 
@@ -167,10 +181,7 @@ class TokenIterator
 		}
 
 		$this->index++;
-
-		if ($this->tokens[$this->index][Lexer::TYPE_OFFSET] === Lexer::TOKEN_HORIZONTAL_WS) {
-			$this->index++;
-		}
+		$this->skipIrrelevantTokens();
 
 		return true;
 	}
@@ -183,16 +194,30 @@ class TokenIterator
 			return false;
 		}
 
-		$this->index++;
-
-		if ($this->tokens[$this->index][Lexer::TYPE_OFFSET] === Lexer::TOKEN_HORIZONTAL_WS) {
-			$this->index++;
+		if ($tokenType === Lexer::TOKEN_PHPDOC_EOL) {
+			if ($this->newline === null) {
+				$this->detectNewline();
+			}
 		}
 
+		$this->index++;
+		$this->skipIrrelevantTokens();
+
 		return true;
 	}
 
 
+	private function detectNewline(): void
+	{
+		$value = $this->currentTokenValue();
+		if (substr($value, 0, 2) === "\r\n") {
+			$this->newline = "\r\n";
+		} elseif (substr($value, 0, 1) === "\n") {
+			$this->newline = "\n";
+		}
+	}
+
+
 	public function getSkippedHorizontalWhiteSpaceIfAny(): string
 	{
 		if ($this->index > 0 && $this->tokens[$this->index - 1][Lexer::TYPE_OFFSET] === Lexer::TOKEN_HORIZONTAL_WS) {
@@ -217,12 +242,34 @@ class TokenIterator
 	public function next(): void
 	{
 		$this->index++;
+		$this->skipIrrelevantTokens();
+	}
 
-		if ($this->tokens[$this->index][Lexer::TYPE_OFFSET] !== Lexer::TOKEN_HORIZONTAL_WS) {
+
+	private function skipIrrelevantTokens(): void
+	{
+		if (!isset($this->tokens[$this->index])) {
 			return;
 		}
 
-		$this->index++;
+		while (in_array($this->tokens[$this->index][Lexer::TYPE_OFFSET], $this->skippedTokenTypes, true)) {
+			if (!isset($this->tokens[$this->index + 1])) {
+				break;
+			}
+			$this->index++;
+		}
+	}
+
+
+	public function addEndOfLineToSkippedTokens(): void
+	{
+		$this->skippedTokenTypes = [Lexer::TOKEN_HORIZONTAL_WS, Lexer::TOKEN_PHPDOC_EOL];
+	}
+
+
+	public function removeEndOfLineFromSkippedTokens(): void
+	{
+		$this->skippedTokenTypes = [Lexer::TOKEN_HORIZONTAL_WS];
 	}
 
 	/** @phpstan-impure */
@@ -319,6 +366,11 @@ class TokenIterator
 		return false;
 	}
 
+	public function getDetectedNewline(): ?string
+	{
+		return $this->newline;
+	}
+
 	/**
 	 * Whether the given position is immediately surrounded by parenthesis.
 	 */

vendor/phpstan/phpdoc-parser/src/Parser/TypeParser.php

@@ -70,23 +70,14 @@ class TypeParser
 	 */
 	public function enrichWithAttributes(TokenIterator $tokens, Ast\Node $type, int $startLine, int $startIndex): Ast\Node
 	{
-		$endLine = $tokens->currentTokenLine();
-		$endIndex = $tokens->currentTokenIndex();
-
 		if ($this->useLinesAttributes) {
 			$type->setAttribute(Ast\Attribute::START_LINE, $startLine);
-			$type->setAttribute(Ast\Attribute::END_LINE, $endLine);
+			$type->setAttribute(Ast\Attribute::END_LINE, $tokens->currentTokenLine());
 		}
 
 		if ($this->useIndexAttributes) {
-			$tokensArray = $tokens->getTokens();
-			$endIndex--;
-			if ($tokensArray[$endIndex][Lexer::TYPE_OFFSET] === Lexer::TOKEN_HORIZONTAL_WS) {
-				$endIndex--;
-			}
-
 			$type->setAttribute(Ast\Attribute::START_INDEX, $startIndex);
-			$type->setAttribute(Ast\Attribute::END_INDEX, $endIndex);
+			$type->setAttribute(Ast\Attribute::END_INDEX, $tokens->endIndexOfLastRelevantToken());
 		}
 
 		return $type;
@@ -205,28 +196,45 @@ class TypeParser
 			$tokens->dropSavePoint(); // because of ConstFetchNode
 		}
 
-		$exception = new ParserException(
-			$tokens->currentTokenValue(),
-			$tokens->currentTokenType(),
-			$tokens->currentTokenOffset(),
-			Lexer::TOKEN_IDENTIFIER,
-			null,
-			$tokens->currentTokenLine()
-		);
+		$currentTokenValue = $tokens->currentTokenValue();
+		$currentTokenType = $tokens->currentTokenType();
+		$currentTokenOffset = $tokens->currentTokenOffset();
+		$currentTokenLine = $tokens->currentTokenLine();
 
 		if ($this->constExprParser === null) {
-			throw $exception;
+			throw new ParserException(
+				$currentTokenValue,
+				$currentTokenType,
+				$currentTokenOffset,
+				Lexer::TOKEN_IDENTIFIER,
+				null,
+				$currentTokenLine
+			);
 		}
 
 		try {
 			$constExpr = $this->constExprParser->parse($tokens, true);
 			if ($constExpr instanceof Ast\ConstExpr\ConstExprArrayNode) {
-				throw $exception;
+				throw new ParserException(
+					$currentTokenValue,
+					$currentTokenType,
+					$currentTokenOffset,
+					Lexer::TOKEN_IDENTIFIER,
+					null,
+					$currentTokenLine
+				);
 			}
 
 			return $this->enrichWithAttributes($tokens, new Ast\Type\ConstTypeNode($constExpr), $startLine, $startIndex);
 		} catch (LogicException $e) {
-			throw $exception;
+			throw new ParserException(
+				$currentTokenValue,
+				$currentTokenType,
+				$currentTokenOffset,
+				Lexer::TOKEN_IDENTIFIER,
+				null,
+				$currentTokenLine
+			);
 		}
 	}
 
@@ -609,23 +617,33 @@ class TypeParser
 			}
 		}
 
-		$exception = new ParserException(
-			$tokens->currentTokenValue(),
-			$tokens->currentTokenType(),
-			$tokens->currentTokenOffset(),
-			Lexer::TOKEN_IDENTIFIER,
-			null,
-			$tokens->currentTokenLine()
-		);
+		$currentTokenValue = $tokens->currentTokenValue();
+		$currentTokenType = $tokens->currentTokenType();
+		$currentTokenOffset = $tokens->currentTokenOffset();
+		$currentTokenLine = $tokens->currentTokenLine();
 
 		if ($this->constExprParser === null) {
-			throw $exception;
+			throw new ParserException(
+				$currentTokenValue,
+				$currentTokenType,
+				$currentTokenOffset,
+				Lexer::TOKEN_IDENTIFIER,
+				null,
+				$currentTokenLine
+			);
 		}
 
 		try {
 			$constExpr = $this->constExprParser->parse($tokens, true);
 			if ($constExpr instanceof Ast\ConstExpr\ConstExprArrayNode) {
-				throw $exception;
+				throw new ParserException(
+					$currentTokenValue,
+					$currentTokenType,
+					$currentTokenOffset,
+					Lexer::TOKEN_IDENTIFIER,
+					null,
+					$currentTokenLine
+				);
 			}
 
 			$type = new Ast\Type\ConstTypeNode($constExpr);
@@ -640,7 +658,14 @@ class TypeParser
 
 			return $type;
 		} catch (LogicException $e) {
-			throw $exception;
+			throw new ParserException(
+				$currentTokenValue,
+				$currentTokenType,
+				$currentTokenOffset,
+				Lexer::TOKEN_IDENTIFIER,
+				null,
+				$currentTokenLine
+			);
 		}
 	}
 

vendor/phpstan/phpdoc-parser/src/Printer/Printer.php

@@ -10,6 +10,11 @@ use PHPStan\PhpDocParser\Ast\Node;
 use PHPStan\PhpDocParser\Ast\PhpDoc\AssertTagMethodValueNode;
 use PHPStan\PhpDocParser\Ast\PhpDoc\AssertTagPropertyValueNode;
 use PHPStan\PhpDocParser\Ast\PhpDoc\AssertTagValueNode;
+use PHPStan\PhpDocParser\Ast\PhpDoc\Doctrine\DoctrineAnnotation;
+use PHPStan\PhpDocParser\Ast\PhpDoc\Doctrine\DoctrineArgument;
+use PHPStan\PhpDocParser\Ast\PhpDoc\Doctrine\DoctrineArray;
+use PHPStan\PhpDocParser\Ast\PhpDoc\Doctrine\DoctrineArrayItem;
+use PHPStan\PhpDocParser\Ast\PhpDoc\Doctrine\DoctrineTagValueNode;
 use PHPStan\PhpDocParser\Ast\PhpDoc\ExtendsTagValueNode;
 use PHPStan\PhpDocParser\Ast\PhpDoc\ImplementsTagValueNode;
 use PHPStan\PhpDocParser\Ast\PhpDoc\MethodTagValueNode;
@@ -95,6 +100,8 @@ final class Printer
 		GenericTypeNode::class . '->genericTypes' => ', ',
 		ConstExprArrayNode::class . '->items' => ', ',
 		MethodTagValueNode::class . '->parameters' => ', ',
+		DoctrineArray::class . '->items' => ', ',
+		DoctrineAnnotation::class . '->arguments' => ', ',
 	];
 
 	/**
@@ -106,6 +113,8 @@ final class Printer
 		CallableTypeNode::class . '->parameters' => ['(', '', ''],
 		ArrayShapeNode::class . '->items' => ['{', '', ''],
 		ObjectShapeNode::class . '->items' => ['{', '', ''],
+		DoctrineArray::class . '->items' => ['{', '', ''],
+		DoctrineAnnotation::class . '->arguments' => ['(', '', ''],
 	];
 
 	/** @var array<string, list<class-string<TypeNode>>> */
@@ -186,6 +195,10 @@ final class Printer
 			return $node->text;
 		}
 		if ($node instanceof PhpDocTagNode) {
+			if ($node->value instanceof DoctrineTagValueNode) {
+				return $this->print($node->value);
+			}
+
 			return trim(sprintf('%s %s', $node->name, $this->print($node->value)));
 		}
 		if ($node instanceof PhpDocTagValueNode) {
@@ -211,6 +224,18 @@ final class Printer
 			$isOptional = $node->isOptional ? '=' : '';
 			return trim("{$type}{$isReference}{$isVariadic}{$node->parameterName}") . $isOptional;
 		}
+		if ($node instanceof DoctrineAnnotation) {
+			return (string) $node;
+		}
+		if ($node instanceof DoctrineArgument) {
+			return (string) $node;
+		}
+		if ($node instanceof DoctrineArray) {
+			return (string) $node;
+		}
+		if ($node instanceof DoctrineArrayItem) {
+			return (string) $node;
+		}
 
 		throw new LogicException(sprintf('Unknown node type %s', get_class($node)));
 	}
@@ -491,7 +516,7 @@ final class Printer
 		[$isMultiline, $beforeAsteriskIndent, $afterAsteriskIndent] = $this->isMultiline($tokenIndex, $originalNodes, $originalTokens);
 
 		if ($insertStr === "\n * ") {
-			$insertStr = sprintf("\n%s*%s", $beforeAsteriskIndent, $afterAsteriskIndent);
+			$insertStr = sprintf('%s%s*%s', $originalTokens->getDetectedNewline() ?? "\n", $beforeAsteriskIndent, $afterAsteriskIndent);
 		}
 
 		foreach ($diff as $i => $diffElem) {
@@ -524,7 +549,7 @@ final class Printer
 						}
 
 						if ($insertNewline) {
-							$result .= $insertStr . sprintf("\n%s*%s", $beforeAsteriskIndent, $afterAsteriskIndent);
+							$result .= $insertStr . sprintf('%s%s*%s', $originalTokens->getDetectedNewline() ?? "\n", $beforeAsteriskIndent, $afterAsteriskIndent);
 						} else {
 							$result .= $insertStr;
 						}
@@ -568,7 +593,7 @@ final class Printer
 
 				$itemEndPos = $tokenIndex - 1;
 				if ($insertNewline) {
-					$result .= $insertStr . sprintf("\n%s*%s", $beforeAsteriskIndent, $afterAsteriskIndent);
+					$result .= $insertStr . sprintf('%s%s*%s', $originalTokens->getDetectedNewline() ?? "\n", $beforeAsteriskIndent, $afterAsteriskIndent);
 				} else {
 					$result .= $insertStr;
 				}
@@ -637,7 +662,7 @@ final class Printer
 				if (!$first) {
 					$result .= $insertStr;
 					if ($insertNewline) {
-						$result .= sprintf("\n%s*%s", $beforeAsteriskIndent, $afterAsteriskIndent);
+						$result .= sprintf('%s%s*%s', $originalTokens->getDetectedNewline() ?? "\n", $beforeAsteriskIndent, $afterAsteriskIndent);
 					}
 				}
 

vendor/phpstan/phpstan/phpstan.phar.asc

@@ -1,16 +1,16 @@
 -----BEGIN PGP SIGNATURE-----
 
-iQIzBAABCgAdFiEEynwsejDI6OEnSoR2UcZzBf/C5cAFAmRaZmcACgkQUcZzBf/C
-5cAn/Q//fbWiR/qaSvlHpk73KH7iDfoHwNvRrHSQODZdMa4PGiEbL+SXsKnRxFDo
-kEJZwgU5qi3WMflt7Ml3dYDlQDgoDerdaiySYFoBcv1NXDWKoF7+Egy1AHxpfNq+
-FMCkZNR2ulSaYUCofM4GkTNap4yVkPCy289ZU6yUmRnJxF+hh/CFfdVPAPbwh/a6
-UqV3R2ENJZSbtA1pzSTBpUPQGQ9qcsqngKyNyxk1hEd9opdMg2eSFvO1e1ZZm/Tk
-Kgh5wCbsbSJuRPGO4vbiybTeO/qXPDlHV6oA5SHnjJ4H24phCsHdyJHHvLQmrUeR
-BKHgnH1y/b5J9cgr9OgEQJK9TMHHd6dii9//Qp+0rUZIDZ4Ym2lDSA/Vn/D9GoV3
-zo4QYzW3TvE3QMdnLcX/ZtaLliPdDYIaYUXOiyaYwLFGVxSWZWOC5IN0G0bLJb39
-Ca/z839nkWdMqg68q/oHC2Nk/v/KZnKg1RlRjYhj53T6nr0JDEiaYMyETSOIFsVX
-AcCQnLLwMndUAibJAyORDnTk+ipg0SecFoPvvhea1BtlTfhSDIlrT4OPKZ5nExzd
-nR/zGbIH8lCvsBc+hq+Kgodtfs5nauwEOwlVUwet26xL1YKOd0jxz+Zp6tgk0wba
-cMf5L9fm85j83DQYr7Ukaaj81kmMujRWDo/dRojKhUlJUrNnjXA=
-=jTtX
+iQIzBAABCgAdFiEEynwsejDI6OEnSoR2UcZzBf/C5cAFAmUBhZwACgkQUcZzBf/C
+5cDAIA/+JOxOdWCg6b1+/Bs4Opm7cmILJzh3Rw1366MzXFHJhe2n7exemzTE3X2E
+0HTjVVWoE0MpTt6knBgb+dulXTGm+yzJNIRLnCJFhsSdwUcxNAZMPozliZszGMcC
+HhGC1Ya7RU5d9WEg/lCAKRjNgSeY8VTRRfa49m6TQPQwGinXBNpH6q665feziUX5
+NB+rBMaWUDKp6GelPVrezEfME+SMfT66hW31n5m5paTwT+khk2Cenub5xXBUyXtz
+saxSayOShlUPN8kZKOjS/L/FPnOApGwcKxkX2kMK0qDs8YQFYHibNgnyhrEOBRD1
+UV9kBiU1+LUuxDcya8f0qo/gk6QN7Y/ywnIY3kTkqTYchCAAO+osu1amLYlInBSu
+r0LtQQ8+/llQ/bP0XS6cC6247J1fxO9xYMMmKVBfJrul3Wi6ETRI5WIdEQTSc2Z+
+rE00JY2X/vxJijUyGZ88+QDX3z7vGyaQJZiXq1XyjmBYw6w8UlxhGZcGGDIbTsb7
+lACLR/t4hgtE69QXW+L4P2ngU0agk5XXojg/+r+CnCWD/TdKcvs1WTn4TyuMZOLa
+2XF3h9/H0XMfE5LPlNJmb4YRjYjcNvPQwmGI4dmUMCJuTpjHUnpFXfswu4xgsaYV
+xq756DVfrRyG9PyXFfJZ66P7jt5+wisrVsWh/X3nX69P0ruwwss=
+=aOCq
 -----END PGP SIGNATURE-----