new approach

Author: jakkdl

src/trio/_core/_run.py

@@ -1261,6 +1261,9 @@ def _child_finished(
         outcome: Outcome[object],
     ) -> None:
         self._children.remove(task)
+        if self._closed and not hasattr(self, "_pending_excs"):
+            # We're abandoned by misnested nurseries, the result of the task is lost.
+            return
         if isinstance(outcome, Error):
             self._add_exc(
                 outcome.error,
@@ -2007,45 +2010,24 @@ async def python_wrapper(orig_coro: Awaitable[RetT]) -> RetT:
         return task
 
     def task_exited(self, task: Task, outcome: Outcome[object]) -> None:
+        if task._child_nurseries:
+            for nursery in task._child_nurseries:
+                nursery.cancel_scope.cancel()  # TODO: add reason
+                nursery._parent_waiting_in_aexit = False
+                nursery._closed = True
+
         # break parking lots associated with the exiting task
         if task in GLOBAL_PARKING_LOT_BREAKER:
             for lot in GLOBAL_PARKING_LOT_BREAKER[task]:
                 lot.break_lot(task)
             del GLOBAL_PARKING_LOT_BREAKER[task]
 
-        if task._child_nurseries:
-            # Forcefully abort any tasks spawned by the misnested nursery to
-            # avoid internal errors.
-            runner = GLOBAL_RUN_CONTEXT.runner
-            for nursery in task._child_nurseries:
-                for child in nursery._children.copy():
-                    if child in runner.runq:
-                        runner.runq.remove(child)
-                        self.task_exited(
-                            child,
-                            Error(
-                                RuntimeError(
-                                    f"Task {child} aborted after nursery was destroyed due to misnesting."
-                                )
-                            ),
-                        )
-                assert not nursery._children
-            try:
-                # Raise this, rather than just constructing it, to get a
-                # traceback frame included
-                raise RuntimeError(
-                    "Nursery stack corrupted: nurseries spawned by "
-                    f"{task!r} was still live when the task exited\n{MISNESTING_ADVICE}",
-                )
-            except RuntimeError as new_exc:
-                if isinstance(outcome, Error):
-                    new_exc.__context__ = outcome.error
-                outcome = Error(new_exc)
-        elif (
+        if (
             task._cancel_status is not None
             and task._cancel_status.abandoned_by_misnesting
             and task._cancel_status.parent is None
-        ):
+        ) or task._child_nurseries:
+            reason = "Nursery" if task._child_nurseries else "Cancel scope"
             # The cancel scope surrounding this task's nursery was closed
             # before the task exited. Force the task to exit with an error,
             # since the error might not have been caught elsewhere. See the
@@ -2054,7 +2036,7 @@ def task_exited(self, task: Task, outcome: Outcome[object]) -> None:
                 # Raise this, rather than just constructing it, to get a
                 # traceback frame included
                 raise RuntimeError(
-                    "Cancel scope stack corrupted: cancel scope surrounding "
+                    f"{reason} stack corrupted: {reason} surrounding "
                     f"{task!r} was closed before the task exited\n{MISNESTING_ADVICE}",
                 )
             except RuntimeError as new_exc:

src/trio/_core/_tests/test_run.py

@@ -868,6 +868,17 @@ async def inner_func() -> None:
             outer_nursery.start_soon(inner_func)
 
 
+def test_nursery_nested_child_misnest() -> None:
+    # TODO: check context as well for the AssertionError (that will be a RuntimeError)
+    async def main() -> None:
+        async with _core.open_nursery():
+            inner_cm = _core.open_nursery()
+            await inner_cm.__aenter__()
+
+    with pytest.raises(RuntimeError, match="Nursery stack corrupted"):
+        _core.run(main)
+
+
 async def test_asyncexitstack_nursery_misnest() -> None:
     @asynccontextmanager
     async def asynccontextmanager_that_creates_a_nursery_internally() -> (
@@ -883,17 +894,11 @@ async def started_sleeper(task_status: _core.TaskStatus[None]) -> None:
         await sleep_forever()
 
     async def unstarted_task() -> None:
-        raise AssertionError("this should not even get a chance to run")
+        await _core.checkpoint()
 
     with pytest.RaisesGroup(
-        pytest.RaisesExc(
-            RuntimeError,
-            match="Task .*unstarted_task.* aborted after nursery was destroyed due to misnesting.",
-        ),
-        pytest.RaisesExc(
-            RuntimeError,
-            match="Task .*started_sleeper.* aborted after nursery was destroyed due to misnesting.",
-        ),
+        _core.Cancelled,  # this leaks out, likely the scope supposed to handle it is gone
+        # but one of them is handled, or lost, not sure (TODO).
         pytest.RaisesGroup(
             pytest.RaisesExc(RuntimeError, match="Nursery stack corrupted")
         ),
@@ -905,15 +910,6 @@ async def unstarted_task() -> None:
                 asynccontextmanager_that_creates_a_nursery_internally(),
             )
 
-    # The outer nursery forcefully aborts the inner nursery and stops `unstarted_task`
-    # from ever being started.
-    # `started_sleeper` is awaited, but not the internal `sleep`
-    with pytest.warns(
-        RuntimeWarning,
-        match="^coroutine '(test_asyncexitstack_nursery_misnest.<locals>.unstarted_task|sleep)' was never awaited$",
-    ):
-        gc_collect_harder()
-
 
 @slow
 async def test_timekeeping() -> None: