Deduplicate double entries in a compound

When writing a compound type (i.e. `int|int|bool`) you can use
duplicates. These duplicates have no function and will only add extra
complexity for consuming applications. As such I have introduced
deduplication into the compound type and improved type safety by means
of a private `add` function.

The new `add` function is private by design as we want our Value Objects
immutable and this is only used internally for type checking and
deduplication.

Author: Mike van Riel

src/Types/Compound.php

@@ -29,25 +29,18 @@
 final class Compound implements Type, IteratorAggregate
 {
     /** @var Type[] */
-    private $types;
+    private $types = [];
 
     /**
      * Initializes a compound type (i.e. `string|int`) and tests if the provided types all implement the Type interface.
      *
      * @param Type[] $types
-     *
-     * @throws InvalidArgumentException When types are not all instance of Type.
      */
     public function __construct(array $types)
     {
         foreach ($types as $type) {
-            /** @psalm-suppress RedundantConditionGivenDocblockType */
-            if (!$type instanceof Type) {
-                throw new InvalidArgumentException('A compound type can only have other types as elements');
-            }
+            $this->add($type);
         }
-
-        $this->types = $types;
     }
 
     /**
@@ -70,6 +63,21 @@ public function has(int $index) : bool
         return isset($this->types[$index]);
     }
 
+    /**
+     * Tests if this compound type contains the given type.
+     */
+    public function contains(Type $type): bool
+    {
+        foreach ($this->types as $typePart) {
+            // if the type is duplicate; do not add it
+            if ((string) $typePart === (string) $type) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
     /**
      * Returns a rendered output of the Type as it would be used in a DocBlock.
      */
@@ -85,4 +93,14 @@ public function getIterator()
     {
         return new ArrayIterator($this->types);
     }
+
+    private function add(Type $type): void
+    {
+        // if the type is duplicate; do not add it
+        if ($this->contains($type)) {
+            return;
+        }
+
+        $this->types[] = $type;
+    }
 }

tests/unit/Types/CompoundTest.php

@@ -18,15 +18,14 @@
 /**
  * @coversDefaultClass \phpDocumentor\Reflection\Types\Compound
  */
-class CompoundTest extends TestCase
+final class CompoundTest extends TestCase
 {
     /**
      * @covers ::__construct
      */
     public function testCompoundCannotBeConstructedFromType() : void
     {
-        $this->expectException('InvalidArgumentException');
-        $this->expectExceptionMessage('A compound type can only have other types as elements');
+        $this->expectException(\TypeError::class);
         new Compound(['foo']);
     }
 
@@ -61,7 +60,7 @@ public function testCompoundGetNotExistingType() : void
      *
      * @covers ::has
      */
-    public function testCompoundHasType() : void
+    public function testCompoundHasIndex() : void
     {
         $this->assertTrue((new Compound([new Integer()]))->has(0));
     }
@@ -71,11 +70,34 @@ public function testCompoundHasType() : void
      *
      * @covers ::has
      */
-    public function testCompoundHasNotExistingType() : void
+    public function testCompoundDoesNotHasIndex() : void
     {
         $this->assertFalse((new Compound([]))->has(0));
     }
 
+    /**
+     * @uses \phpDocumentor\Reflection\Types\Compound::__construct
+     * @uses \phpDocumentor\Reflection\Types\Integer
+     *
+     * @covers ::contains
+     */
+    public function testCompoundContainsType() : void
+    {
+        $this->assertTrue((new Compound([new Integer()]))->contains(new Integer()));
+    }
+
+    /**
+     * @uses \phpDocumentor\Reflection\Types\Compound::__construct
+     * @uses \phpDocumentor\Reflection\Types\Integer
+     * @uses \phpDocumentor\Reflection\Types\String_
+     *
+     * @covers ::contains
+     */
+    public function testCompoundDoesNotContainType() : void
+    {
+        $this->assertFalse((new Compound([new Integer()]))->contains(new String_()));
+    }
+
     /**
      * @uses \phpDocumentor\Reflection\Types\Integer
      * @uses \phpDocumentor\Reflection\Types\Boolean
@@ -88,6 +110,21 @@ public function testCompoundCanBeConstructedAndStringifiedCorrectly() : void
         $this->assertSame('int|bool', (string) (new Compound([new Integer(), new Boolean()])));
     }
 
+    /**
+     * @uses \phpDocumentor\Reflection\Types\Integer
+     * @uses \phpDocumentor\Reflection\Types\Boolean
+     *
+     * @covers ::__construct
+     * @covers ::__toString
+     */
+    public function testCompoundDoesNotContainDuplicates() : void
+    {
+        $compound = new Compound([new Integer(), new Integer(), new Boolean()]);
+
+        $this->assertCount(2, iterator_to_array($compound));
+        $this->assertSame('int|bool', (string) $compound);
+    }
+
     /**
      * @uses \phpDocumentor\Reflection\Types\Compound::__construct
      * @uses \phpDocumentor\Reflection\Types\Integer