Return an excinfo object from _interpreters.exec().

ericsnowcurrently · ericsnowcurrently · commit 61845dd695b4 · 2023-11-22T17:20:49.000-07:00
diff --git a/Lib/test/support/interpreters.py b/Lib/test/support/interpreters.py
@@ -110,7 +110,11 @@ def run(self, src_str, /, channels=None):
         that time, the previous interpreter is allowed to run
         in other threads.
         """
-        _interpreters.exec(self._id, src_str, channels)
+        err = _interpreters.exec(self._id, src_str, channels)
+        if err is not None:
+            exc = RunFailedError(err.formatted)
+            exc.snapshot = err
+            raise exc
 
 
 def create_channel():
diff --git a/Lib/test/test__xxinterpchannels.py b/Lib/test/test__xxinterpchannels.py
@@ -1017,16 +1017,16 @@ def test_close_multiple_users(self):
             _channels.recv({cid})
             """))
         channels.close(cid)
-        with self.assertRaises(interpreters.RunFailedError) as cm:
-            interpreters.run_string(id1, dedent(f"""
+
+        excsnap = interpreters.run_string(id1, dedent(f"""
                 _channels.send({cid}, b'spam')
                 """))
-        self.assertIn('ChannelClosedError', str(cm.exception))
-        with self.assertRaises(interpreters.RunFailedError) as cm:
-            interpreters.run_string(id2, dedent(f"""
+        self.assertEqual(excsnap.type.__name__, 'ChannelClosedError')
+
+        excsnap = interpreters.run_string(id2, dedent(f"""
                 _channels.send({cid}, b'spam')
                 """))
-        self.assertIn('ChannelClosedError', str(cm.exception))
+        self.assertEqual(excsnap.type.__name__, 'ChannelClosedError')
 
     def test_close_multiple_times(self):
         cid = channels.create()
diff --git a/Lib/test/test__xxsubinterpreters.py b/Lib/test/test__xxsubinterpreters.py
@@ -956,11 +956,12 @@ class NeverError(Exception): pass
                 raise NeverError  # never raised
                 """).format(dedent(text))
             if fails:
-                with self.assertRaises(excwrapper) as caught:
-                    interpreters.run_string(self.id, script)
-                return caught.exception
+                err = interpreters.run_string(self.id, script)
+                self.assertIsNot(err, None)
+                return err
             else:
-                interpreters.run_string(self.id, script)
+                err = interpreters.run_string(self.id, script)
+                self.assertIs(err, None)
                 return None
         except:
             raise  # re-raise
@@ -982,11 +983,12 @@ def _assert_run_failed(self, exctype, msg, script):
         exc = self.run_script(script, fails=True)
 
         # Check the wrapper exception.
+        self.assertEqual(exc.type.__name__, exctype_name)
         if msg is None:
-            self.assertEqual(str(exc).split(':')[0],
+            self.assertEqual(exc.formatted.split(':')[0],
                              exctype_name)
         else:
-            self.assertEqual(str(exc),
+            self.assertEqual(exc.formatted,
                              '{}: {}'.format(exctype_name, msg))
 
         return exc
diff --git a/Lib/test/test_import/__init__.py b/Lib/test/test_import/__init__.py
@@ -1968,10 +1968,12 @@ def test_disallowed_reimport(self):
             print(_testsinglephase)
             ''')
         interpid = _interpreters.create()
-        with self.assertRaises(_interpreters.RunFailedError):
-            _interpreters.run_string(interpid, script)
-        with self.assertRaises(_interpreters.RunFailedError):
-            _interpreters.run_string(interpid, script)
+
+        excsnap = _interpreters.run_string(interpid, script)
+        self.assertIsNot(excsnap, None)
+
+        excsnap = _interpreters.run_string(interpid, script)
+        self.assertIsNot(excsnap, None)
 
 
 class TestSinglePhaseSnapshot(ModuleSnapshot):
diff --git a/Lib/test/test_importlib/test_util.py b/Lib/test/test_importlib/test_util.py
@@ -655,25 +655,19 @@ def test_magic_number(self):
 @unittest.skipIf(_interpreters is None, 'subinterpreters required')
 class IncompatibleExtensionModuleRestrictionsTests(unittest.TestCase):
 
-    ERROR = re.compile("^ImportError: module (.*) does not support loading in subinterpreters")
-
     def run_with_own_gil(self, script):
         interpid = _interpreters.create(isolated=True)
-        try:
-            _interpreters.run_string(interpid, script)
-        except _interpreters.RunFailedError as exc:
-            if m := self.ERROR.match(str(exc)):
-                modname, = m.groups()
-                raise ImportError(modname)
+        excsnap = _interpreters.run_string(interpid, script)
+        if excsnap is not None:
+            if excsnap.type.__name__ == 'ImportError':
+                raise ImportError(excsnap.msg)
 
     def run_with_shared_gil(self, script):
         interpid = _interpreters.create(isolated=False)
-        try:
-            _interpreters.run_string(interpid, script)
-        except _interpreters.RunFailedError as exc:
-            if m := self.ERROR.match(str(exc)):
-                modname, = m.groups()
-                raise ImportError(modname)
+        excsnap = _interpreters.run_string(interpid, script)
+        if excsnap is not None:
+            if excsnap.type.__name__ == 'ImportError':
+                raise ImportError(excsnap.msg)
 
     @unittest.skipIf(_testsinglephase is None, "test requires _testsinglephase module")
     def test_single_phase_init_module(self):
diff --git a/Modules/_xxsubinterpretersmodule.c b/Modules/_xxsubinterpretersmodule.c
@@ -225,23 +225,11 @@ _run_script(PyObject *ns, const char *codestr, Py_ssize_t codestrlen, int flags)
     return 0;
 }
 
-static void
-_raise_formatted(PyObject *exctype, PyObject *excinfo)
-{
-    PyObject *formatted = PyObject_GetAttrString(excinfo, "formatted");
-    if (formatted == NULL) {
-        assert(PyErr_Occurred());
-        return;
-    }
-    PyErr_SetObject(exctype, formatted);
-    Py_DECREF(formatted);
-}
-
 static int
 _run_in_interpreter(PyInterpreterState *interp,
                     const char *codestr, Py_ssize_t codestrlen,
                     PyObject *shareables, int flags,
-                    PyObject *excwrapper)
+                    PyObject **p_excinfo)
 {
     assert(!PyErr_Occurred());
     _PyXI_session session = {0};
@@ -251,7 +239,7 @@ _run_in_interpreter(PyInterpreterState *interp,
         assert(!PyErr_Occurred());
         PyObject *excinfo = _PyXI_ApplyError(session.error);
         if (excinfo != NULL) {
-            _raise_formatted(excwrapper, excinfo);
+            *p_excinfo = excinfo;
         }
         assert(PyErr_Occurred());
         return -1;
@@ -268,7 +256,7 @@ _run_in_interpreter(PyInterpreterState *interp,
     if (res < 0) {
         PyObject *excinfo = _PyXI_ApplyCapturedException(&session);
         if (excinfo != NULL) {
-            _raise_formatted(excwrapper, excinfo);
+            *p_excinfo = excinfo;
         }
     }
     else {
@@ -539,7 +527,8 @@ convert_code_arg(PyObject *arg, const char *fname, const char *displayname,
 
 static int
 _interp_exec(PyObject *self,
-             PyObject *id_arg, PyObject *code_arg, PyObject *shared_arg)
+             PyObject *id_arg, PyObject *code_arg, PyObject *shared_arg,
+             PyObject **p_excinfo)
 {
     // Look up the interpreter.
     PyInterpreterState *interp = PyInterpreterID_LookUp(id_arg);
@@ -558,10 +547,8 @@ _interp_exec(PyObject *self,
     }
 
     // Run the code in the interpreter.
-    module_state *state = get_module_state(self);
-    assert(state != NULL);
     int res = _run_in_interpreter(interp, codestr, codestrlen,
-                                  shared_arg, flags, state->RunFailedError);
+                                  shared_arg, flags, p_excinfo);
     Py_XDECREF(bytes_obj);
     if (res < 0) {
         return -1;
@@ -595,10 +582,12 @@ interp_exec(PyObject *self, PyObject *args, PyObject *kwds)
         return NULL;
     }
 
-    int res = _interp_exec(self, id, code, shared);
+    PyObject *excinfo = NULL;
+    int res = _interp_exec(self, id, code, shared, &excinfo);
     Py_DECREF(code);
     if (res < 0) {
-        return NULL;
+        assert((excinfo == NULL) != (PyErr_Occurred() == NULL));
+        return excinfo;
     }
     Py_RETURN_NONE;
 }
@@ -638,10 +627,12 @@ interp_run_string(PyObject *self, PyObject *args, PyObject *kwds)
         return NULL;
     }
 
-    int res = _interp_exec(self, id, script, shared);
+    PyObject *excinfo = NULL;
+    int res = _interp_exec(self, id, script, shared, &excinfo);
     Py_DECREF(script);
     if (res < 0) {
-        return NULL;
+        assert((excinfo == NULL) != (PyErr_Occurred() == NULL));
+        return excinfo;
     }
     Py_RETURN_NONE;
 }
@@ -672,10 +663,12 @@ interp_run_func(PyObject *self, PyObject *args, PyObject *kwds)
         return NULL;
     }
 
-    int res = _interp_exec(self, id, (PyObject *)code, shared);
+    PyObject *excinfo = NULL;
+    int res = _interp_exec(self, id, (PyObject *)code, shared, &excinfo);
     Py_DECREF(code);
     if (res < 0) {
-        return NULL;
+        assert((excinfo == NULL) != (PyErr_Occurred() == NULL));
+        return excinfo;
     }
     Py_RETURN_NONE;
 }
