Revert "Call handler when waiting on fulfilled/rejected Promise (#135)…

…" (#146)

This reverts commit 9c0acf5.

src/FulfilledPromise.php

@@ -12,12 +12,6 @@ class FulfilledPromise implements PromiseInterface
 {
     private $value;
 
-    /** @var Promise|null */
-    private $promise;
-
-    /** @var callable|null */
-    private $onFulfilled;
-
     public function __construct($value)
     {
         if (is_object($value) && method_exists($value, 'then')) {
@@ -38,14 +32,18 @@ public function then(
             return $this;
         }
 
-        $this->onFulfilled = $onFulfilled;
-
         $queue = Utils::queue();
-        $p = $this->promise = new Promise([$queue, 'run']);
+        $p = new Promise([$queue, 'run']);
         $value = $this->value;
         $queue->add(static function () use ($p, $value, $onFulfilled) {
             if (Is::pending($p)) {
-                self::callHandler($p, $value, $onFulfilled);
+                try {
+                    $p->resolve($onFulfilled($value));
+                } catch (\Throwable $e) {
+                    $p->reject($e);
+                } catch (\Exception $e) {
+                    $p->reject($e);
+                }
             }
         });
 
@@ -59,11 +57,6 @@ public function otherwise(callable $onRejected)
 
     public function wait($unwrap = true, $defaultDelivery = null)
     {
-        // Don't run the queue to avoid deadlocks, instead directly resolve the promise.
-        if ($this->promise && Is::pending($this->promise)) {
-            self::callHandler($this->promise, $this->value, $this->onFulfilled);
-        }
-
         return $unwrap ? $this->value : null;
     }
 
@@ -88,15 +81,4 @@ public function cancel()
     {
         // pass
     }
-
-    private static function callHandler(Promise $promise, $value, callable $handler)
-    {
-        try {
-            $promise->resolve($handler($value));
-        } catch (\Throwable $e) {
-            $promise->reject($e);
-        } catch (\Exception $e) {
-            $promise->reject($e);
-        }
-    }
 }

src/RejectedPromise.php

@@ -12,12 +12,6 @@ class RejectedPromise implements PromiseInterface
 {
     private $reason;
 
-    /** @var Promise|null */
-    private $promise;
-
-    /** @var callable|null */
-    private $onRejected;
-
     public function __construct($reason)
     {
         if (is_object($reason) && method_exists($reason, 'then')) {
@@ -38,14 +32,21 @@ public function then(
             return $this;
         }
 
-        $this->onRejected = $onRejected;
-
         $queue = Utils::queue();
         $reason = $this->reason;
-        $p = $this->promise = new Promise([$queue, 'run']);
+        $p = new Promise([$queue, 'run']);
         $queue->add(static function () use ($p, $reason, $onRejected) {
             if (Is::pending($p)) {
-                self::callHandler($p, $reason, $onRejected);
+                try {
+                    // Return a resolved promise if onRejected does not throw.
+                    $p->resolve($onRejected($reason));
+                } catch (\Throwable $e) {
+                    // onRejected threw, so return a rejected promise.
+                    $p->reject($e);
+                } catch (\Exception $e) {
+                    // onRejected threw, so return a rejected promise.
+                    $p->reject($e);
+                }
             }
         });
 
@@ -63,11 +64,6 @@ public function wait($unwrap = true, $defaultDelivery = null)
             throw Create::exceptionFor($this->reason);
         }
 
-        // Don't run the queue to avoid deadlocks, instead directly reject the promise.
-        if ($this->promise && Is::pending($this->promise)) {
-            self::callHandler($this->promise, $this->reason, $this->onRejected);
-        }
-
         return null;
     }
 
@@ -92,15 +88,4 @@ public function cancel()
     {
         // pass
     }
-
-    private static function callHandler(Promise $promise, $reason, callable $handler)
-    {
-        try {
-            $promise->resolve($handler($reason));
-        } catch (\Throwable $e) {
-            $promise->reject($e);
-        } catch (\Exception $e) {
-            $promise->reject($e);
-        }
-    }
 }

tests/FulfilledPromiseTest.php

@@ -81,17 +81,6 @@ public function testAsynchronouslyInvokesOnFulfilled()
         $this->assertSame('a', $r);
     }
 
-    public function testInvokesOnFulfilledOnWait()
-    {
-        $p = new FulfilledPromise('a');
-        $r = null;
-        $f = function ($d) use (&$r) { $r = $d; };
-        $p->then($f);
-        $this->assertNull($r);
-        $p->wait();
-        $this->assertSame('a', $r);
-    }
-
     public function testReturnsNewRejectedWhenOnFulfilledFails()
     {
         $p = new FulfilledPromise('a');
@@ -120,6 +109,5 @@ public function testDoesNotTryToFulfillTwiceDuringTrampoline()
         $t1 = $fp->then(function ($v) { return $v . ' b'; });
         $t1->resolve('why!');
         $this->assertSame('why!', $t1->wait());
-        P\Utils::queue()->run();
     }
 }

tests/RejectedPromiseTest.php

@@ -97,17 +97,6 @@ public function testInvokesOnRejectedAsynchronously()
         $this->assertSame('a', $r);
     }
 
-    public function testInvokesOnRejectedOnWait()
-    {
-        $p = new RejectedPromise('a');
-        $r = null;
-        $f = function ($reason) use (&$r) { $r = $reason; };
-        $p->then(null, $f);
-        $this->assertNull($r);
-        $p->wait(false);
-        $this->assertSame('a', $r);
-    }
-
     public function testReturnsNewRejectedWhenOnRejectedFails()
     {
         $p = new RejectedPromise('a');
@@ -156,6 +145,5 @@ public function testDoesNotTryToRejectTwiceDuringTrampoline()
         $t1 = $fp->then(null, function ($v) { return $v . ' b'; });
         $t1->resolve('why!');
         $this->assertSame('why!', $t1->wait());
-        P\Utils::queue()->run();
     }
 }