Skip to content

Commit 2ed8768

Browse files
DaDeatherDaDeather
committed
Allow new lines in between everything and handle them correctly
1 parent 81de606 commit 2ed8768

File tree

3 files changed

+164
-38
lines changed

3 files changed

+164
-38
lines changed

‎src/Parser/TokenIterator.php‎

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -205,6 +205,15 @@ public function tryConsumeTokenType(int $tokenType): bool
205205
}
206206

207207

208+
/** @phpstan-impure */
209+
public function skipNewLineTokens(): void
210+
{
211+
do {
212+
$foundNewLine = $this->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
213+
} while ($foundNewLine === true);
214+
}
215+
216+
208217
private function detectNewline(): void
209218
{
210219
$value = $this->currentTokenValue();

‎src/Parser/TypeParser.php‎

Lines changed: 43 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -90,7 +90,7 @@ private function subParse(TokenIterator $tokens): Ast\Type\TypeNode
9090
if ($tokens->isCurrentTokenValue('is')) {
9191
$type = $this->parseConditional($tokens, $type);
9292
} else {
93-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
93+
$tokens->skipNewLineTokens();
9494

9595
if ($tokens->isCurrentTokenType(Lexer::TOKEN_UNION)) {
9696
$type = $this->subParseUnion($tokens, $type);
@@ -112,9 +112,9 @@ private function parseAtomic(TokenIterator $tokens): Ast\Type\TypeNode
112112
$startIndex = $tokens->currentTokenIndex();
113113

114114
if ($tokens->tryConsumeTokenType(Lexer::TOKEN_OPEN_PARENTHESES)) {
115-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
115+
$tokens->skipNewLineTokens();
116116
$type = $this->subParse($tokens);
117-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
117+
$tokens->skipNewLineTokens();
118118

119119
$tokens->consumeTokenType(Lexer::TOKEN_CLOSE_PARENTHESES);
120120

@@ -256,9 +256,9 @@ private function subParseUnion(TokenIterator $tokens, Ast\Type\TypeNode $type):
256256
$types = [$type];
257257

258258
while ($tokens->tryConsumeTokenType(Lexer::TOKEN_UNION)) {
259-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
259+
$tokens->skipNewLineTokens();
260260
$types[] = $this->parseAtomic($tokens);
261-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
261+
$tokens->skipNewLineTokens();
262262
}
263263

264264
return new Ast\Type\UnionTypeNode($types);
@@ -284,9 +284,9 @@ private function subParseIntersection(TokenIterator $tokens, Ast\Type\TypeNode $
284284
$types = [$type];
285285

286286
while ($tokens->tryConsumeTokenType(Lexer::TOKEN_INTERSECTION)) {
287-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
287+
$tokens->skipNewLineTokens();
288288
$types[] = $this->parseAtomic($tokens);
289-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
289+
$tokens->skipNewLineTokens();
290290
}
291291

292292
return new Ast\Type\IntersectionTypeNode($types);
@@ -306,15 +306,15 @@ private function parseConditional(TokenIterator $tokens, Ast\Type\TypeNode $subj
306306

307307
$targetType = $this->parse($tokens);
308308

309-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
309+
$tokens->skipNewLineTokens();
310310
$tokens->consumeTokenType(Lexer::TOKEN_NULLABLE);
311-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
311+
$tokens->skipNewLineTokens();
312312

313313
$ifType = $this->parse($tokens);
314314

315-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
315+
$tokens->skipNewLineTokens();
316316
$tokens->consumeTokenType(Lexer::TOKEN_COLON);
317-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
317+
$tokens->skipNewLineTokens();
318318

319319
$elseType = $this->subParse($tokens);
320320

@@ -335,15 +335,15 @@ private function parseConditionalForParameter(TokenIterator $tokens, string $par
335335

336336
$targetType = $this->parse($tokens);
337337

338-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
338+
$tokens->skipNewLineTokens();
339339
$tokens->consumeTokenType(Lexer::TOKEN_NULLABLE);
340-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
340+
$tokens->skipNewLineTokens();
341341

342342
$ifType = $this->parse($tokens);
343343

344-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
344+
$tokens->skipNewLineTokens();
345345
$tokens->consumeTokenType(Lexer::TOKEN_COLON);
346-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
346+
$tokens->skipNewLineTokens();
347347

348348
$elseType = $this->subParse($tokens);
349349

@@ -409,8 +409,13 @@ public function parseGeneric(TokenIterator $tokens, Ast\Type\IdentifierTypeNode
409409
$variances = [];
410410

411411
$isFirst = true;
412-
while ($isFirst || $tokens->tryConsumeTokenType(Lexer::TOKEN_COMMA)) {
413-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
412+
while (
413+
$isFirst
414+
|| $tokens->tryConsumeTokenType(Lexer::TOKEN_COMMA)
415+
|| $tokens->tryConsumeTokenType(Lexer::TOKEN_UNION)
416+
|| $tokens->tryConsumeTokenType(Lexer::TOKEN_INTERSECTION)
417+
) {
418+
$tokens->skipNewLineTokens();
414419

415420
// trailing comma case
416421
if (!$isFirst && $tokens->isCurrentTokenType(Lexer::TOKEN_CLOSE_ANGLE_BRACKET)) {
@@ -419,7 +424,7 @@ public function parseGeneric(TokenIterator $tokens, Ast\Type\IdentifierTypeNode
419424
$isFirst = false;
420425

421426
[$genericTypes[], $variances[]] = $this->parseGenericTypeArgument($tokens);
422-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
427+
$tokens->skipNewLineTokens();
423428
}
424429

425430
$type = new Ast\Type\GenericTypeNode($baseType, $genericTypes, $variances);
@@ -510,19 +515,19 @@ private function parseCallable(TokenIterator $tokens, Ast\Type\IdentifierTypeNod
510515
: [];
511516

512517
$tokens->consumeTokenType(Lexer::TOKEN_OPEN_PARENTHESES);
513-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
518+
$tokens->skipNewLineTokens();
514519

515520
$parameters = [];
516521
if (!$tokens->isCurrentTokenType(Lexer::TOKEN_CLOSE_PARENTHESES)) {
517522
$parameters[] = $this->parseCallableParameter($tokens);
518-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
523+
$tokens->skipNewLineTokens();
519524
while ($tokens->tryConsumeTokenType(Lexer::TOKEN_COMMA)) {
520-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
525+
$tokens->skipNewLineTokens();
521526
if ($tokens->isCurrentTokenType(Lexer::TOKEN_CLOSE_PARENTHESES)) {
522527
break;
523528
}
524529
$parameters[] = $this->parseCallableParameter($tokens);
525-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
530+
$tokens->skipNewLineTokens();
526531
}
527532
}
528533

@@ -550,7 +555,7 @@ private function parseCallableTemplates(TokenIterator $tokens): array
550555

551556
$isFirst = true;
552557
while ($isFirst || $tokens->tryConsumeTokenType(Lexer::TOKEN_COMMA)) {
553-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
558+
$tokens->skipNewLineTokens();
554559

555560
// trailing comma case
556561
if (!$isFirst && $tokens->isCurrentTokenType(Lexer::TOKEN_CLOSE_ANGLE_BRACKET)) {
@@ -559,7 +564,7 @@ private function parseCallableTemplates(TokenIterator $tokens): array
559564
$isFirst = false;
560565

561566
$templates[] = $this->parseCallableTemplateArgument($tokens);
562-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
567+
$tokens->skipNewLineTokens();
563568
}
564569

565570
$tokens->consumeTokenType(Lexer::TOKEN_CLOSE_ANGLE_BRACKET);
@@ -830,7 +835,7 @@ private function parseArrayShape(TokenIterator $tokens, Ast\Type\TypeNode $type,
830835
$unsealedType = null;
831836

832837
do {
833-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
838+
$tokens->skipNewLineTokens();
834839

835840
if ($tokens->tryConsumeTokenType(Lexer::TOKEN_CLOSE_CURLY_BRACKET)) {
836841
return Ast\Type\ArrayShapeNode::createSealed($items, $kind);
@@ -839,14 +844,14 @@ private function parseArrayShape(TokenIterator $tokens, Ast\Type\TypeNode $type,
839844
if ($tokens->tryConsumeTokenType(Lexer::TOKEN_VARIADIC)) {
840845
$sealed = false;
841846

842-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
847+
$tokens->skipNewLineTokens();
843848
if ($tokens->isCurrentTokenType(Lexer::TOKEN_OPEN_ANGLE_BRACKET)) {
844849
if ($kind === Ast\Type\ArrayShapeNode::KIND_ARRAY) {
845850
$unsealedType = $this->parseArrayShapeUnsealedType($tokens);
846851
} else {
847852
$unsealedType = $this->parseListShapeUnsealedType($tokens);
848853
}
849-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
854+
$tokens->skipNewLineTokens();
850855
}
851856

852857
$tokens->tryConsumeTokenType(Lexer::TOKEN_COMMA);
@@ -855,10 +860,10 @@ private function parseArrayShape(TokenIterator $tokens, Ast\Type\TypeNode $type,
855860

856861
$items[] = $this->parseArrayShapeItem($tokens);
857862

858-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
863+
$tokens->skipNewLineTokens();
859864
} while ($tokens->tryConsumeTokenType(Lexer::TOKEN_COMMA));
860865

861-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
866+
$tokens->skipNewLineTokens();
862867
$tokens->consumeTokenType(Lexer::TOKEN_CLOSE_CURLY_BRACKET);
863868

864869
if ($sealed) {
@@ -945,18 +950,18 @@ private function parseArrayShapeUnsealedType(TokenIterator $tokens): Ast\Type\Ar
945950
$startIndex = $tokens->currentTokenIndex();
946951

947952
$tokens->consumeTokenType(Lexer::TOKEN_OPEN_ANGLE_BRACKET);
948-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
953+
$tokens->skipNewLineTokens();
949954

950955
$valueType = $this->parse($tokens);
951-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
956+
$tokens->skipNewLineTokens();
952957

953958
$keyType = null;
954959
if ($tokens->tryConsumeTokenType(Lexer::TOKEN_COMMA)) {
955-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
960+
$tokens->skipNewLineTokens();
956961

957962
$keyType = $valueType;
958963
$valueType = $this->parse($tokens);
959-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
964+
$tokens->skipNewLineTokens();
960965
}
961966

962967
$tokens->consumeTokenType(Lexer::TOKEN_CLOSE_ANGLE_BRACKET);
@@ -978,10 +983,10 @@ private function parseListShapeUnsealedType(TokenIterator $tokens): Ast\Type\Arr
978983
$startIndex = $tokens->currentTokenIndex();
979984

980985
$tokens->consumeTokenType(Lexer::TOKEN_OPEN_ANGLE_BRACKET);
981-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
986+
$tokens->skipNewLineTokens();
982987

983988
$valueType = $this->parse($tokens);
984-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
989+
$tokens->skipNewLineTokens();
985990

986991
$tokens->consumeTokenType(Lexer::TOKEN_CLOSE_ANGLE_BRACKET);
987992

@@ -1003,18 +1008,18 @@ private function parseObjectShape(TokenIterator $tokens): Ast\Type\ObjectShapeNo
10031008
$items = [];
10041009

10051010
do {
1006-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
1011+
$tokens->skipNewLineTokens();
10071012

10081013
if ($tokens->tryConsumeTokenType(Lexer::TOKEN_CLOSE_CURLY_BRACKET)) {
10091014
return new Ast\Type\ObjectShapeNode($items);
10101015
}
10111016

10121017
$items[] = $this->parseObjectShapeItem($tokens);
10131018

1014-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
1019+
$tokens->skipNewLineTokens();
10151020
} while ($tokens->tryConsumeTokenType(Lexer::TOKEN_COMMA));
10161021

1017-
$tokens->tryConsumeTokenType(Lexer::TOKEN_PHPDOC_EOL);
1022+
$tokens->skipNewLineTokens();
10181023
$tokens->consumeTokenType(Lexer::TOKEN_CLOSE_CURLY_BRACKET);
10191024

10201025
return new Ast\Type\ObjectShapeNode($items);

‎tests/PHPStan/Parser/PhpDocParserTest.php‎

Lines changed: 112 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -4027,6 +4027,118 @@ public function provideMultiLinePhpDocData(): iterable
40274027
new PhpDocTextNode(''),
40284028
]),
40294029
];
4030+
4031+
yield [
4032+
'Multiline PHPDoc with new line across generic type declaration',
4033+
'/**' . PHP_EOL .
4034+
' * @param array<string, array{' . PHP_EOL .
4035+
' * foo: int,' . PHP_EOL .
4036+
' * bar?: array<string,' . PHP_EOL .
4037+
' * array{foo1: int, bar1?: true}' . PHP_EOL .
4038+
' * | array{foo1: int, foo2: true, bar1?: true}' . PHP_EOL .
4039+
' * >,' . PHP_EOL .
4040+
' * }> $a' . PHP_EOL .
4041+
' */',
4042+
new PhpDocNode([
4043+
new PhpDocTagNode('@param', new ParamTagValueNode(
4044+
new GenericTypeNode(
4045+
new IdentifierTypeNode('array'),
4046+
[
4047+
new IdentifierTypeNode('string'),
4048+
ArrayShapeNode::createSealed([
4049+
new ArrayShapeItemNode(new IdentifierTypeNode('foo'), false, new IdentifierTypeNode('int')),
4050+
new ArrayShapeItemNode(new IdentifierTypeNode('bar'), true, new GenericTypeNode(
4051+
new IdentifierTypeNode('array'),
4052+
[
4053+
new IdentifierTypeNode('string'),
4054+
ArrayShapeNode::createSealed([
4055+
new ArrayShapeItemNode(new IdentifierTypeNode('foo1'), false, new IdentifierTypeNode('int')),
4056+
new ArrayShapeItemNode(new IdentifierTypeNode('bar1'), true, new IdentifierTypeNode('true')),
4057+
]),
4058+
ArrayShapeNode::createSealed([
4059+
new ArrayShapeItemNode(new IdentifierTypeNode('foo1'), false, new IdentifierTypeNode('int')),
4060+
new ArrayShapeItemNode(new IdentifierTypeNode('foo2'), false, new IdentifierTypeNode('true')),
4061+
new ArrayShapeItemNode(new IdentifierTypeNode('bar1'), true, new IdentifierTypeNode('true')),
4062+
]),
4063+
],
4064+
[
4065+
GenericTypeNode::VARIANCE_INVARIANT,
4066+
GenericTypeNode::VARIANCE_INVARIANT,
4067+
GenericTypeNode::VARIANCE_INVARIANT,
4068+
],
4069+
)),
4070+
]),
4071+
],
4072+
[
4073+
GenericTypeNode::VARIANCE_INVARIANT,
4074+
GenericTypeNode::VARIANCE_INVARIANT,
4075+
],
4076+
),
4077+
false,
4078+
'$a',
4079+
'',
4080+
false,
4081+
)),
4082+
]),
4083+
];
4084+
4085+
yield [
4086+
'Multiline PHPDoc with new line within type declaration',
4087+
'/**' . PHP_EOL .
4088+
' * @param array<string, array{' . PHP_EOL .
4089+
' * foo: int,' . PHP_EOL .
4090+
' * ' . PHP_EOL .
4091+
' * ' . PHP_EOL .
4092+
' * bar?: array<string,' . PHP_EOL .
4093+
' * ' . PHP_EOL .
4094+
' * array{foo1: int, bar1?: true}' . PHP_EOL .
4095+
' * ' . PHP_EOL .
4096+
' * | array{foo1: int, foo2: true, bar1?: true}' . PHP_EOL .
4097+
' * >,' . PHP_EOL .
4098+
' * }> $a' . PHP_EOL .
4099+
' */',
4100+
new PhpDocNode([
4101+
new PhpDocTagNode('@param', new ParamTagValueNode(
4102+
new GenericTypeNode(
4103+
new IdentifierTypeNode('array'),
4104+
[
4105+
new IdentifierTypeNode('string'),
4106+
ArrayShapeNode::createSealed([
4107+
new ArrayShapeItemNode(new IdentifierTypeNode('foo'), false, new IdentifierTypeNode('int')),
4108+
new ArrayShapeItemNode(new IdentifierTypeNode('bar'), true, new GenericTypeNode(
4109+
new IdentifierTypeNode('array'),
4110+
[
4111+
new IdentifierTypeNode('string'),
4112+
ArrayShapeNode::createSealed([
4113+
new ArrayShapeItemNode(new IdentifierTypeNode('foo1'), false, new IdentifierTypeNode('int')),
4114+
new ArrayShapeItemNode(new IdentifierTypeNode('bar1'), true, new IdentifierTypeNode('true')),
4115+
]),
4116+
ArrayShapeNode::createSealed([
4117+
new ArrayShapeItemNode(new IdentifierTypeNode('foo1'), false, new IdentifierTypeNode('int')),
4118+
new ArrayShapeItemNode(new IdentifierTypeNode('foo2'), false, new IdentifierTypeNode('true')),
4119+
new ArrayShapeItemNode(new IdentifierTypeNode('bar1'), true, new IdentifierTypeNode('true')),
4120+
]),
4121+
],
4122+
[
4123+
GenericTypeNode::VARIANCE_INVARIANT,
4124+
GenericTypeNode::VARIANCE_INVARIANT,
4125+
GenericTypeNode::VARIANCE_INVARIANT,
4126+
],
4127+
)),
4128+
]),
4129+
],
4130+
[
4131+
GenericTypeNode::VARIANCE_INVARIANT,
4132+
GenericTypeNode::VARIANCE_INVARIANT,
4133+
],
4134+
),
4135+
false,
4136+
'$a',
4137+
'',
4138+
false,
4139+
)),
4140+
]),
4141+
];
40304142
}
40314143

40324144
public function provideTemplateTagsData(): Iterator

0 commit comments

Comments
 (0)