gh-124872: Back up exception before calling PyContext_WatchCallback

I believe that the value of a simpler API (and defense against poorly
written callbacks) outweighs the cost of backing up and restoring the
thread's exception state.

Doc/c-api/contextvars.rst

@@ -135,16 +135,13 @@ Context object management functions:
    Otherwise, the callback is invoked before the deactivation of *ctx* as the current context
    and the restoration of the previous contex object for the current thread.
 
+   Any pending exception is cleared before the callback is called and restored
+   after the callback returns.
+
    If the callback returns with an exception set, it must return ``-1``; this
    exception will be printed as an unraisable exception using
    :c:func:`PyErr_FormatUnraisable`. Otherwise it should return ``0``.
 
-   There may already be a pending exception set on entry to the callback. In
-   this case, the callback should return ``0`` with the same exception still
-   set. This means the callback may not call any other API that can set an
-   exception unless it saves and clears the exception state first, and restores
-   it before returning.
-
    .. versionadded:: 3.14
 
 

Include/cpython/context.h

@@ -38,6 +38,9 @@ typedef enum {
  * The callback is invoked with the event and a reference to
  * the context after its entered and before its exited.
  *
+ * Any pending exception is cleared before the callback is called and restored
+ * after the callback returns.
+ *
  * if the callback returns with an exception set, it must return -1. Otherwise
  * it should return 0
  */

Lib/test/test_capi/test_watchers.py

@@ -640,6 +640,16 @@ def _in_context(stack):
                 ctx.run(_in_context, stack)
             self.assertEqual(str(cm.unraisable.exc_value), "boom!")
 
+    def test_exception_save(self):
+        with self.context_watcher(2):
+            with catch_unraisable_exception() as cm:
+                def _in_context():
+                    raise RuntimeError("test")
+
+                with self.assertRaisesRegex(RuntimeError, "test"):
+                    contextvars.copy_context().run(_in_context)
+                self.assertEqual(str(cm.unraisable.exc_value), "boom!")
+
     def test_clear_out_of_range_watcher_id(self):
         with self.assertRaisesRegex(ValueError, r"Invalid context watcher ID -1"):
             _testcapi.clear_context_watcher(-1)

Python/context.c

@@ -124,11 +124,13 @@ static void notify_context_watchers(PyContextEvent event, PyContext *ctx, PyThre
         if (bits & 1) {
             PyContext_WatchCallback cb = interp->context_watchers[i];
             assert(cb != NULL);
+            PyObject *exc = _PyErr_GetRaisedException(ts);
             if (cb(event, ctx) < 0) {
                 PyErr_FormatUnraisable(
                     "Exception ignored in %s watcher callback for %R",
                     context_event_name(event), ctx);
             }
+            _PyErr_SetRaisedException(ts, exc);
         }
         i++;
         bits >>= 1;