gh-121306: allow a mapping as __dict__ of object

Lib/test/test_capi/test_eval_code_ex.py

@@ -23,9 +23,9 @@ def f():
         self.assertEqual(eval_code_ex(code, dict(a=1)), 1)
 
         self.assertRaises(NameError, eval_code_ex, code, {})
-        self.assertRaises(SystemError, eval_code_ex, code, UserDict(a=1))
-        self.assertRaises(SystemError, eval_code_ex, code, [])
-        self.assertRaises(SystemError, eval_code_ex, code, 1)
+        eval_code_ex(code, UserDict(a=1))
+        self.assertRaises(TypeError, eval_code_ex, code, [])
+        self.assertRaises(TypeError, eval_code_ex, code, 1)
         # CRASHES eval_code_ex(code, NULL)
         # CRASHES eval_code_ex(1, {})
         # CRASHES eval_code_ex(NULL, {})

Lib/test/test_capi/test_run.py

@@ -64,9 +64,9 @@ def run(s, *args):
         self.assertRaises(SystemError, run, b'a\n', NULL)
         self.assertRaises(SystemError, run, b'a\n', NULL, {})
         self.assertRaises(SystemError, run, b'a\n', NULL, dict(a=1))
-        self.assertRaises(SystemError, run, b'a\n', UserDict())
-        self.assertRaises(SystemError, run, b'a\n', UserDict(), {})
-        self.assertRaises(SystemError, run, b'a\n', UserDict(), dict(a=1))
+        self.assertRaises(NameError, run, b'a\n', UserDict())
+        self.assertRaises(NameError, run, b'a\n', UserDict(), {})
+        run(b'a\n', UserDict(), dict(a=1))
 
         # CRASHES run(NULL, {})
 
@@ -97,9 +97,9 @@ def run(*args):
         self.assertRaises(SystemError, run, NULL)
         self.assertRaises(SystemError, run, NULL, {})
         self.assertRaises(SystemError, run, NULL, dict(a=1))
-        self.assertRaises(SystemError, run, UserDict())
-        self.assertRaises(SystemError, run, UserDict(), {})
-        self.assertRaises(SystemError, run, UserDict(), dict(a=1))
+        self.assertRaises(NameError, run, UserDict())
+        self.assertRaises(NameError, run, UserDict(), {})
+        run(UserDict(), dict(a=1))
 
     @unittest.skipUnless(TESTFN_UNDECODABLE, 'only works if there are undecodable paths')
     @unittest.skipIf(os.name == 'nt', 'does not work on Windows')

Lib/test/test_compile.py

@@ -97,7 +97,7 @@ def keys(self):
         self.assertEqual(m.results, ('z', g))
         exec('z = locals()', g, m)
         self.assertEqual(m.results, ('z', m))
-        self.assertRaises(TypeError, exec, 'z = b', m)
+        self.assertRaises(NameError, exec, 'z = b', m)
 
         class A:
             "Non-mapping"

Objects/frameobject.c

@@ -2105,17 +2105,18 @@ PyFrame_GetGenerator(PyFrameObject *frame)
 PyObject*
 _PyEval_BuiltinsFromGlobals(PyThreadState *tstate, PyObject *globals)
 {
-    PyObject *builtins = PyDict_GetItemWithError(globals, &_Py_ID(__builtins__));
-    if (builtins) {
+    PyObject *builtins;
+    int has_builtins = PyMapping_GetOptionalItem(
+        globals, &_Py_ID(__builtins__), &builtins);
+    if (has_builtins < 0) {
+        return NULL;
+    }
+    if (has_builtins) {
         if (PyModule_Check(builtins)) {
-            builtins = _PyModule_GetDict(builtins);
+            builtins = Py_XNewRef(_PyModule_GetDict(builtins));
             assert(builtins != NULL);
         }
         return builtins;
     }
-    if (PyErr_Occurred()) {
-        return NULL;
-    }
-
-    return _PyEval_GetBuiltins(tstate);
+    return Py_NewRef(_PyEval_GetBuiltins(tstate));
 }

Objects/funcobject.c

@@ -103,7 +103,7 @@ PyFunctionObject *
 _PyFunction_FromConstructor(PyFrameConstructor *constr)
 {
     PyObject *module;
-    if (PyDict_GetItemRef(constr->fc_globals, &_Py_ID(__name__), &module) < 0) {
+    if (PyMapping_GetOptionalItemString(constr->fc_globals, "__name__", &module) < 0) {
         return NULL;
     }
 
@@ -174,15 +174,14 @@ PyFunction_NewWithQualName(PyObject *code, PyObject *globals, PyObject *qualname
     // __module__: Use globals['__name__'] if it exists, or NULL.
     PyObject *module;
     PyObject *builtins = NULL;
-    if (PyDict_GetItemRef(globals, &_Py_ID(__name__), &module) < 0) {
+    if (PyMapping_GetOptionalItemString(globals, "__name__", &module) < 0) {
         goto error;
     }
 
-    builtins = _PyEval_BuiltinsFromGlobals(tstate, globals); // borrowed ref
+    builtins = _PyEval_BuiltinsFromGlobals(tstate, globals);
     if (builtins == NULL) {
         goto error;
     }
-    Py_INCREF(builtins);
 
     PyFunctionObject *op = PyObject_GC_New(PyFunctionObject, &PyFunction_Type);
     if (op == NULL) {

Python/bltinmodule.c

@@ -963,10 +963,8 @@ builtin_eval_impl(PyObject *module, PyObject *source, PyObject *globals,
         PyErr_SetString(PyExc_TypeError, "locals must be a mapping");
         return NULL;
     }
-    if (globals != Py_None && !PyDict_Check(globals)) {
-        PyErr_SetString(PyExc_TypeError, PyMapping_Check(globals) ?
-            "globals must be a real dict; try eval(expr, {}, mapping)"
-            : "globals must be a dict");
+    if (globals != Py_None && !PyMapping_Check(globals)) {
+        PyErr_SetString(PyExc_TypeError, "globals must be a mapping");
         return NULL;
     }
     if (globals == Py_None) {
@@ -993,9 +991,9 @@ builtin_eval_impl(PyObject *module, PyObject *source, PyObject *globals,
         goto error;
     }
 
-    int r = PyDict_Contains(globals, &_Py_ID(__builtins__));
+    int r = PyMapping_HasKeyStringWithError(globals, "__builtins__");
     if (r == 0) {
-        r = PyDict_SetItem(globals, &_Py_ID(__builtins__), PyEval_GetBuiltins());
+        r = PyMapping_SetItemString(globals, "__builtins__", PyEval_GetBuiltins());
     }
     if (r < 0) {
         goto error;
@@ -1084,8 +1082,8 @@ builtin_exec_impl(PyObject *module, PyObject *source, PyObject *globals,
         Py_INCREF(locals);
     }
 
-    if (!PyDict_Check(globals)) {
-        PyErr_Format(PyExc_TypeError, "exec() globals must be a dict, not %.100s",
+    if (!PyMapping_Check(globals)) {
+        PyErr_Format(PyExc_TypeError, "globals must be a mapping or None, not %.100s",
                      Py_TYPE(globals)->tp_name);
         goto error;
     }
@@ -1095,9 +1093,9 @@ builtin_exec_impl(PyObject *module, PyObject *source, PyObject *globals,
             Py_TYPE(locals)->tp_name);
         goto error;
     }
-    int r = PyDict_Contains(globals, &_Py_ID(__builtins__));
+    int r = PyMapping_HasKeyStringWithError(globals, "__builtins__");
     if (r == 0) {
-        r = PyDict_SetItem(globals, &_Py_ID(__builtins__), PyEval_GetBuiltins());
+        r = PyMapping_SetItemString(globals, "__builtins__", PyEval_GetBuiltins());
     }
     if (r < 0) {
         goto error;

Python/bytecodes.c

@@ -1466,21 +1466,21 @@ dummy_func(
 
         inst(STORE_GLOBAL, (v --)) {
             PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
-            int err = PyDict_SetItem(GLOBALS(), name, PyStackRef_AsPyObjectBorrow(v));
+            int err = PyObject_SetItem(GLOBALS(), name, PyStackRef_AsPyObjectBorrow(v));
             DECREF_INPUTS();
             ERROR_IF(err, error);
         }
 
         inst(DELETE_GLOBAL, (--)) {
             PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
-            int err = PyDict_Pop(GLOBALS(), name, NULL);
+            int err = PyMapping_DelItem(GLOBALS(), name);
             // Can't use ERROR_IF here.
             if (err < 0) {
-                ERROR_NO_POP();
-            }
-            if (err == 0) {
-                _PyEval_FormatExcCheckArg(tstate, PyExc_NameError,
-                                          NAME_ERROR_MSG, name);
+                if (_PyErr_Occurred(tstate) &&
+                    _PyErr_ExceptionMatches(tstate, PyExc_KeyError)) {
+                    _PyEval_FormatExcCheckArg(tstate, PyExc_NameError,
+                                              NAME_ERROR_MSG, name);
+                }
                 ERROR_NO_POP();
             }
         }
@@ -1551,7 +1551,7 @@ dummy_func(
                 ERROR_NO_POP();
             }
             if (v_o == NULL) {
-                if (PyDict_GetItemRef(GLOBALS(), name, &v_o) < 0) {
+                if (PyMapping_GetOptionalItem(GLOBALS(), name, &v_o) < 0) {
                     ERROR_NO_POP();
                 }
                 if (v_o == NULL) {

Python/ceval.c

@@ -205,7 +205,7 @@ maybe_lltrace_resume_frame(_PyInterpreterFrame *frame, _PyInterpreterFrame *skip
     if (frame == skip_frame) {
         return 0;
     }
-    int r = PyDict_Contains(globals, &_Py_ID(__lltrace__));
+    int r = PyMapping_HasKeyWithError(globals, &_Py_ID(__lltrace__));
     if (r < 0) {
         return -1;
     }
@@ -623,6 +623,7 @@ PyEval_EvalCode(PyObject *co, PyObject *globals, PyObject *locals)
     EVAL_CALL_STAT_INC(EVAL_CALL_LEGACY);
     PyObject *res = _PyEval_Vector(tstate, func, locals, NULL, 0, NULL);
     Py_DECREF(func);
+    Py_DECREF(builtins);
     return res;
 }
 
@@ -1946,6 +1947,7 @@ PyEval_EvalCodeEx(PyObject *_co, PyObject *globals, PyObject *locals,
     Py_XDECREF(kwnames);
     PyMem_Free(newargs);
     Py_DECREF(defaults);
+    Py_DECREF(builtins);
     return res;
 }
 

Python/pythonrun.c

@@ -1273,16 +1273,16 @@ run_eval_code_obj(PyThreadState *tstate, PyCodeObject *co, PyObject *globals, Py
     _PyRuntime.signals.unhandled_keyboard_interrupt = 0;
 
     /* Set globals['__builtins__'] if it doesn't exist */
-    if (!globals || !PyDict_Check(globals)) {
-        PyErr_SetString(PyExc_SystemError, "globals must be a real dict");
+    if (!globals || !PyMapping_Check(globals)) {
+        PyErr_SetString(PyExc_SystemError, "globals must be a mapping");
         return NULL;
     }
-    int has_builtins = PyDict_ContainsString(globals, "__builtins__");
+    int has_builtins = PyMapping_HasKeyStringWithError(globals, "__builtins__");
     if (has_builtins < 0) {
         return NULL;
     }
     if (!has_builtins) {
-        if (PyDict_SetItemString(globals, "__builtins__",
+        if (PyMapping_SetItemString(globals, "__builtins__",
                                  tstate->interp->builtins) < 0)
         {
             return NULL;