Add support of intersection for return type

Author: Nek-

spec/Prophecy/Doubler/Generator/ClassCodeGeneratorSpec.php

@@ -10,6 +10,9 @@
 use Prophecy\Doubler\Generator\Node\ClassNode;
 use Prophecy\Doubler\Generator\Node\MethodNode;
 use Prophecy\Doubler\Generator\Node\ReturnTypeNode;
+use Prophecy\Doubler\Generator\Node\Type\IntersectionType;
+use Prophecy\Doubler\Generator\Node\Type\SimpleType;
+use Prophecy\Doubler\Generator\Node\Type\UnionType;
 
 class ClassCodeGeneratorSpec extends ObjectBehavior
 {
@@ -115,10 +118,10 @@ class CustomClass extends \RuntimeException implements \Prophecy\Doubler\Generat
 public $name;
 private $email;
 
-public static function getName(array $fullname, \ReflectionClass $class, object $instance): ?string {
+public static function getName(array $fullname, \ReflectionClass $class, object $instance): string|null {
 return $this->name;
 }
-protected  function getEmail(?string $default = '[email protected]') {
+protected  function getEmail(string|null $default = '[email protected]') {
 return $this->email;
 }
 public  function &getRefValue( $refValue): string {
@@ -271,7 +274,7 @@ function it_overrides_properly_methods_with_args_passed_by_reference(
 namespace  {
 class CustomClass extends \RuntimeException implements \Prophecy\Doubler\Generator\MirroredInterface {
 
-public  function getName(?array &$fullname = NULL) {
+public  function getName(array|null &$fullname = NULL) {
 return $this->name;
 }
 
@@ -310,6 +313,47 @@ public  function foo(): int|string|null {
 
 }
 
+}
+}
+PHP;
+        $expected = strtr($expected, array("\r\n" => "\n", "\r" => "\n"));
+
+        $code->shouldBe($expected);
+    }
+
+    function it_generates_proper_code_for_intersection_return_types(
+        ClassNode $class,
+        MethodNode $method
+    ) {
+        $class->getParentClass()->willReturn('stdClass');
+        $class->getInterfaces()->willReturn([]);
+        $class->getProperties()->willReturn([]);
+        $class->getMethods()->willReturn(array($method));
+        $class->isReadOnly()->willReturn(false);
+
+        $method->getName()->willReturn('foo');
+        $method->getVisibility()->willReturn('public');
+        $method->isStatic()->willReturn(false);
+        $method->getArguments()->willReturn([]);
+        $method->getReturnTypeNode()->willReturn(new ReturnTypeNode(
+            new UnionType([
+                new IntersectionType([new SimpleType('Foo'), new SimpleType('Bar')]),
+                new SimpleType('string')
+            ])
+        ));
+        $method->returnsReference()->willReturn(false);
+        $method->getCode()->willReturn('');
+
+        $code = $this->generate('CustomClass', $class);
+
+        $expected = <<<'PHP'
+namespace  {
+class CustomClass extends \stdClass implements  {
+
+public  function foo(): \Foo&\Bar|string {
+
+}
+
 }
 }
 PHP;

src/Prophecy/Doubler/Generator/ClassCodeGenerator.php

@@ -12,7 +12,12 @@
 namespace Prophecy\Doubler\Generator;
 
 use Prophecy\Doubler\Generator\Node\ReturnTypeNode;
+use Prophecy\Doubler\Generator\Node\Type\IntersectionType;
+use Prophecy\Doubler\Generator\Node\Type\SimpleType;
+use Prophecy\Doubler\Generator\Node\Type\TypeInterface;
+use Prophecy\Doubler\Generator\Node\Type\UnionType;
 use Prophecy\Doubler\Generator\Node\TypeNodeAbstract;
+use Prophecy\Exception\Doubler\ClassCreatorException;
 
 /**
  * Class code creator.
@@ -78,16 +83,36 @@ private function generateMethod(Node\MethodNode $method): string
 
     private function generateTypes(TypeNodeAbstract $typeNode): string
     {
-        if (!$typeNode->getTypes()) {
+        if ($typeNode->getType() === null) {
             return '';
         }
 
-        // When we require PHP 8 we can stop generating ?foo nullables and remove this first block
-        if ($typeNode->canUseNullShorthand()) {
-            return sprintf('?%s', $typeNode->getNonNullTypes()[0]);
-        } else {
-            return join('|', $typeNode->getTypes());
+        $generatedType = $this->generateSubType($typeNode->getType());
+
+        return $generatedType;
+    }
+
+    private function generateSubType(TypeInterface $type): string
+    {
+        if ($type instanceof SimpleType) {
+            return $type->getType();
         }
+
+        if ($type instanceof UnionType) {
+            return join('|', array_map(
+                fn (TypeInterface $type) => $this->generateSubType($type),
+                $type->getTypes()
+            ));
+        }
+
+        if ($type instanceof IntersectionType) {
+            return join('&', array_map(
+                fn(SimpleType $type) => $type->getType(),
+                $type->getTypes()
+            ));
+        }
+
+        throw new ClassCreatorException(sprintf('Type "%s" is not supported.', get_class($type)));
     }
 
     /**

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

@@ -207,7 +207,7 @@ public function getReturnTypeNode(): ReturnTypeNode
      */
     public function hasNullableReturnType()
     {
-        return $this->returnTypeNode->canUseNullShorthand();
+        return $this->returnTypeNode->nullable();
     }
 
     /**

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

@@ -52,6 +52,9 @@ public function __construct(string|TypeInterface ...$types)
         }
     }
 
+    /**
+     * @deprecated use nullable() instead
+     */
     public function canUseNullShorthand(): bool
     {
         if ($this->type instanceof UnionType) {
@@ -61,6 +64,19 @@ public function canUseNullShorthand(): bool
         return false;
     }
 
+    public function nullable()
+    {
+        if ($this->type instanceof UnionType) {
+            return $this->type->has(new SimpleType('null'));
+        }
+
+        if ($this->type instanceof SimpleType && $this->type->getType() === 'null') {
+            return true;
+        }
+
+        return false;
+    }
+
     /**
      * @return list<string>
      * @deprecated use getType() instead
@@ -86,7 +102,7 @@ public function getTypes(): array
         return array_values($types);
     }
 
-    public function getType(): TypeInterface
+    public function getType(): ?TypeInterface
     {
         return $this->type;
     }

tests/Doubler/Generator/ClassMirrorTest.php

@@ -744,7 +744,7 @@ public function it_can_not_double_dnf_intersection_argument_types()
      * @todo: remove this test and test it works!
      * test
      */
-    public function it_can_not_double_dnf_intersection_return_types()
+    public function it_can_double_dnf_intersection_return_types()
     {
         if (PHP_VERSION_ID < 80200) {
             $this->markTestSkipped('DNF intersection types are not supported in this PHP version');