Add Fiber-based await() function

Author: clue

README.md

@@ -63,14 +63,8 @@ $result = React\Async\await($promise);
 ```
 
 This function will only return after the given `$promise` has settled, i.e.
-either fulfilled or rejected.
-
-While the promise is pending, this function will assume control over the event
-loop. Internally, it will `run()` the [default loop](https://github.com/reactphp/event-loop#loop)
-until the promise settles and then calls `stop()` to terminate execution of the
-loop. This means this function is more suited for short-lived promise executions
-when using promise-based APIs is not feasible. For long-running applications,
-using promise-based APIs by leveraging chained `then()` calls is usually preferable.
+either fulfilled or rejected. While the promise is pending, this function will 
+suspend the fiber it's called from until the promise is settled.
 
 Once the promise is fulfilled, this function will return whatever the promise
 resolved to.

composer.json

@@ -34,6 +34,9 @@
         "phpunit/phpunit": "^9.3"
     },
     "autoload": {
+        "psr-4": {
+            "React\\Async\\": "src/"
+        },
         "files": [
             "src/functions_include.php"
         ]

src/SimpleFiber.php

@@ -0,0 +1,64 @@
+<?php
+
+namespace React\Async;
+
+use React\EventLoop\Loop;
+
+/**
+ * @internal
+ */
+final class SimpleFiber
+{
+    private static ?\Fiber $scheduler = null;
+    private ?\Fiber $fiber = null;
+
+    public function __construct()
+    {
+        $this->fiber = \Fiber::getCurrent();
+    }
+
+    public function resume(mixed $value): void
+    {
+        if ($this->fiber === null) {
+            Loop::futureTick(static fn() => \Fiber::suspend(static fn() => $value));
+            return;
+        }
+
+        Loop::futureTick(fn() => $this->fiber->resume($value));
+    }
+
+    public function throw(mixed $throwable): void
+    {
+        if (!$throwable instanceof \Throwable) {
+            $throwable = new \UnexpectedValueException(
+                'Promise rejected with unexpected value of type ' . (is_object($throwable) ? get_class($throwable) : gettype($throwable))
+            );
+        }
+
+        if ($this->fiber === null) {
+            Loop::futureTick(static fn() => \Fiber::suspend(static fn() => throw $throwable));
+            return;
+        }
+
+        Loop::futureTick(fn() => $this->fiber->throw($throwable));
+    }
+
+    public function suspend(): mixed
+    {
+        if ($this->fiber === null) {
+            if (self::$scheduler === null || self::$scheduler->isTerminated()) {
+                self::$scheduler = new \Fiber(static fn() => Loop::run());
+                // Run event loop to completion on shutdown.
+                \register_shutdown_function(static function (): void {
+                    if (self::$scheduler->isSuspended()) {
+                        self::$scheduler->resume();
+                    }
+                });
+            }
+
+            return (self::$scheduler->isStarted() ? self::$scheduler->resume() : self::$scheduler->start())();
+        }
+
+        return \Fiber::suspend();
+    }
+}

src/functions.php

@@ -5,6 +5,7 @@
 use React\EventLoop\Loop;
 use React\Promise\CancellablePromiseInterface;
 use React\Promise\Deferred;
+use React\Promise\Promise;
 use React\Promise\PromiseInterface;
 use function React\Promise\reject;
 use function React\Promise\resolve;
@@ -52,48 +53,20 @@
  */
 function await(PromiseInterface $promise): mixed
 {
-    $wait = true;
-    $resolved = null;
-    $exception = null;
-    $rejected = false;
+    $fiber = new SimpleFiber();
 
     $promise->then(
-        function ($c) use (&$resolved, &$wait) {
-            $resolved = $c;
-            $wait = false;
-            Loop::stop();
+        function (mixed $value) use (&$resolved, $fiber): void {
+            $fiber->resume($value);
         },
-        function ($error) use (&$exception, &$rejected, &$wait) {
-            $exception = $error;
-            $rejected = true;
-            $wait = false;
-            Loop::stop();
+        function (mixed $throwable) use (&$resolved, $fiber): void {
+            $fiber->throw($throwable);
         }
     );
 
-    // Explicitly overwrite argument with null value. This ensure that this
-    // argument does not show up in the stack trace in PHP 7+ only.
-    $promise = null;
-
-    while ($wait) {
-        Loop::run();
-    }
-
-    if ($rejected) {
-        // promise is rejected with an unexpected value (Promise API v1 or v2 only)
-        if (!$exception instanceof \Throwable) {
-            $exception = new \UnexpectedValueException(
-                'Promise rejected with unexpected value of type ' . (is_object($exception) ? get_class($exception) : gettype($exception))
-            );
-        }
-
-        throw $exception;
-    }
-
-    return $resolved;
+    return $fiber->suspend();
 }
 
-
 /**
  * Execute a Generator-based coroutine to "await" promises.
  *

tests/AwaitTest.php

@@ -70,20 +70,6 @@ public function testAwaitReturnsValueWhenPromiseIsFullfilled()
         $this->assertEquals(42, React\Async\await($promise));
     }
 
-    public function testAwaitReturnsValueWhenPromiseIsFulfilledEvenWhenOtherTimerStopsLoop()
-    {
-        $promise = new Promise(function ($resolve) {
-            Loop::addTimer(0.02, function () use ($resolve) {
-                $resolve(2);
-            });
-        });
-        Loop::addTimer(0.01, function () {
-            Loop::stop();
-        });
-
-        $this->assertEquals(2, React\Async\await($promise));
-    }
-
     public function testAwaitShouldNotCreateAnyGarbageReferencesForResolvedPromise()
     {
         if (class_exists('React\Promise\When')) {