#23: * Adjustment of Scope: By default, the Scope is created in safely dispose mode.

Author: EdmondDantes

scheduler.c

@@ -891,7 +891,7 @@ void async_scheduler_coroutine_suspend(zend_fiber_transfer *transfer)
 	if (UNEXPECTED(
 		false == has_handles
 		&& false == is_next_coroutine
-		&& ZEND_ASYNC_ACTIVE_COROUTINE_COUNT > 0
+		&& zend_hash_num_elements(&ASYNC_G(coroutines)) > 0
 		&& circular_buffer_is_empty(&ASYNC_G(microtasks))
 		&& resolve_deadlocks()
 		)) {
@@ -955,7 +955,7 @@ void async_scheduler_main_loop(void)
 			if (UNEXPECTED(
 				false == has_handles
 				&& false == was_executed
-				&& ZEND_ASYNC_ACTIVE_COROUTINE_COUNT > 0
+				&& zend_hash_num_elements(&ASYNC_G(coroutines)) > 0
 				&& circular_buffer_is_empty(&ASYNC_G(coroutine_queue))
 				&& circular_buffer_is_empty(&ASYNC_G(microtasks))
 				&& resolve_deadlocks()

scope.c

@@ -63,12 +63,10 @@ async_scope_remove_coroutine(async_scope_t *scope, async_coroutine_t *coroutine)
 	for (uint32_t i = 0; i < vector->length; ++i) {
 		if (vector->data[i] == coroutine) {
 			// Decrement active coroutines count if coroutine was active
-			if (false == ZEND_COROUTINE_IS_ZOMBIE(&coroutine->coroutine)) {
-				if (scope->active_coroutines_count > 0) {
-					scope->active_coroutines_count--;
-				} else if (scope->zombie_coroutines_count > 0) {
-					scope->zombie_coroutines_count--;
-				}
+			if (false == ZEND_COROUTINE_IS_ZOMBIE(&coroutine->coroutine) && scope->active_coroutines_count > 0) {
+				scope->active_coroutines_count--;
+			} else if (scope->zombie_coroutines_count > 0) {
+				scope->zombie_coroutines_count--;
 			}
 
 			vector->data[i] = vector->data[--vector->length];
@@ -1087,6 +1085,12 @@ static zend_string* scope_info(zend_async_event_t *event)
 
 static void scope_dispose(zend_async_event_t *scope_event)
 {
+	async_scope_t *scope = (async_scope_t *) scope_event;
+
+	if (ZEND_ASYNC_SCOPE_IS_DISPOSING(&scope->scope)) {
+		return;
+	}
+
 	if (ZEND_ASYNC_EVENT_REF(scope_event) > 1) {
 		ZEND_ASYNC_EVENT_DEL_REF(scope_event);
 		return;
@@ -1096,16 +1100,31 @@ static void scope_dispose(zend_async_event_t *scope_event)
 		ZEND_ASYNC_EVENT_DEL_REF(scope_event);
 	}
 
-	async_scope_t *scope = (async_scope_t *) scope_event;
+	ZEND_ASYNC_SCOPE_SET_DISPOSING(&scope->scope);
 
 	ZEND_ASSERT(scope->coroutines.length == 0 && scope->scope.scopes.length == 0
 		&& "Scope should be empty before disposal");
 
+	zend_object *critical_exception = NULL;
+
+	//
+	// Notifying subscribers one last time that the scope has been definitively completed.
+	//
+	ZEND_ASYNC_CALLBACKS_NOTIFY(scope_event, NULL, NULL);
+	zend_async_callbacks_free(&scope->scope.event);
+	if (UNEXPECTED(EG(exception))) {
+		critical_exception = zend_exception_merge(critical_exception, true, true);
+	}
+
 	if (scope->finally_handlers != NULL
 		&& zend_hash_num_elements(scope->finally_handlers) > 0
 		&& async_scope_call_finally_handlers(scope)) {
 		// If finally handlers were called, we don't dispose the scope yet
 		ZEND_ASYNC_EVENT_ADD_REF(&scope->scope.event);
+		if (critical_exception) {
+			async_spawn_and_throw(critical_exception, &scope->scope, 0);
+		}
+		ZEND_ASYNC_SCOPE_CLR_DISPOSING(&scope->scope);
 		return;
 	}
 
@@ -1153,6 +1172,10 @@ static void scope_dispose(zend_async_event_t *scope_event)
 	async_scope_free_coroutines(scope);
 	zend_async_scope_free_children(&scope->scope);
 	efree(scope);
+
+	if (critical_exception != NULL) {
+		async_rethrow_exception(critical_exception);
+	}
 }
 
 zend_async_scope_t * async_new_scope(zend_async_scope_t * parent_scope, const bool with_zend_object)
@@ -1181,6 +1204,11 @@ zend_async_scope_t * async_new_scope(zend_async_scope_t * parent_scope, const bo
 	scope->scope.parent_scope = parent_scope;
 	zend_async_event_t *event = &scope->scope.event;
 
+	// Inherit safely disposal flag from parent scope or set it to true if parent scope is NULL
+	if (parent_scope == NULL || ZEND_ASYNC_SCOPE_IS_DISPOSE_SAFELY(parent_scope)) {
+		ZEND_ASYNC_SCOPE_SET_DISPOSE_SAFELY(&scope->scope);
+	}
+
 	event->ref_count = 1; // Initialize reference count
 
 	scope->scope.before_coroutine_enqueue = scope_before_coroutine_enqueue;

tests/edge_cases/010-deadlock-after-cancel-with-zombie.phpt

@@ -0,0 +1,65 @@
+--TEST--
+Deadlock - Deadlock is an operation after coroutines are cancelled, when they are already zombies.
+--FILE--
+<?php
+
+use function Async\spawn;
+use function Async\await;
+use function Async\suspend;
+use Async\Scope;
+
+echo "start\n";
+
+$scope = new Scope();
+
+$coroutine1 = null;
+$coroutine2 = null;
+
+$coroutine1 = $scope->spawn(function() use (&$coroutine2) {
+    echo "coroutine1 running\n";
+    suspend();
+
+    try {
+        await($coroutine2);
+    } catch (Throwable $e) {
+        echo "Caught exception: " . $e->getMessage() . "\n";
+    }
+
+    suspend();
+
+    echo "coroutine1 finished\n";
+});
+
+$coroutine2 = $scope->spawn(function() use ($coroutine1) {
+    echo "coroutine2 running\n";
+    suspend();
+    try {
+        await($coroutine1);
+    } catch (Throwable $e) {
+        echo "Caught exception: " . $e->getMessage() . "\n";
+    }
+
+    suspend();
+
+    echo "coroutine2 finished\n";
+});
+
+suspend(); // Suspend the main coroutine to allow the others to run
+$scope->dispose(); // This will cancel the coroutines, making them zombies
+
+echo "end\n";
+?>
+--EXPECTF--
+start
+coroutine1 running
+coroutine2 running
+end
+
+Warning: no active coroutines, deadlock detected. Coroutines in waiting: 2 in %s on line %d
+
+Warning: the coroutine was suspended in file: %s, line: %d will be canceled in %s on line %d
+
+Warning: the coroutine was suspended in file: %s, line: %d will be canceled in %s on line %d
+Caught exception: Deadlock detected
+coroutine1 finished
+coroutine2 finished

tests/scope/024-scope_awaitAfterCancellation_basic.phpt

@@ -60,6 +60,8 @@ coroutine1 started
 coroutine2 started
 scope cancelled
 external waiting after cancellation
+coroutine1 finished
+coroutine2 finished
 awaitAfterCancellation completed
 scope finished: true
 scope closed: true

tests/scope/025-scope_awaitAfterCancellation_error_handler.phpt

@@ -71,9 +71,8 @@ error coroutine started
 normal coroutine started
 external waiting with error handler
 scope cancel
-coroutine cancelled
 awaitAfterCancellation with handler started
-error handler called: Coroutine error after cancellation
+normal coroutine finished
 awaitAfterCancellation with handler completed
 scope finished: true
 end

tests/scope/026-scope_cancel_with_active_coroutines.phpt

@@ -10,7 +10,7 @@ use Async\Scope;
 echo "start\n";
 
 // Test comprehensive cancellation behavior
-$scope = Scope::inherit();
+$scope = Scope::inherit()->asNotSafely();
 
 $coroutine1 = $scope->spawn(function() {
     echo "coroutine1 started\n";

tests/scope/029-scope_complex_tree_cancellation.phpt

@@ -10,7 +10,7 @@ use function Async\await;
 echo "start\n";
 
 // Create complex scope tree: parent -> child -> grandchild -> great-grandchild
-$parent_scope = new \Async\Scope();
+$parent_scope = new \Async\Scope()->asNotSafely();
 $child_scope = \Async\Scope::inherit($parent_scope);
 $grandchild_scope = \Async\Scope::inherit($child_scope);
 $great_grandchild_scope = \Async\Scope::inherit($grandchild_scope);

tests/scope/033-scope_cancellation_finally_handlers.phpt

@@ -9,7 +9,7 @@ use function Async\await;
 
 echo "start\n";
 
-$scope = new \Async\Scope();
+$scope = new \Async\Scope()->asNotSafely();
 
 // Spawn coroutine with finally handlers
 $coroutine_with_finally = $scope->spawn(function() {