TASK: Add constraints for union type references

grebaldi · grebaldi · commit 178d5796d460 · 2023-07-28T15:58:15.000+02:00
diff --git a/src/Language/AST/ASTException.php b/src/Language/AST/ASTException.php
@@ -29,7 +29,7 @@ abstract class ASTException extends \Exception
     protected function __construct(
         int $code,
         string $message,
-        public readonly NodeAttributes $attributesOfAffectedNode
+        public readonly ?NodeAttributes $attributesOfAffectedNode = null
     ) {
         parent::__construct($message, $code);
     }
diff --git a/src/Language/AST/Node/TypeReference/InvalidTypeNameNodes.php b/src/Language/AST/Node/TypeReference/InvalidTypeNameNodes.php
@@ -0,0 +1,46 @@
+<?php
+
+/**
+ * PackageFactory.ComponentEngine - Universal View Components for PHP
+ *   Copyright (C) 2023 Contributors of PackageFactory.ComponentEngine
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+declare(strict_types=1);
+
+namespace PackageFactory\ComponentEngine\Language\AST\Node\TypeReference;
+
+use PackageFactory\ComponentEngine\Language\AST\ASTException;
+
+final class InvalidTypeNameNodes extends ASTException
+{
+    public static function becauseTheyWereEmpty(): self
+    {
+        return new self(
+            code: 1690549442,
+            message: 'A type reference must refer to at least one type name.'
+        );
+    }
+
+    public static function becauseTheyContainDuplicates(
+        TypeNameNode $duplicateTypeNameNode
+    ): self {
+        return new self(
+            code: 1690551330,
+            message: 'A type reference must not contain duplicates.',
+            attributesOfAffectedNode: $duplicateTypeNameNode->attributes
+        );
+    }
+}
diff --git a/src/Language/AST/Node/TypeReference/InvalidTypeReferenceNode.php b/src/Language/AST/Node/TypeReference/InvalidTypeReferenceNode.php
@@ -41,4 +41,32 @@ public static function becauseItWasOptionalAndArrayAtTheSameTime(
             attributesOfAffectedNode: $attributesOfAffectedNode
         );
     }
+
+    public static function becauseItWasUnionAndArrayAtTheSameTime(
+        TypeNames $affectedTypeNames,
+        NodeAttributes $attributesOfAffectedNode
+    ): self {
+        return new self(
+            code: 1690552344,
+            message: sprintf(
+                'The type reference to "%s" must not be union and array at the same time.',
+                $affectedTypeNames->toDebugString()
+            ),
+            attributesOfAffectedNode: $attributesOfAffectedNode
+        );
+    }
+
+    public static function becauseItWasUnionAndOptionalAtTheSameTime(
+        TypeNames $affectedTypeNames,
+        NodeAttributes $attributesOfAffectedNode
+    ): self {
+        return new self(
+            code: 1690552586,
+            message: sprintf(
+                'The type reference to "%s" must not be union and optional at the same time.',
+                $affectedTypeNames->toDebugString()
+            ),
+            attributesOfAffectedNode: $attributesOfAffectedNode
+        );
+    }
 }
diff --git a/src/Language/AST/Node/TypeReference/TypeNameNodes.php b/src/Language/AST/Node/TypeReference/TypeNameNodes.php
@@ -35,6 +35,21 @@ final class TypeNameNodes
 
     public function __construct(TypeNameNode ...$items)
     {
+        if (count($items) === 0) {
+            throw InvalidTypeNameNodes::becauseTheyWereEmpty();
+        }
+
+        $typeNames = [];
+        foreach ($items as $item) {
+            if (isset($typeNames[$item->value->value])) {
+                throw InvalidTypeNameNodes::becauseTheyContainDuplicates(
+                    duplicateTypeNameNode: $item
+                );
+            }
+
+            $typeNames[$item->value->value] = true;
+        }
+
         $this->items = $items;
     }
 
diff --git a/src/Language/AST/Node/TypeReference/TypeReferenceNode.php b/src/Language/AST/Node/TypeReference/TypeReferenceNode.php
@@ -39,5 +39,19 @@ public function __construct(
                 attributesOfAffectedNode: $attributes
             );
         }
+
+        if ($names->getSize() > 1 && $isArray === true) {
+            throw InvalidTypeReferenceNode::becauseItWasUnionAndArrayAtTheSameTime(
+                affectedTypeNames: $names->toTypeNames(),
+                attributesOfAffectedNode: $attributes
+            );
+        }
+
+        if ($names->getSize() > 1 && $isOptional === true) {
+            throw InvalidTypeReferenceNode::becauseItWasUnionAndOptionalAtTheSameTime(
+                affectedTypeNames: $names->toTypeNames(),
+                attributesOfAffectedNode: $attributes
+            );
+        }
     }
 }
diff --git a/test/Unit/Language/AST/Node/TypeReference/TypeNameNodesTest.php b/test/Unit/Language/AST/Node/TypeReference/TypeNameNodesTest.php
@@ -24,8 +24,13 @@
 
 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\TypeNameNode;
 use PackageFactory\ComponentEngine\Language\AST\Node\TypeReference\TypeNameNodes;
+use PackageFactory\ComponentEngine\Language\AST\NodeAttributes\NodeAttributes;
+use PackageFactory\ComponentEngine\Parser\Source\Path;
+use PackageFactory\ComponentEngine\Parser\Source\Position;
+use PackageFactory\ComponentEngine\Parser\Source\Range;
 use PackageFactory\ComponentEngine\Test\Unit\Language\AST\Helpers\DummyAttributes;
 use PHPUnit\Framework\TestCase;
 
@@ -41,6 +46,48 @@ protected function createTypeNameNode(string $typeName): TypeNameNode
         );
     }
 
+    /**
+     * @test
+     */
+    public function mustNotBeEmpty(): void
+    {
+        $this->expectExceptionObject(
+            InvalidTypeNameNodes::becauseTheyWereEmpty()
+        );
+
+        new TypeNameNodes();
+    }
+
+    /**
+     * @test
+     */
+    public function mustNotContainDuplicates(): void
+    {
+        $duplicate = new TypeNameNode(
+            attributes: new NodeAttributes(
+                pathToSource: Path::fromString(':memory:'),
+                rangeInSource: Range::from(
+                    new Position(1, 1),
+                    new Position(1, 1)
+                )
+            ),
+            value: TypeName::from('Foo')
+        );
+
+        $this->expectExceptionObject(
+            InvalidTypeNameNodes::becauseTheyContainDuplicates(
+                duplicateTypeNameNode: $duplicate
+            )
+        );
+
+        new TypeNameNodes(
+            $this->createTypeNameNode('Foo'),
+            $this->createTypeNameNode('Bar'),
+            $duplicate,
+            $this->createTypeNameNode('Baz'),
+        );
+    }
+
     /**
      * @test
      */
diff --git a/test/Unit/Language/AST/Node/TypeReference/TypeReferenceNodeTest.php b/test/Unit/Language/AST/Node/TypeReference/TypeReferenceNodeTest.php
@@ -107,7 +107,40 @@ public function validOptionalTypeReferenceIsValid(): void
     /**
      * @test
      */
-    public function typeReferenceCannotBeArrayAndOptionalSimultaneously(): void
+    public function validUnionTypeReferenceIsValid(): void
+    {
+        $typeReferenceNode = new TypeReferenceNode(
+            attributes: $this->dummyAttributes,
+            names: new TypeNameNodes(
+                new TypeNameNode(
+                    attributes: $this->dummyAttributes,
+                    value: TypeName::from('Foo')
+                ),
+                new TypeNameNode(
+                    attributes: $this->dummyAttributes,
+                    value: TypeName::from('Bar')
+                ),
+                new TypeNameNode(
+                    attributes: $this->dummyAttributes,
+                    value: TypeName::from('Baz')
+                )
+            ),
+            isArray: false,
+            isOptional: false
+        );
+
+        $this->assertEquals(3, $typeReferenceNode->names->getSize());
+        $this->assertEquals('Foo', $typeReferenceNode->names->items[0]->value->value);
+        $this->assertEquals('Bar', $typeReferenceNode->names->items[1]->value->value);
+        $this->assertEquals('Baz', $typeReferenceNode->names->items[2]->value->value);
+        $this->assertFalse($typeReferenceNode->isArray);
+        $this->assertFalse($typeReferenceNode->isOptional);
+    }
+
+    /**
+     * @test
+     */
+    public function mustNotBeArrayAndOptionalSimultaneously(): void
     {
         $name = TypeName::from('Foo');
 
@@ -130,4 +163,74 @@ public function typeReferenceCannotBeArrayAndOptionalSimultaneously(): void
             isOptional: true
         );
     }
+
+    /**
+     * @test
+     */
+    public function mustNotBeUnionAndArraySimultaneously(): void
+    {
+        $typeNameNodes = new TypeNameNodes(
+            new TypeNameNode(
+                attributes: $this->dummyAttributes,
+                value: TypeName::from('Foo')
+            ),
+            new TypeNameNode(
+                attributes: $this->dummyAttributes,
+                value: TypeName::from('Bar')
+            ),
+            new TypeNameNode(
+                attributes: $this->dummyAttributes,
+                value: TypeName::from('Baz')
+            )
+        );
+
+        $this->expectExceptionObject(
+            InvalidTypeReferenceNode::becauseItWasUnionAndArrayAtTheSameTime(
+                affectedTypeNames: $typeNameNodes->toTypeNames(),
+                attributesOfAffectedNode: $this->dummyAttributes
+            )
+        );
+
+        new TypeReferenceNode(
+            attributes: $this->dummyAttributes,
+            names: $typeNameNodes,
+            isArray: true,
+            isOptional: false
+        );
+    }
+
+    /**
+     * @test
+     */
+    public function mustNotBeUnionAndOptionalSimultaneously(): void
+    {
+        $typeNameNodes = new TypeNameNodes(
+            new TypeNameNode(
+                attributes: $this->dummyAttributes,
+                value: TypeName::from('Foo')
+            ),
+            new TypeNameNode(
+                attributes: $this->dummyAttributes,
+                value: TypeName::from('Bar')
+            ),
+            new TypeNameNode(
+                attributes: $this->dummyAttributes,
+                value: TypeName::from('Baz')
+            )
+        );
+
+        $this->expectExceptionObject(
+            InvalidTypeReferenceNode::becauseItWasUnionAndOptionalAtTheSameTime(
+                affectedTypeNames: $typeNameNodes->toTypeNames(),
+                attributesOfAffectedNode: $this->dummyAttributes
+            )
+        );
+
+        new TypeReferenceNode(
+            attributes: $this->dummyAttributes,
+            names: $typeNameNodes,
+            isArray: false,
+            isOptional: true
+        );
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -29,7 +29,7 @@ abstract class ASTException extends \Exception`
`29`	`29`	`protected function __construct(`
`30`	`30`	`int $code,`
`31`	`31`	`string $message,`
`32`		`- public readonly NodeAttributes $attributesOfAffectedNode`
	`32`	`+ public readonly ?NodeAttributes $attributesOfAffectedNode = null`
`33`	`33`	`) {`
`34`	`34`	`parent::__construct($message, $code);`
`35`	`35`	`}`