TASK: Refactor TypeReferenceParser

Author: grebaldi

src/Language/Parser/ParserException.php

@@ -29,15 +29,9 @@ abstract class ParserException extends \Exception
     protected function __construct(
         int $code,
         string $message,
-        public readonly Range $affectedRangeInSource,
+        public readonly ?Range $affectedRangeInSource = null,
         ?\Exception $cause = null
     ) {
-        $message = sprintf(
-            '[%s] %s',
-            $affectedRangeInSource->start->toDebugString(),
-            $message
-        );
-
         parent::__construct($message, $code, $cause);
     }
 }

src/Language/Parser/TypeReference/TypeReferenceCouldNotBeParsed.php

@@ -22,23 +22,36 @@
 
 namespace PackageFactory\ComponentEngine\Language\Parser\TypeReference;
 
+use PackageFactory\ComponentEngine\Language\AST\Node\TypeReference\InvalidTypeNameNodes;
 use PackageFactory\ComponentEngine\Language\AST\Node\TypeReference\InvalidTypeReferenceNode;
 use PackageFactory\ComponentEngine\Language\Parser\ParserException;
-use PackageFactory\ComponentEngine\Parser\Source\Range;
 
 final class TypeReferenceCouldNotBeParsed extends ParserException
 {
     public static function becauseOfInvalidTypeReferenceNode(
-        InvalidTypeReferenceNode $cause,
-        Range $affectedRangeInSource
+        InvalidTypeReferenceNode $cause
     ): self {
         return new self(
             code: 1690542466,
             message: sprintf(
                 'TypeReferenceNode could not be parsed, because the result would be invalid: %s',
                 $cause->getMessage()
             ),
-            affectedRangeInSource: $affectedRangeInSource,
+            affectedRangeInSource: $cause->attributesOfAffectedNode?->rangeInSource ?? null,
+            cause: $cause
+        );
+    }
+
+    public static function becauseOfInvalidTypeTypeNameNodes(
+        InvalidTypeNameNodes $cause
+    ): self {
+        return new self(
+            code: 1690833898,
+            message: sprintf(
+                'TypeReferenceNode could not be parsed, because the list of type names was invalid: %s',
+                $cause->getMessage()
+            ),
+            affectedRangeInSource: $cause->attributesOfAffectedNode?->rangeInSource ?? null,
             cause: $cause
         );
     }

src/Language/Parser/TypeReference/TypeReferenceParser.php

@@ -23,6 +23,7 @@
 namespace PackageFactory\ComponentEngine\Language\Parser\TypeReference;
 
 use PackageFactory\ComponentEngine\Domain\TypeName\TypeName;
+use PackageFactory\ComponentEngine\Language\AST\Node\TypeReference\InvalidTypeNameNodes;
 use PackageFactory\ComponentEngine\Language\AST\Node\TypeReference\InvalidTypeReferenceNode;
 use PackageFactory\ComponentEngine\Language\AST\Node\TypeReference\TypeNameNode;
 use PackageFactory\ComponentEngine\Language\AST\Node\TypeReference\TypeNameNodes;
@@ -66,10 +67,7 @@ public function parse(\Iterator $tokens): TypeReferenceNode
                 isOptional: $isOptional
             );
         } catch (InvalidTypeReferenceNode $e) {
-            throw TypeReferenceCouldNotBeParsed::becauseOfInvalidTypeReferenceNode(
-                cause: $e,
-                affectedRangeInSource: $rangeInSource
-            );
+            throw TypeReferenceCouldNotBeParsed::becauseOfInvalidTypeReferenceNode($e);
         }
     }
 
@@ -97,31 +95,40 @@ public function parseTypeNames(\Iterator $tokens): TypeNameNodes
     {
         $items = [];
         while (true) {
-            Scanner::assertType($tokens, TokenType::STRING);
-
-            $typeNameToken = $tokens->current();
-            $items[] = new TypeNameNode(
-                attributes: new NodeAttributes(
-                    rangeInSource: $typeNameToken->boundaries
-                ),
-                value: TypeName::from($typeNameToken->value)
-            );
+            $items[] = $this->parseTypeName($tokens);
 
-            Scanner::skipOne($tokens);
-
-            if (Scanner::isEnd($tokens)) {
+            if (Scanner::isEnd($tokens) || Scanner::type($tokens) !== TokenType::PIPE) {
                 break;
             }
 
-            if (Scanner::type($tokens) === TokenType::PIPE) {
-                Scanner::skipOne($tokens);
-                continue;
-            }
+            Scanner::skipOne($tokens);
+        }
 
-            break;
+        try {
+            return new TypeNameNodes(...$items);
+        } catch (InvalidTypeNameNodes $e) {
+            throw TypeReferenceCouldNotBeParsed::becauseOfInvalidTypeTypeNameNodes($e);
         }
+    }
+
+    /**
+     * @param \Iterator<mixed,Token> $tokens
+     * @return TypeNameNode
+     */
+    public function parseTypeName(\Iterator $tokens): TypeNameNode
+    {
+        Scanner::assertType($tokens, TokenType::STRING);
+
+        $typeNameToken = $tokens->current();
 
-        return new TypeNameNodes(...$items);
+        Scanner::skipOne($tokens);
+
+        return new TypeNameNode(
+            attributes: new NodeAttributes(
+                rangeInSource: $typeNameToken->boundaries
+            ),
+            value: TypeName::from($typeNameToken->value)
+        );
     }
 
     /**

test/Unit/Language/Parser/TypeReference/TypeReferenceParserTest.php

@@ -24,6 +24,7 @@
 
 use PackageFactory\ComponentEngine\Domain\TypeName\TypeName;
 use PackageFactory\ComponentEngine\Domain\TypeName\TypeNames;
+use PackageFactory\ComponentEngine\Language\AST\Node\TypeReference\InvalidTypeNameNodes;
 use PackageFactory\ComponentEngine\Language\AST\Node\TypeReference\InvalidTypeReferenceNode;
 use PackageFactory\ComponentEngine\Language\AST\Node\TypeReference\TypeNameNode;
 use PackageFactory\ComponentEngine\Language\AST\Node\TypeReference\TypeNameNodes;
@@ -221,10 +222,34 @@ public function throwsParserExceptionWhenInvalidTypeReferenceOccurs(): void
                             new Position(0, 4)
                         )
                     ),
-                ),
-                affectedRangeInSource: Range::from(
-                    new Position(0, 0),
-                    new Position(0, 4)
+                )
+            )
+        );
+
+        $typeReferenceParser->parse($tokens);
+    }
+
+    /**
+     * @test
+     */
+    public function throwsParserExceptionWhenDuplicatesOccur(): void
+    {
+        $typeReferenceParser = new TypeReferenceParser();
+        $tokens = Tokenizer::fromSource(Source::fromString('Foo|Bar|Foo|Baz'))->getIterator();
+
+        $this->expectException(ParserException::class);
+        $this->expectExceptionObject(
+            TypeReferenceCouldNotBeParsed::becauseOfInvalidTypeTypeNameNodes(
+                cause: InvalidTypeNameNodes::becauseTheyContainDuplicates(
+                    duplicateTypeNameNode: new TypeNameNode(
+                        attributes: new NodeAttributes(
+                            rangeInSource: Range::from(
+                                new Position(0, 9),
+                                new Position(0, 11)
+                            )
+                        ),
+                        value: TypeName::from('Foo')
+                    )
                 )
             )
         );