Fix await_*() deadlock with already-completed awaitables

When a coroutine or Future had already completed before being passed
to await_all/await_any_or_fail/etc, it was skipped (CLOSED → continue)
but resolved_count was never incremented, so it could never reach
total → deadlock. Fixed by using ZEND_ASYNC_EVENT_REPLAY to replay
the stored result/exception through the normal callback path.

Also breaks out of the loop early when replay already satisfies the
waiting condition, so await_any_or_fail returns immediately instead
of subscribing to remaining awaitables and suspending unnecessarily.

Author: EdmondDantes

CHANGELOG.md

@@ -11,6 +11,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Non-blocking `flock()`**: `flock()` no longer blocks the event loop. The lock operation is offloaded to the libuv thread pool via `zend_async_task_t`, allowing other coroutines to continue executing while waiting for a file lock.
 - **`zend_async_task_new()` API**: New factory function for creating thread pool tasks, registered through the reactor like timer and IO events. Replaces manual `pecalloc` + field initialization.
 
+### Fixed
+- **`await_*()` deadlock with already-completed awaitables**: When a coroutine or Future passed to `await_all()`, `await_any_or_fail()`, or other `await_*()` functions had already completed, it was skipped entirely (`ZEND_ASYNC_EVENT_IS_CLOSED` → `continue`), but `resolved_count` was never incremented. Since `total` still counted the skipped awaitable, `resolved_count` could never reach `total`, causing a deadlock. Fixed by using `ZEND_ASYNC_EVENT_REPLAY` to synchronously replay the stored result/exception through the normal callback path, correctly updating all counters. Additionally, when replay satisfies the waiting condition early (e.g. `await_any_or_fail` needs only one result), the loop now breaks immediately instead of subscribing to remaining awaitables and suspending unnecessarily.
+
 ## [0.6.1] - 2026-03-15
 
 ### Fixed

async_API.c

@@ -968,7 +968,7 @@ void async_await_futures(zval *iterable,
 				return;
 			}
 
-			if (awaitable == NULL || ZEND_ASYNC_EVENT_IS_CLOSED(awaitable)) {
+			if (awaitable == NULL) {
 				continue;
 			}
 
@@ -999,6 +999,21 @@ void async_await_futures(zval *iterable,
 				}
 			}
 
+			/* If the awaitable already completed, replay its stored result/exception
+			 * through the normal callback path so counters update correctly.
+			 * Without this, resolved_count never reaches total → deadlock. */
+			if (ZEND_ASYNC_EVENT_IS_CLOSED(awaitable)) {
+				callback->callback.base.dispose = async_waiting_callback_dispose;
+				await_context->ref_count++;
+				ZEND_ASYNC_EVENT_REPLAY(awaitable, &callback->callback.base);
+
+				if (AWAIT_ITERATOR_IS_FINISHED(await_context)) {
+					break;
+				}
+
+				continue;
+			}
+
 			zend_async_resume_when(coroutine, awaitable, false, NULL, &callback->callback);
 
 			if (UNEXPECTED(EG(exception))) {

tests/await/080-awaitAll_already_completed_coroutine.phpt

@@ -0,0 +1,43 @@
+--TEST--
+await_all() with already completed coroutine does not deadlock
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\await_all;
+use function Async\suspend;
+
+echo "start\n";
+
+$completed = spawn(function() {
+    echo "completed: done\n";
+    return "already_done";
+});
+
+// Let it finish
+suspend();
+
+echo "completed: " . ($completed->isCompleted() ? "true" : "false") . "\n";
+
+$pending = spawn(function() {
+    echo "pending: done\n";
+    return "just_finished";
+});
+
+[$results, $errors] = await_all([$completed, $pending]);
+
+echo "results[0]: " . $results[0] . "\n";
+echo "results[1]: " . $results[1] . "\n";
+echo "errors: " . count($errors) . "\n";
+echo "end\n";
+
+?>
+--EXPECT--
+start
+completed: done
+completed: true
+pending: done
+results[0]: already_done
+results[1]: just_finished
+errors: 0
+end

tests/await/081-awaitAll_already_completed_future.phpt

@@ -0,0 +1,36 @@
+--TEST--
+await_all() with already completed Future does not deadlock
+--FILE--
+<?php
+
+use Async\FutureState;
+use Async\Future;
+use function Async\spawn;
+use function Async\await_all;
+
+echo "start\n";
+
+$state = new FutureState();
+$state->complete("future_result");
+$completed_future = new Future($state);
+
+$pending = spawn(function() {
+    echo "pending: done\n";
+    return "coroutine_result";
+});
+
+[$results, $errors] = await_all([$completed_future, $pending]);
+
+echo "results[0]: " . $results[0] . "\n";
+echo "results[1]: " . $results[1] . "\n";
+echo "errors: " . count($errors) . "\n";
+echo "end\n";
+
+?>
+--EXPECT--
+start
+pending: done
+results[0]: future_result
+results[1]: coroutine_result
+errors: 0
+end

tests/await/082-awaitAll_already_completed_with_exception.phpt

@@ -0,0 +1,48 @@
+--TEST--
+await_all() with already completed coroutine that threw exception does not deadlock
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\await;
+use function Async\await_all;
+
+echo "start\n";
+
+$failed = spawn(function() {
+    throw new RuntimeException("already failed");
+});
+
+// Await to let it finish and handle the exception
+try {
+    await($failed);
+} catch (RuntimeException $e) {
+    echo "caught: " . $e->getMessage() . "\n";
+}
+
+echo "failed: " . ($failed->isCompleted() ? "true" : "false") . "\n";
+
+$pending = spawn(function() {
+    echo "pending: done\n";
+    return "success";
+});
+
+[$results, $errors] = await_all([$failed, $pending]);
+
+echo "results count: " . count($results) . "\n";
+echo "results[1]: " . $results[1] . "\n";
+echo "errors count: " . count($errors) . "\n";
+echo "error[0]: " . $errors[0]->getMessage() . "\n";
+echo "end\n";
+
+?>
+--EXPECT--
+start
+caught: already failed
+failed: true
+pending: done
+results count: 1
+results[1]: success
+errors count: 1
+error[0]: already failed
+end

tests/await/083-awaitAll_all_already_completed.phpt

@@ -0,0 +1,42 @@
+--TEST--
+await_all() with all awaitables already completed does not deadlock
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\await;
+use function Async\await_all;
+
+echo "start\n";
+
+$a = spawn(function() {
+    return "aaa";
+});
+
+$b = spawn(function() {
+    return "bbb";
+});
+
+// Let both finish
+await($a);
+await($b);
+
+echo "a completed: " . ($a->isCompleted() ? "true" : "false") . "\n";
+echo "b completed: " . ($b->isCompleted() ? "true" : "false") . "\n";
+
+[$results, $errors] = await_all([$a, $b]);
+
+echo "results[0]: " . $results[0] . "\n";
+echo "results[1]: " . $results[1] . "\n";
+echo "errors: " . count($errors) . "\n";
+echo "end\n";
+
+?>
+--EXPECT--
+start
+a completed: true
+b completed: true
+results[0]: aaa
+results[1]: bbb
+errors: 0
+end

tests/await/084-awaitAnyOrFail_already_completed_returns_immediately.phpt

@@ -0,0 +1,39 @@
+--TEST--
+await_any_or_fail() with already completed coroutine returns immediately
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\await;
+use function Async\await_any_or_fail;
+use function Async\suspend;
+
+echo "start\n";
+
+$completed = spawn(function() {
+    return "fast";
+});
+
+// Let it finish
+await($completed);
+
+echo "completed: " . ($completed->isCompleted() ? "true" : "false") . "\n";
+
+// This coroutine will never finish on its own
+$slow = spawn(function() {
+    suspend();
+    suspend();
+    suspend();
+    return "slow";
+});
+
+$result = await_any_or_fail([$completed, $slow]);
+echo "result: " . $result . "\n";
+echo "end\n";
+
+?>
+--EXPECT--
+start
+completed: true
+result: fast
+end