Merge pull request #2879 from gschaffner/cpython-throw-bugs-testing

Test that Trio works around some CPython `.throw` bugs present in >= 3.9

Author: gschaffner

src/trio/_core/_run.py

@@ -2546,9 +2546,11 @@ def unrolled_run(
                 try:
                     # We used to unwrap the Outcome object here and send/throw
                     # its contents in directly, but it turns out that .throw()
-                    # is buggy, at least before CPython 3.9:
+                    # is buggy on CPython (all versions at time of writing):
                     #   https://bugs.python.org/issue29587
                     #   https://bugs.python.org/issue29590
+                    #   https://bugs.python.org/issue40694
+                    #   https://github.com/python/cpython/issues/108668
                     # So now we send in the Outcome object and unwrap it on the
                     # other side.
                     msg = task.context.run(next_send_fn, next_send)

src/trio/_core/_tests/test_run.py

@@ -1070,12 +1070,19 @@ async def child2() -> None:
     ]
 
 
-# Before CPython 3.9, using .throw() to raise an exception inside a
-# coroutine/generator causes the original exc_info state to be lost, so things
-# like re-raising and exception chaining are broken.
+# On all CPython versions (at time of writing), using .throw() to raise an
+# exception inside a coroutine/generator can cause the original `exc_info` state
+# to be lost, so things like re-raising and exception chaining are broken unless
+# Trio implements its workaround. At time of writing, CPython main (3.13-dev)
+# and every CPython release (excluding releases for old Python versions not
+# supported by Trio) is affected (albeit in differing ways).
 #
-# https://bugs.python.org/issue29587
-async def test_exc_info_after_yield_error() -> None:
+# If the `ValueError()` gets sent in via `throw` and is suppressed, then CPython
+# loses track of the original `exc_info`:
+#   https://bugs.python.org/issue25612 (Example 1)
+#   https://bugs.python.org/issue29587 (Example 2)
+# This is fixed in CPython >= 3.7.
+async def test_exc_info_after_throw_suppressed() -> None:
     child_task: _core.Task | None = None
 
     async def child() -> None:
@@ -1084,21 +1091,28 @@ async def child() -> None:
 
         try:
             raise KeyError
-        except Exception:
-            with suppress(Exception):
+        except KeyError:
+            with suppress(ValueError):
                 await sleep_forever()
             raise
 
-    with pytest.raises(KeyError):
+    with pytest.raises(KeyError) as excinfo:
         async with _core.open_nursery() as nursery:
             nursery.start_soon(child)
             await wait_all_tasks_blocked()
             _core.reschedule(not_none(child_task), outcome.Error(ValueError()))
 
+    assert excinfo.value.__context__ is None
+
 
-# Similar to previous test -- if the ValueError() gets sent in via 'throw',
-# then Python's normal implicit chaining stuff is broken.
-async def test_exception_chaining_after_yield_error() -> None:
+# Similar to previous test -- if the `ValueError()` gets sent in via 'throw' and
+# propagates out, then CPython doesn't set its `__context__` so normal implicit
+# exception chaining is broken:
+#   https://bugs.python.org/issue25612 (Example 2)
+#   https://bugs.python.org/issue25683
+#   https://bugs.python.org/issue29587 (Example 1)
+# This is fixed in CPython >= 3.9.
+async def test_exception_chaining_after_throw() -> None:
     child_task: _core.Task | None = None
 
     async def child() -> None:
@@ -1107,7 +1121,7 @@ async def child() -> None:
 
         try:
             raise KeyError
-        except Exception:
+        except KeyError:
             await sleep_forever()
 
     with pytest.raises(ValueError) as excinfo:
@@ -1119,6 +1133,71 @@ async def child() -> None:
     assert isinstance(excinfo.value.__context__, KeyError)
 
 
+# Similar to previous tests -- if the `ValueError()` gets sent into an inner
+# `await` via 'throw' and is suppressed there, then CPython loses track of
+# `exc_info` in the inner coroutine:
+#   https://github.com/python/cpython/issues/108668
+# This is unfixed in CPython at time of writing.
+async def test_exc_info_after_throw_to_inner_suppressed() -> None:
+    child_task: _core.Task | None = None
+
+    async def child() -> None:
+        nonlocal child_task
+        child_task = _core.current_task()
+
+        try:
+            raise KeyError
+        except KeyError as exc:
+            await inner(exc)
+            raise
+
+    async def inner(exc: BaseException) -> None:
+        with suppress(ValueError):
+            await sleep_forever()
+        assert not_none(sys.exc_info()[1]) is exc
+
+    with pytest.raises(KeyError) as excinfo:
+        async with _core.open_nursery() as nursery:
+            nursery.start_soon(child)
+            await wait_all_tasks_blocked()
+            _core.reschedule(not_none(child_task), outcome.Error(ValueError()))
+
+    assert excinfo.value.__context__ is None
+
+
+# Similar to previous tests -- if the `ValueError()` gets sent into an inner
+# `await` via `throw` and propagates out, then CPython incorrectly sets its
+# `__context__` so normal implicit exception chaining is broken:
+#   https://bugs.python.org/issue40694
+# This is unfixed in CPython at time of writing.
+async def test_exception_chaining_after_throw_to_inner() -> None:
+    child_task: _core.Task | None = None
+
+    async def child() -> None:
+        nonlocal child_task
+        child_task = _core.current_task()
+
+        try:
+            raise KeyError
+        except KeyError:
+            await inner()
+
+    async def inner() -> None:
+        try:
+            raise IndexError
+        except IndexError:
+            await sleep_forever()
+
+    with pytest.raises(ValueError) as excinfo:
+        async with _core.open_nursery() as nursery:
+            nursery.start_soon(child)
+            await wait_all_tasks_blocked()
+            _core.reschedule(not_none(child_task), outcome.Error(ValueError()))
+
+    assert isinstance(excinfo.value.__context__, IndexError)
+    assert isinstance(excinfo.value.__context__.__context__, KeyError)
+
+
 async def test_nursery_exception_chaining_doesnt_make_context_loops() -> None:
     async def crasher() -> NoReturn:
         raise KeyError