WIP

Author: Nek-

composer.json

@@ -18,7 +18,7 @@
     ],
 
     "require": {
-        "php":                               "^7.2 || 8.0.* || 8.1.* || 8.2.* || 8.3.* || 8.4.*",
+        "php":                               "8.1.* || 8.2.* || 8.3.* || 8.4.*",
         "phpdocumentor/reflection-docblock": "^5.2",
         "sebastian/comparator":              "^3.0 || ^4.0 || ^5.0 || ^6.0 || ^7.0",
         "doctrine/instantiator":             "^1.2 || ^2.0",

src/Prophecy/Doubler/Generator/Node/Type/AbstractType.php

@@ -0,0 +1,8 @@
+<?php
+
+namespace Prophecy\Doubler\Generator\Node\Type;
+
+abstract class AbstractType
+{
+
+}

src/Prophecy/Doubler/Generator/Node/Type/IntersectionType.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Prophecy\Doubler\Generator\Node\Type;
+
+class IntersectionType extends AbstractType
+{
+    private function guard(): void
+    {
+        // Cannot contain void, never or union
+    }
+}

src/Prophecy/Doubler/Generator/Node/Type/SimpleType.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace Prophecy\Doubler\Generator\Node\Type;
+
+class SimpleType extends AbstractType implements \Stringable
+{
+    private $type;
+    public function __construct(string $type)
+    {
+        switch ($type) {
+            // type aliases
+            case 'double':
+            case 'real':
+                return 'float';
+            case 'boolean':
+                return 'bool';
+            case 'integer':
+                return 'int';
+
+            //  built in types
+            case 'self':
+            case 'static':
+            case 'array':
+            case 'callable':
+            case 'bool':
+            case 'false':
+            case 'true':
+            case 'float':
+            case 'int':
+            case 'string':
+            case 'iterable':
+            case 'object':
+            case 'null':
+            case 'mixed':
+            case 'void':
+            case 'never':
+                return $type;
+            default:
+                // Class / Interface type
+                throw new \Exception('TODO');
+                return $this->prefixWithNsSeparator($type);
+        }
+    }
+}

src/Prophecy/Doubler/Generator/Node/Type/UnionType.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace Prophecy\Doubler\Generator\Node\Type;
+
+class UnionType extends AbstractType
+{
+    /**
+     * @param list<AbstractType> $types
+     */
+    public function __construct(private array $types)
+    {
+        $this->guard();
+    }
+
+    /**
+     * @return list<AbstractType>
+     */
+    public function getTypes(): array
+    {
+        return $this->types;
+    }
+    public function isRecursive(): bool
+    {
+        foreach ($this->types as $type) {
+            if ($type instanceof IntersectionType) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private function guard(): void
+    {
+        // Cannot contain void or never
+    }
+}

src/Prophecy/Doubler/Generator/Node/TypeNodeAbstract.php

@@ -2,21 +2,45 @@
 
 namespace Prophecy\Doubler\Generator\Node;
 
+use Prophecy\Doubler\Generator\Node\Type\AbstractType;
+use Prophecy\Doubler\Generator\Node\Type\SimpleType;
+use Prophecy\Doubler\Generator\Node\Type\UnionType;
 use Prophecy\Exception\Doubler\DoubleException;
 
 abstract class TypeNodeAbstract
 {
-    /** @var array<string, string> */
-    protected $types = [];
+    protected AbstractType $type;
 
-    public function __construct(string ...$types)
+    /**
+     * @param string|AbstractType ...$types
+     */
+    public function __construct(string|AbstractType ...$types)
     {
-        foreach ($types as $type) {
-            $type = $this->getRealType($type);
-            $this->types[$type] = $type;
+        $deprecation = 'Only 1 type will be supported in the future, strings are no longer supported as type.';
+        if (count($types) !== 1) {
+            // TODO: trigger deprecation notice
+        } else {
+            foreach ($types as $type) {
+                if (!$type instanceof AbstractType) {
+                    // TODO: deprecation notice
+                    break;
+                }
+            }
         }
 
-        $this->guardIsValidType();
+        // BC Layer for usage with strings
+        foreach ($types as $index => $type) {
+            if (is_string($type)) {
+                $types[$index] = new SimpleType($type);
+            }
+        }
+
+        // BC Layer for usage with many types
+        if (count($types) > 1) {
+            $this->type = new UnionType($types);
+        } else {
+            $this->type = $types[0];
+        }
     }
 
     public function canUseNullShorthand(): bool
@@ -26,17 +50,36 @@ public function canUseNullShorthand(): bool
 
     /**
      * @return list<string>
+     * @deprecated use getType() instead
      */
     public function getTypes(): array
     {
-        return array_values($this->types);
+        // TODO: add deprecation notice
+        if ($this->type instanceof SimpleType) {
+            return [(string) $this->type];
+        }
+
+        if ($this->type instanceof UnionType && $this->type->isSimple()) {
+            foreach ($this->type->getTypes() as $type) {
+                $types[] = (string) $type;
+            }
+        }
+
+        return $types;
+    }
+
+    public function getType(): AbstractType
+    {
+        return $this->type;
     }
 
     /**
+     * @deprecated use getType() instead
      * @return list<string>
      */
     public function getNonNullTypes(): array
     {
+        // @fixme
         $nonNullTypes = $this->types;
         unset($nonNullTypes['null']);
 
@@ -60,7 +103,7 @@ protected function getRealType(string $type): string
             case 'integer':
                 return 'int';
 
-                //  built in types
+            //  built in types
             case 'self':
             case 'static':
             case 'array':
@@ -74,16 +117,18 @@ protected function getRealType(string $type): string
             case 'iterable':
             case 'object':
             case 'null':
-                return $type;
             case 'mixed':
-                return \PHP_VERSION_ID < 80000 ? $this->prefixWithNsSeparator($type) : $type;
-
+            case 'void':
+            case 'never':
+                return $type;
             default:
+                // Class / Interface type
                 return $this->prefixWithNsSeparator($type);
         }
     }
 
     /**
+     * @todo: put this in SimpleType
      * @return void
      */
     protected function guardIsValidType()