gh-152132: Address review feedback — rename helpers, add tests

- Rename _PyRun_SimpleFileObjectEx → _PyRun_SimpleFileObjectNoPrint to
  avoid the deprecated 'Ex' suffix. Make _PyRun_SimpleFileObject a thin
  wrapper around it to avoid code duplication.
- Rename _PyRun_SimpleStringFlagsEx → _PyRun_SimpleStringFlagsNoPrint
  and make _PyRun_SimpleStringFlagsWithName a thin wrapper similarly.
- Rename single-letter variable 'v' and 'res' to 'result' throughout.
- Add test cases for sys.exit() handling via -c, file, -m and message.

Author: tangyuan0821

Include/internal/pycore_pylifecycle.h

@@ -114,7 +114,7 @@ int _PyRun_SimpleStringFlagsWithName(const char *command, const char* name, PyCo
 // Like _PyRun_SimpleStringFlagsWithName but returns the result object
 // instead of calling PyErr_Print() on failure. The caller should handle
 // the error with _Py_HandleSystemExitAndKeyboardInterrupt or PyErr_Print.
-PyObject *_PyRun_SimpleStringFlagsEx(const char *command, const char* name, PyCompilerFlags *flags);
+PyObject *_PyRun_SimpleStringFlagsNoPrint(const char *command, const char* name, PyCompilerFlags *flags);
 
 
 /* interpreter config */

Include/internal/pycore_pythonrun.h

@@ -20,7 +20,7 @@ extern int _PyRun_AnyFileObject(
     int closeit,
     PyCompilerFlags *flags);
 
-extern PyObject * _PyRun_SimpleFileObjectEx(
+extern PyObject * _PyRun_SimpleFileObjectNoPrint(
     FILE *fp,
     PyObject *filename,
     int closeit,

Lib/test/test_runpy.py

@@ -916,6 +916,45 @@ def test_pymain_run_module(self):
         ham = self.ham
         self.assertSigInt(["-m", ham.stem], cwd=ham.parent)
 
+    # Tests for sys.exit() handling (gh-152132)
+    @requires_subprocess()
+    def test_sys_exit_run_command(self):
+        cmd = [sys.executable, '-c', 'import sys; sys.exit(42)']
+        proc = subprocess.run(cmd, text=True, stderr=subprocess.PIPE)
+        self.assertEqual(proc.returncode, 42)
+
+    @requires_subprocess()
+    def test_sys_exit_run_command_default(self):
+        cmd = [sys.executable, '-c', 'import sys; sys.exit()']
+        proc = subprocess.run(cmd, text=True, stderr=subprocess.PIPE)
+        self.assertEqual(proc.returncode, 0)
+
+    @requires_subprocess()
+    def test_sys_exit_run_command_message(self):
+        cmd = [sys.executable, '-c', "import sys; sys.exit('error message')"]
+        proc = subprocess.run(cmd, text=True, stdout=subprocess.PIPE,
+                              stderr=subprocess.PIPE)
+        self.assertEqual(proc.returncode, 1)
+        self.assertIn('error message', proc.stderr)
+
+    @requires_subprocess()
+    def test_sys_exit_run_file(self):
+        with self.tmp_path() as tmp:
+            script = tmp / "exit_script.py"
+            script.write_text("import sys; sys.exit(42)")
+            cmd = [sys.executable, str(script)]
+            proc = subprocess.run(cmd, text=True, stderr=subprocess.PIPE)
+            self.assertEqual(proc.returncode, 42)
+
+    @requires_subprocess()
+    def test_sys_exit_run_module(self):
+        with self.tmp_path() as tmp:
+            script = tmp / "exit_mod.py"
+            script.write_text("import sys; sys.exit(42)")
+            cmd = [sys.executable, '-m', 'exit_mod']
+            proc = subprocess.run(cmd, cwd=tmp, text=True, stderr=subprocess.PIPE)
+            self.assertEqual(proc.returncode, 42)
+
 
 if __name__ == "__main__":
     unittest.main()

Modules/main.c

@@ -10,7 +10,7 @@
 #include "pycore_pathconfig.h"    // _PyPathConfig_ComputeSysPath0()
 #include "pycore_pylifecycle.h"   // _Py_PreInitializeFromPyArgv()
 #include "pycore_pystate.h"       // _PyInterpreterState_GET()
-#include "pycore_pythonrun.h"     // _PyRun_SimpleFileObjectEx()
+#include "pycore_pythonrun.h"     // _PyRun_SimpleFileObjectNoPrint()
 #include "pycore_tuple.h"         // _PyTuple_FromPair
 #include "pycore_unicodeobject.h" // _PyUnicode_Dedent()
 
@@ -258,12 +258,12 @@ pymain_run_command(wchar_t *command)
 
     PyCompilerFlags cf = _PyCompilerFlags_INIT;
     cf.cf_flags |= PyCF_IGNORE_COOKIE;
-    PyObject *res = _PyRun_SimpleStringFlagsEx(PyBytes_AsString(bytes), "<string>", &cf);
+    PyObject *result = _PyRun_SimpleStringFlagsNoPrint(PyBytes_AsString(bytes), "<string>", &cf);
     Py_DECREF(bytes);
-    if (res == NULL) {
+    if (result == NULL) {
         return pymain_exit_err_print();
     }
-    Py_DECREF(res);
+    Py_DECREF(result);
     return 0;
 
 error:
@@ -409,14 +409,14 @@ pymain_run_file_obj(PyObject *program_name, PyObject *filename,
         return pymain_exit_err_print();
     }
 
-    /* Use _PyRun_SimpleFileObjectEx which returns PyObject* without calling
+    /* Use _PyRun_SimpleFileObjectNoPrint which returns PyObject* without calling
        PyErr_Print(), so we can handle SystemExit properly via pymain_exit_err_print. */
     PyCompilerFlags cf = _PyCompilerFlags_INIT;
-    PyObject *v = _PyRun_SimpleFileObjectEx(fp, filename, 1, &cf);
-    if (v == NULL) {
+    PyObject *result = _PyRun_SimpleFileObjectNoPrint(fp, filename, 1, &cf);
+    if (result == NULL) {
         return pymain_exit_err_print();
     }
-    Py_DECREF(v);
+    Py_DECREF(result);
     return 0;
 }
 

Python/pythonrun.c

@@ -458,95 +458,15 @@ set_main_loader(PyObject *d, PyObject *filename, const char *loader_name)
 }
 
 
-int
-_PyRun_SimpleFileObject(FILE *fp, PyObject *filename, int closeit,
-                        PyCompilerFlags *flags)
-{
-    int ret = -1;
-
-    PyObject *main_module = PyImport_AddModuleRef("__main__");
-    if (main_module == NULL)
-        return -1;
-    PyObject *dict = PyModule_GetDict(main_module);  // borrowed ref
-
-    int set_file_name = 0;
-    int has_file = PyDict_ContainsString(dict, "__file__");
-    if (has_file < 0) {
-        goto done;
-    }
-    if (!has_file) {
-        if (PyDict_SetItemString(dict, "__file__", filename) < 0) {
-            goto done;
-        }
-        set_file_name = 1;
-    }
-
-    int pyc = maybe_pyc_file(fp, filename, closeit);
-    if (pyc < 0) {
-        goto done;
-    }
-
-    PyObject *v;
-    if (pyc) {
-        FILE *pyc_fp;
-        /* Try to run a pyc file. First, re-open in binary */
-        if (closeit) {
-            fclose(fp);
-        }
-
-        pyc_fp = Py_fopen(filename, "rb");
-        if (pyc_fp == NULL) {
-            fprintf(stderr, "python: Can't reopen .pyc file\n");
-            goto done;
-        }
-
-        if (set_main_loader(dict, filename, "SourcelessFileLoader") < 0) {
-            fprintf(stderr, "python: failed to set __main__.__loader__\n");
-            ret = -1;
-            fclose(pyc_fp);
-            goto done;
-        }
-        v = run_pyc_file(pyc_fp, dict, dict, flags);
-    } else {
-        /* When running from stdin, leave __main__.__loader__ alone */
-        if ((!PyUnicode_Check(filename) || !PyUnicode_EqualToUTF8(filename, "<stdin>")) &&
-            set_main_loader(dict, filename, "SourceFileLoader") < 0) {
-            fprintf(stderr, "python: failed to set __main__.__loader__\n");
-            ret = -1;
-            goto done;
-        }
-        v = pyrun_file(fp, filename, Py_file_input, dict, dict,
-                       closeit, flags);
-    }
-    flush_io();
-    if (v == NULL) {
-        Py_CLEAR(main_module);
-        PyErr_Print();
-        goto done;
-    }
-    Py_DECREF(v);
-    ret = 0;
-
-  done:
-    if (set_file_name) {
-        if (PyDict_PopString(dict, "__file__", NULL) < 0) {
-            PyErr_Print();
-        }
-    }
-    Py_XDECREF(main_module);
-    return ret;
-}
-
-
-/* Variant of _PyRun_SimpleFileObject that returns the result object
-   instead of calling PyErr_Print() on failure. The caller (typically
-   pymain_run_file_obj in Modules/main.c) should handle the error
-   with _Py_HandleSystemExitAndKeyboardInterrupt or pymain_exit_err_print. */
+/* Run a simple file object. Returns the result PyObject* on success,
+   or NULL on failure. Does NOT call PyErr_Print(); the caller must
+   handle the error (e.g. with PyErr_Print() or
+   _Py_HandleSystemExitAndKeyboardInterrupt()). */
 PyObject *
-_PyRun_SimpleFileObjectEx(FILE *fp, PyObject *filename, int closeit,
-                          PyCompilerFlags *flags)
+_PyRun_SimpleFileObjectNoPrint(FILE *fp, PyObject *filename, int closeit,
+                               PyCompilerFlags *flags)
 {
-    PyObject *v = NULL;
+    PyObject *result = NULL;
 
     PyObject *main_module = PyImport_AddModuleRef("__main__");
     if (main_module == NULL)
@@ -589,22 +509,22 @@ _PyRun_SimpleFileObjectEx(FILE *fp, PyObject *filename, int closeit,
             fclose(pyc_fp);
             goto done;
         }
-        v = run_pyc_file(pyc_fp, dict, dict, flags);
+        result = run_pyc_file(pyc_fp, dict, dict, flags);
     } else {
         /* When running from stdin, leave __main__.__loader__ alone */
         if ((!PyUnicode_Check(filename) || !PyUnicode_EqualToUTF8(filename, "<stdin>")) &&
             set_main_loader(dict, filename, "SourceFileLoader") < 0) {
             fprintf(stderr, "python: failed to set __main__.__loader__\n");
             goto done;
         }
-        v = pyrun_file(fp, filename, Py_file_input, dict, dict,
-                       closeit, flags);
+        result = pyrun_file(fp, filename, Py_file_input, dict, dict,
+                            closeit, flags);
     }
     flush_io();
 
 done:
     if (set_file_name) {
-        if (v == NULL) {
+        if (result == NULL) {
             // Main code failed: save the exception before cleanup
             // so PyDict_PopString doesn't overwrite it
             PyObject *saved_exc = PyErr_GetRaisedException();
@@ -622,7 +542,22 @@ _PyRun_SimpleFileObjectEx(FILE *fp, PyObject *filename, int closeit,
         }
     }
     Py_XDECREF(main_module);
-    return v;
+    return result;
+}
+
+
+int
+_PyRun_SimpleFileObject(FILE *fp, PyObject *filename, int closeit,
+                        PyCompilerFlags *flags)
+{
+    PyObject *result = _PyRun_SimpleFileObjectNoPrint(fp, filename, closeit,
+                                                      flags);
+    if (result == NULL) {
+        PyErr_Print();
+        return -1;
+    }
+    Py_DECREF(result);
+    return 0;
 }
 
 
@@ -640,61 +575,49 @@ PyRun_SimpleFileExFlags(FILE *fp, const char *filename, int closeit,
 }
 
 
-int
-_PyRun_SimpleStringFlagsWithName(const char *command, const char* name, PyCompilerFlags *flags) {
-    PyObject *main_module = PyImport_AddModuleRef("__main__");
-    if (main_module == NULL) {
-        return -1;
-    }
-    PyObject *dict = PyModule_GetDict(main_module);  // borrowed ref
-
-    PyObject *res = NULL;
-    if (name == NULL) {
-        res = PyRun_StringFlags(command, Py_file_input, dict, dict, flags);
-    } else {
-        PyObject* the_name = PyUnicode_FromString(name);
-        if (!the_name) {
-            PyErr_Print();
-            Py_DECREF(main_module);
-            return -1;
-        }
-        res = _PyRun_StringFlagsWithName(command, the_name, Py_file_input, dict, dict, flags, 0);
-        Py_DECREF(the_name);
-    }
-    Py_DECREF(main_module);
-    if (res == NULL) {
-        PyErr_Print();
-        return -1;
-    }
-
-    Py_DECREF(res);
-    return 0;
-}
-
+/* Run a simple string. Returns the result PyObject* on success,
+   or NULL on failure. Does NOT call PyErr_Print(); the caller must
+   handle the error (e.g. with PyErr_Print() or
+   _Py_HandleSystemExitAndKeyboardInterrupt()). */
 PyObject *
-_PyRun_SimpleStringFlagsEx(const char *command, const char* name, PyCompilerFlags *flags)
+_PyRun_SimpleStringFlagsNoPrint(const char *command, const char* name,
+                                PyCompilerFlags *flags)
 {
     PyObject *main_module = PyImport_AddModuleRef("__main__");
     if (main_module == NULL) {
         return NULL;
     }
     PyObject *dict = PyModule_GetDict(main_module);  // borrowed ref
 
-    PyObject *res = NULL;
+    PyObject *result = NULL;
     if (name == NULL) {
-        res = PyRun_StringFlags(command, Py_file_input, dict, dict, flags);
+        result = PyRun_StringFlags(command, Py_file_input, dict, dict, flags);
     } else {
         PyObject* the_name = PyUnicode_FromString(name);
         if (!the_name) {
             Py_DECREF(main_module);
             return NULL;
         }
-        res = _PyRun_StringFlagsWithName(command, the_name, Py_file_input,
-                                         dict, dict, flags, 0);
+        result = _PyRun_StringFlagsWithName(command, the_name, Py_file_input,
+                                            dict, dict, flags, 0);
         Py_DECREF(the_name);
     }
     Py_DECREF(main_module);
-    return res;
+    return result;
+}
+
+
+int
+_PyRun_SimpleStringFlagsWithName(const char *command, const char* name,
+                                 PyCompilerFlags *flags)
+{
+    PyObject *result = _PyRun_SimpleStringFlagsNoPrint(command, name, flags);
+    if (result == NULL) {
+        PyErr_Print();
+        return -1;
+    }
+    Py_DECREF(result);
+    return 0;
 }