check for nursery misnesting on task exit

src/trio/_core/_run.py

@@ -2013,7 +2013,29 @@ def task_exited(self, task: Task, outcome: Outcome[object]) -> None:
                 lot.break_lot(task)
             del GLOBAL_PARKING_LOT_BREAKER[task]
 
-        if (
+        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:
+                nursery.cancel_scope.cancel()
+                for child in nursery._children:
+                    if child in runner.runq:
+                        runner.runq.remove(child)
+                        runner.tasks.remove(child)
+                nursery._children.clear()
+            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 (
             task._cancel_status is not None
             and task._cancel_status.abandoned_by_misnesting
             and task._cancel_status.parent is None

src/trio/_core/_tests/test_run.py

@@ -8,7 +8,13 @@
 import time
 import types
 import weakref
-from contextlib import ExitStack, contextmanager, suppress
+from contextlib import (
+    AsyncExitStack,
+    ExitStack,
+    asynccontextmanager,
+    contextmanager,
+    suppress,
+)
 from math import inf, nan
 from typing import TYPE_CHECKING, NoReturn, TypeVar
 from unittest import mock
@@ -761,7 +767,7 @@ async def enter_scope() -> None:
     assert scope.cancel_called  # never become un-cancelled
 
 
-async def test_cancel_scope_misnesting() -> None:
+async def test_cancel_scope_misnesting_1() -> None:
     outer = _core.CancelScope()
     inner = _core.CancelScope()
     with ExitStack() as stack:
@@ -771,6 +777,8 @@ async def test_cancel_scope_misnesting() -> None:
                 stack.close()
         # No further error is raised when exiting the inner context
 
+
+async def test_cancel_scope_misnesting_2() -> None:
     # If there are other tasks inside the abandoned part of the cancel tree,
     # they get cancelled when the misnesting is detected
     async def task1() -> None:
@@ -828,6 +836,8 @@ def no_context(exc: RuntimeError) -> bool:
     )
     assert group.matches(exc_info.value.__context__)
 
+
+async def test_cancel_scope_misnesting_3() -> None:
     # Trying to exit a cancel scope from an unrelated task raises an error
     # without affecting any state
     async def task3(task_status: _core.TaskStatus[_core.CancelScope]) -> None:
@@ -844,6 +854,59 @@ async def task3(task_status: _core.TaskStatus[_core.CancelScope]) -> None:
         scope.cancel()
 
 
+async def test_nursery_misnest() -> None:
+    # See https://github.com/python-trio/trio/issues/3298
+    async def inner_func() -> None:
+        inner_nursery = await inner_cm.__aenter__()
+        inner_nursery.start_soon(sleep, 1)
+
+    with pytest.RaisesGroup(
+        pytest.RaisesExc(RuntimeError, match="Nursery stack corrupted")
+    ):
+        async with _core.open_nursery() as outer_nursery:
+            inner_cm = _core.open_nursery()
+            outer_nursery.start_soon(inner_func)
+
+
+async def test_asyncexitstack_nursery_misnest() -> None:
+    @asynccontextmanager
+    async def asynccontextmanager_that_creates_a_nursery_internally() -> (
+        AsyncGenerator[None]
+    ):
+        async with _core.open_nursery() as nursery:
+            await nursery.start(started_sleeper)
+            nursery.start_soon(unstarted_task)
+            yield
+
+    async def started_sleeper(task_status: _core.TaskStatus[None]) -> None:
+        task_status.started()
+        await sleep_forever()
+
+    async def unstarted_task() -> None:
+        raise AssertionError("this should not even get a chance to run")
+
+    async with AsyncExitStack() as stack:
+        manager = _core.open_nursery()
+        nursery = await manager.__aenter__()
+        # The asynccontextmanager is going to create a nursery that outlives this nursery!
+        nursery.start_soon(
+            stack.enter_async_context,
+            asynccontextmanager_that_creates_a_nursery_internally(),
+        )
+        with pytest.RaisesGroup(
+            pytest.RaisesExc(RuntimeError, match="Nursery stack corrupted")
+        ):
+            await manager.__aexit__(None, None, None)
+
+    # The outer nursery forcefully aborts the inner nursery and stops `unstarted_task`
+    # from ever being started.
+    with pytest.warns(
+        RuntimeWarning,
+        match="^coroutine 'test_asyncexitstack_nursery_misnest.<locals>.unstarted_task' was never awaited$",
+    ):
+        gc_collect_harder()
+
+
 @slow
 async def test_timekeeping() -> None:
     # probably a good idea to use a real clock for *one* test anyway...

test-requirements.in

@@ -1,5 +1,5 @@
 # For tests
-pytest >= 5.0         # for faulthandler in core
+pytest >= 8.4         # for pytest.RaisesGroup
 coverage >= 7.2.5
 async_generator >= 1.9
 pyright