Revert "gh-132775: Add _PyCode_VerifyStateless() (gh-133221)"

This reverts commit d270bb5.

Note that the test functions in _code_definitions are not reverted.

Author: encukou

Include/internal/pycore_code.h

@@ -619,47 +619,6 @@ PyAPI_FUNC(int) _PyCode_SetUnboundVarCounts(
         PyObject *globalsns,
         PyObject *builtinsns);
 
-
-/* "Stateless" code is a function or code object which does not rely on
- * external state or internal state.  It may rely on arguments and
- * builtins, but not globals or a closure.  Thus it does not rely
- * on __globals__ or __closure__, and a stateless function
- * is equivalent to its code object.
- *
- * Stateless code also does not keep any persistent state
- * of its own, so it can't have any executors, monitoring,
- * instrumentation, or "extras" (i.e. co_extra).
- *
- * Stateless code may create nested functions, including closures.
- * However, nested functions must themselves be stateless, except they
- * *can* close on the enclosing locals.
- *
- * Stateless code may return any value, including nested functions and closures.
- *
- * Stateless code that takes no arguments and doesn't return anything
- * may be treated like a script.
- *
- * We consider stateless code to be "portable" if it does not return any
- * any object that holds a reference to any of the code's locals.  Thus
- * generators and coroutines are not portable.  Likewise a function
- * that returns a closure is not portable.  The concept of
- * portability is useful in cases where the code is run
- * in a different execution context than where
- * the return value will be used. */
-
-PyAPI_FUNC(int) _PyCode_CheckNoInternalState(PyCodeObject *, const char **);
-PyAPI_FUNC(int) _PyCode_CheckNoExternalState(
-        PyCodeObject *,
-        _PyCode_var_counts_t *,
-        const char **);
-PyAPI_FUNC(int) _PyCode_VerifyStateless(
-        PyThreadState *,
-        PyCodeObject *,
-        PyObject *globalnames,
-        PyObject *globalsns,
-        PyObject *builtinsns);
-
-PyAPI_FUNC(int) _PyCode_CheckPureFunction(PyCodeObject *, const char **);
 PyAPI_FUNC(int) _PyCode_ReturnsOnlyNone(PyCodeObject *);
 
 

Include/internal/pycore_function.h

@@ -35,13 +35,6 @@ PyFunctionObject *_PyFunction_LookupByVersion(uint32_t version, PyObject **p_cod
 extern PyObject *_Py_set_function_type_params(
     PyThreadState* unused, PyObject *func, PyObject *type_params);
 
-
-/* See pycore_code.h for explanation about what "stateless" means. */
-
-PyAPI_FUNC(int)
-_PyFunction_VerifyStateless(PyThreadState *, PyObject *);
-
-
 #ifdef __cplusplus
 }
 #endif

Include/internal/pycore_opcode_utils.h

@@ -56,8 +56,6 @@ extern "C" {
 
 #define IS_RETURN_OPCODE(opcode) \
         (opcode == RETURN_VALUE)
-#define IS_RAISE_OPCODE(opcode) \
-        (opcode == RAISE_VARARGS || opcode == RERAISE)
 
 
 /* Flags used in the oparg for MAKE_FUNCTION */

Lib/test/_code_definitions.py

@@ -178,32 +178,6 @@ def ham_C_closure(z):
     *NESTED_FUNCTIONS,
 ]
 
-STATELESS_FUNCTIONS = [
-    spam,
-    spam_minimal,
-    spam_with_builtins,
-    spam_args_attrs_and_builtins,
-    spam_returns_arg,
-    spam_annotated,
-    spam_with_inner_not_closure,
-    spam_with_inner_closure,
-    spam_N,
-    spam_C,
-    spam_NN,
-    spam_NC,
-    spam_CN,
-    spam_CC,
-    eggs_nested,
-    eggs_nested_N,
-    ham_nested,
-    ham_C_nested
-]
-STATELESS_CODE = [
-    *STATELESS_FUNCTIONS,
-    spam_with_globals_and_builtins,
-    spam_full,
-]
-
 
 # generators
 

Lib/test/test_code.py

@@ -220,7 +220,6 @@
     import _testinternalcapi
 except ModuleNotFoundError:
     _testinternalcapi = None
-import test._code_definitions as defs
 
 COPY_FREE_VARS = opmap['COPY_FREE_VARS']
 
@@ -672,6 +671,7 @@ def test_local_kinds(self):
         VARARGS = CO_FAST_LOCAL | CO_FAST_ARG_VAR | CO_FAST_ARG_POS
         VARKWARGS = CO_FAST_LOCAL | CO_FAST_ARG_VAR | CO_FAST_ARG_KW
 
+        import test._code_definitions as defs
         funcs = {
             defs.spam_minimal: {},
             defs.spam_with_builtins: {
@@ -897,6 +897,7 @@ def new_var_counts(*,
                 },
             }
 
+        import test._code_definitions as defs
         funcs = {
             defs.spam_minimal: new_var_counts(),
             defs.spam_with_builtins: new_var_counts(
@@ -1024,70 +1025,55 @@ def new_var_counts(*,
                 counts = _testinternalcapi.get_code_var_counts(func.__code__)
                 self.assertEqual(counts, expected)
 
-        func = defs.spam_with_globals_and_builtins
+        def func_with_globals_and_builtins():
+            mod1 = _testinternalcapi
+            mod2 = dis
+            mods = (mod1, mod2)
+            checks = tuple(callable(m) for m in mods)
+            return callable(mod2), tuple(mods), list(mods), checks
+
+        func = func_with_globals_and_builtins
         with self.subTest(f'{func} code'):
             expected = new_var_counts(
-                purelocals=5,
-                globalvars=6,
+                purelocals=4,
+                globalvars=5,
             )
             counts = _testinternalcapi.get_code_var_counts(func.__code__)
             self.assertEqual(counts, expected)
 
         with self.subTest(f'{func} with own globals and builtins'):
             expected = new_var_counts(
-                purelocals=5,
-                globalvars=(2, 4),
+                purelocals=4,
+                globalvars=(2, 3),
             )
             counts = _testinternalcapi.get_code_var_counts(func)
             self.assertEqual(counts, expected)
 
         with self.subTest(f'{func} without globals'):
             expected = new_var_counts(
-                purelocals=5,
-                globalvars=(0, 4, 2),
+                purelocals=4,
+                globalvars=(0, 3, 2),
             )
             counts = _testinternalcapi.get_code_var_counts(func, globalsns={})
             self.assertEqual(counts, expected)
 
         with self.subTest(f'{func} without both'):
             expected = new_var_counts(
-                purelocals=5,
-                globalvars=6,
+                purelocals=4,
+                globalvars=5,
             )
             counts = _testinternalcapi.get_code_var_counts(func, globalsns={},
                   builtinsns={})
             self.assertEqual(counts, expected)
 
         with self.subTest(f'{func} without builtins'):
             expected = new_var_counts(
-                purelocals=5,
-                globalvars=(2, 0, 4),
+                purelocals=4,
+                globalvars=(2, 0, 3),
             )
             counts = _testinternalcapi.get_code_var_counts(func, builtinsns={})
             self.assertEqual(counts, expected)
 
-    @unittest.skipIf(_testinternalcapi is None, "missing _testinternalcapi")
-    def test_stateless(self):
-        self.maxDiff = None
-
-        for func in defs.STATELESS_CODE:
-            with self.subTest((func, '(code)')):
-                _testinternalcapi.verify_stateless_code(func.__code__)
-        for func in defs.STATELESS_FUNCTIONS:
-            with self.subTest((func, '(func)')):
-                _testinternalcapi.verify_stateless_code(func)
-
-        for func in defs.FUNCTIONS:
-            if func not in defs.STATELESS_CODE:
-                with self.subTest((func, '(code)')):
-                    with self.assertRaises(Exception):
-                        _testinternalcapi.verify_stateless_code(func.__code__)
-
-            if func not in defs.STATELESS_FUNCTIONS:
-                with self.subTest((func, '(func)')):
-                    with self.assertRaises(Exception):
-                        _testinternalcapi.verify_stateless_code(func)
-
 
 def isinterned(s):
     return s is sys.intern(('_' + s + '_')[1:-1])

Modules/_testinternalcapi.c

@@ -1165,47 +1165,6 @@ get_code_var_counts(PyObject *self, PyObject *_args, PyObject *_kwargs)
     return NULL;
 }
 
-static PyObject *
-verify_stateless_code(PyObject *self, PyObject *args, PyObject *kwargs)
-{
-    PyThreadState *tstate = _PyThreadState_GET();
-    PyObject *codearg;
-    PyObject *globalnames = NULL;
-    PyObject *globalsns = NULL;
-    PyObject *builtinsns = NULL;
-    static char *kwlist[] = {"code", "globalnames",
-                             "globalsns", "builtinsns", NULL};
-    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
-                    "O|O!O!O!:get_code_var_counts", kwlist,
-                    &codearg, &PySet_Type, &globalnames,
-                    &PyDict_Type, &globalsns, &PyDict_Type, &builtinsns))
-    {
-        return NULL;
-    }
-    if (PyFunction_Check(codearg)) {
-        if (globalsns == NULL) {
-            globalsns = PyFunction_GET_GLOBALS(codearg);
-        }
-        if (builtinsns == NULL) {
-            builtinsns = PyFunction_GET_BUILTINS(codearg);
-        }
-        codearg = PyFunction_GET_CODE(codearg);
-    }
-    else if (!PyCode_Check(codearg)) {
-        PyErr_SetString(PyExc_TypeError,
-                        "argument must be a code object or a function");
-        return NULL;
-    }
-    PyCodeObject *code = (PyCodeObject *)codearg;
-
-    if (_PyCode_VerifyStateless(
-                tstate, code, globalnames, globalsns, builtinsns) < 0)
-    {
-        return NULL;
-    }
-    Py_RETURN_NONE;
-}
-
 #ifdef _Py_TIER2
 
 static PyObject *
@@ -2333,8 +2292,6 @@ static PyMethodDef module_functions[] = {
     {"get_co_localskinds", get_co_localskinds, METH_O, NULL},
     {"get_code_var_counts", _PyCFunction_CAST(get_code_var_counts),
      METH_VARARGS | METH_KEYWORDS, NULL},
-    {"verify_stateless_code", _PyCFunction_CAST(verify_stateless_code),
-     METH_VARARGS | METH_KEYWORDS, NULL},
 #ifdef _Py_TIER2
     {"add_executor_dependency", add_executor_dependency, METH_VARARGS, NULL},
     {"invalidate_executors", invalidate_executors, METH_O, NULL},