Extend _checkTypehint support for PHP8.1's intersection types

Author: bzikarsky

src/functions.php

@@ -354,6 +354,8 @@ function _checkTypehint(callable $callback, $object)
 
     // Extract the type of the argument and handle different possibilities
     $type = $expectedException->getType();
+    
+    $isTypeUnion = true;
     $types = [];
 
     switch (true) {
@@ -362,6 +364,8 @@ function _checkTypehint(callable $callback, $object)
         case $type instanceof \ReflectionNamedType:
             $types = [$type];
             break;
+        case $type instanceof \ReflectionIntersectionType:
+            $isTypeUnion = false;
         case $type instanceof \ReflectionUnionType;
             $types = $type->getTypes();
             break;
@@ -374,16 +378,30 @@ function _checkTypehint(callable $callback, $object)
         return true;
     }
 
-    // Search for one matching named-type for success, otherwise return false
-    // A named-type can be either a class-name or a built-in type like string, int, array, etc.
     foreach ($types as $type) {
+        if (!$type instanceof \ReflectionNamedType) {
+            throw new \LogicException('This implementation does not support groups of intersection or union types');
+        }
+
+        // A named-type can be either a class-name or a built-in type like string, int, array, etc.
         $matches = ($type->isBuiltin() && \gettype($object) === $type->getName())
             || (new \ReflectionClass($type->getName()))->isInstance($object);
 
+
+        // If we look for a single match (union), we can return early on match
+        // If we look for a full match (intersection), we can return early on mismatch
         if ($matches) {
-            return true;
+            if ($isTypeUnion) {
+                return true;
+            }
+        } else {
+            if (!$isTypeUnion) {
+                return false;
+            }
         }
     }
 
-    return false;
+    // If we look for a single match (union) and did not return early, we matched no type and are false
+    // If we look for a full match (intersection) and did not return early, we matched all types and are true
+    return $isTypeUnion ? false : true;
 }

tests/FunctionCheckTypehintTest.php

@@ -84,6 +84,39 @@ public function shouldAcceptStaticClassCallbackWithUnionTypehint()
         self::assertFalse(_checkTypehint(['React\Promise\CallbackWithUnionTypehintClass', 'testCallbackStatic'], new \Exception()));
     }
 
+    /**
+     * @test
+     * @requires PHP 8.1
+     */
+    public function shouldAcceptInvokableObjectCallbackWithIntersectionTypehint()
+    {
+        self::assertFalse(_checkTypehint(new CallbackWithIntersectionTypehintClass(), new \RuntimeException()));
+        self::assertFalse(_checkTypehint(new CallbackWithIntersectionTypehintClass(), new CountableNonException()));
+        self::assertTrue(_checkTypehint(new CallbackWithIntersectionTypehintClass(), new CountableException()));
+    }
+
+    /**
+     * @test
+     * @requires PHP 8.1
+     */
+    public function shouldAcceptObjectMethodCallbackWithIntersectionTypehint()
+    {
+        self::assertFalse(_checkTypehint([new CallbackWithIntersectionTypehintClass(), 'testCallback'], new \RuntimeException()));
+        self::assertFalse(_checkTypehint([new CallbackWithIntersectionTypehintClass(), 'testCallback'], new CountableNonException()));
+        self::assertTrue(_checkTypehint([new CallbackWithIntersectionTypehintClass(), 'testCallback'], new CountableException()));
+    }
+
+    /**
+     * @test
+     * @requires PHP 8.1
+     */
+    public function shouldAcceptStaticClassCallbackWithIntersectionTypehint()
+    {
+        self::assertFalse(_checkTypehint(['React\Promise\CallbackWithIntersectionTypehintClass', 'testCallbackStatic'], new \RuntimeException()));
+        self::assertFalse(_checkTypehint(['React\Promise\CallbackWithIntersectionTypehintClass', 'testCallbackStatic'], new CountableNonException()));
+        self::assertTrue(_checkTypehint(['React\Promise\CallbackWithIntersectionTypehintClass', 'testCallbackStatic'], new CountableException()));
+    }
+
     /** @test */
     public function shouldAcceptClosureCallbackWithoutTypehint()
     {

tests/fixtures/CallbackWithIntersectionTypehintClass.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace React\Promise;
+
+use Countable;
+use RuntimeException;
+
+class CallbackWithIntersectionTypehintClass
+{
+    public function __invoke(RuntimeException&Countable $e)
+    {
+    }
+
+    public function testCallback(RuntimeException&Countable $e)
+    {
+    }
+
+    public static function testCallbackStatic(RuntimeException&Countable $e)
+    {
+    }
+}

tests/fixtures/CountableException.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace React\Promise;
+
+use Countable;
+use RuntimeException;
+
+class CountableException extends RuntimeException implements Countable
+{
+    public function count()
+    {
+        return 0;
+    }
+}
+

tests/fixtures/CountableNonException.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace React\Promise;
+
+use Countable;
+use RuntimeException;
+
+class CountableNonException implements Countable
+{
+    public function count()
+    {
+        return 0;
+    }
+}
+