Only pass args to resolver and canceller if callback requires them

Author: clue

src/Promise.php

@@ -176,15 +176,33 @@ private function unwrap($promise)
 
     private function call(callable $callback)
     {
+        // Use reflection to inspect number of arguments expected by this callback.
+        // We did some careful benchmarking here: Using reflection to avoid unneeded
+        // function arguments is actually faster than blindly passing them.
+        // Also, this helps avoiding unnecessary function arguments in the call stack
+        // if the callback creates an Exception (creating garbage cycles).
+        if (is_array($callback)) {
+            $ref = new \ReflectionMethod($callback[0], $callback[1]);
+        } elseif (is_object($callback) && !$callback instanceof \Closure) {
+            $ref = new \ReflectionMethod($callback, '__invoke');
+        } else {
+            $ref = new \ReflectionFunction($callback);
+        }
+        $args = $ref->getNumberOfParameters();
+
         try {
-            $callback(
-                function ($value = null) {
-                    $this->resolve($value);
-                },
-                function ($reason = null) {
-                    $this->reject($reason);
-                }
-            );
+            if ($args === 0) {
+                $callback();
+            } else {
+                $callback(
+                    function ($value = null) {
+                        $this->resolve($value);
+                    },
+                    function ($reason = null) {
+                        $this->reject($reason);
+                    }
+                );
+            }
         } catch (\Throwable $e) {
             $this->reject($e);
         } catch (\Exception $e) {

tests/PromiseTest.php

@@ -45,4 +45,16 @@ public function shouldRejectIfResolverThrowsException()
         $promise
             ->then($this->expectCallableNever(), $mock);
     }
+
+    /** @test */
+    public function shouldRejectWithoutCreatingGarbageCyclesIfResolverThrowsException()
+    {
+        gc_collect_cycles();
+        $promise = new Promise(function () {
+            throw new \Exception('foo');
+        });
+        unset($promise);
+
+        $this->assertSame(0, gc_collect_cycles());
+    }
 }

tests/PromiseTest/CancelTestTrait.php

@@ -14,15 +14,29 @@ abstract public function getPromiseTestAdapter(callable $canceller = null);
     /** @test */
     public function cancelShouldCallCancellerWithResolverArguments()
     {
-        $mock = $this->createCallableMock();
-        $mock
-            ->expects($this->once())
-            ->method('__invoke')
-            ->with($this->isType('callable'), $this->isType('callable'));
+        $args = null;
+        $adapter = $this->getPromiseTestAdapter(function ($resolve, $reject) use (&$args) {
+            $args = func_get_args();
+        });
 
-        $adapter = $this->getPromiseTestAdapter($mock);
+        $adapter->promise()->cancel();
+
+        $this->assertCount(2, $args);
+        $this->assertTrue(is_callable($args[0]));
+        $this->assertTrue(is_callable($args[1]));
+    }
+
+    /** @test */
+    public function cancelShouldCallCancellerWithoutArgumentsIfNotAccessed()
+    {
+        $args = null;
+        $adapter = $this->getPromiseTestAdapter(function () use (&$args) {
+            $args = func_num_args();
+        });
 
         $adapter->promise()->cancel();
+
+        $this->assertSame(0, $args);
     }
 
     /** @test */