gh-74929: Implement PEP 667

Include/ceval.h

@@ -22,6 +22,10 @@ PyAPI_FUNC(PyObject *) PyEval_GetGlobals(void);
 PyAPI_FUNC(PyObject *) PyEval_GetLocals(void);
 PyAPI_FUNC(PyFrameObject *) PyEval_GetFrame(void);
 
+PyAPI_FUNC(PyObject *) PyEval_GetFrameBuiltins(void);
+PyAPI_FUNC(PyObject *) PyEval_GetFrameGlobals(void);
+PyAPI_FUNC(PyObject *) PyEval_GetFrameLocals(void);
+
 PyAPI_FUNC(int) Py_AddPendingCall(int (*func)(void *), void *arg);
 PyAPI_FUNC(int) Py_MakePendingCalls(void);
 

Include/cpython/frameobject.h

@@ -27,3 +27,9 @@ PyAPI_FUNC(int) _PyFrame_IsEntryFrame(PyFrameObject *frame);
 
 PyAPI_FUNC(int) PyFrame_FastToLocalsWithError(PyFrameObject *f);
 PyAPI_FUNC(void) PyFrame_FastToLocals(PyFrameObject *);
+
+
+typedef struct{
+ PyObject_HEAD
+ PyFrameObject* frame;
+} PyFrameLocalsProxyObject;

Include/cpython/pyframe.h

@@ -3,8 +3,10 @@
 #endif
 
 PyAPI_DATA(PyTypeObject) PyFrame_Type;
+PyAPI_DATA(PyTypeObject) PyFrameLocalsProxy_Type;
 
 #define PyFrame_Check(op) Py_IS_TYPE((op), &PyFrame_Type)
+#define PyFrameLocalsProxy_Check(op) Py_IS_TYPE((op), &PyFrameLocalsProxy_Type)
 
 PyAPI_FUNC(PyFrameObject *) PyFrame_GetBack(PyFrameObject *frame);
 PyAPI_FUNC(PyObject *) PyFrame_GetLocals(PyFrameObject *frame);

Include/internal/pycore_frame.h

@@ -25,7 +25,7 @@ struct _frame{
  int f_lineno; /* Current line number. Only valid if non-zero */
  char f_trace_lines; /* Emit per-line trace events? */
  char f_trace_opcodes; /* Emit per-opcode trace events? */
-char f_fast_as_locals; /* Have the fast locals of this frame been converted to a dict? */
+PyObject *f_extra_locals; /* Dict for locals set by users using f_locals, could be NULL */
  /* The frame data, if this frame object owns the frame */
  PyObject *_f_frame_data[1];
 };
@@ -242,14 +242,11 @@ _PyFrame_ClearExceptCode(_PyInterpreterFrame * frame);
 int
 _PyFrame_Traverse(_PyInterpreterFrame *frame, visitproc visit, void *arg);
 
-PyObject *
-_PyFrame_GetLocals(_PyInterpreterFrame *frame, int include_hidden);
-
-int
-_PyFrame_FastToLocalsWithError(_PyInterpreterFrame *frame);
+bool
+_PyFrame_HasHiddenLocals(_PyInterpreterFrame *frame);
 
-void
-_PyFrame_LocalsToFast(_PyInterpreterFrame *frame, int clear);
+PyObject *
+_PyFrame_GetLocals(_PyInterpreterFrame *frame);
 
 static inline bool
 _PyThreadState_HasStackSpace(PyThreadState *tstate, int size)

Lib/test/test_frame.py

@@ -1,3 +1,4 @@
+import copy
 import gc
 import operator
 import re
@@ -13,7 +14,7 @@
  _testcapi = None
 
 from test import support
-from test.support import threading_helper, Py_GIL_DISABLED
+from test.support import import_helper, threading_helper, Py_GIL_DISABLED
 from test.support.script_helper import assert_python_ok
 
 
@@ -198,14 +199,6 @@ def inner():
  tb = tb.tb_next
  return frames
 
- def test_locals(self):
- f, outer, inner = self.make_frames()
- outer_locals = outer.f_locals
- self.assertIsInstance(outer_locals.pop('inner'), types.FunctionType)
- self.assertEqual(outer_locals,{'x': 5, 'y': 6})
- inner_locals = inner.f_locals
- self.assertEqual(inner_locals,{'x': 5, 'z': 7})
-
  def test_clear_locals(self):
  # Test f_locals after clear() (issue #21897)
  f, outer, inner = self.make_frames()
@@ -217,8 +210,8 @@ def test_clear_locals(self):
  def test_locals_clear_locals(self):
  # Test f_locals before and after clear() (to exercise caching)
  f, outer, inner = self.make_frames()
- outer.f_locals
- inner.f_locals
+self.assertNotEqual(outer.f_locals,{})
+self.assertNotEqual(inner.f_locals,{})
  outer.clear()
  inner.clear()
  self.assertEqual(outer.f_locals,{})
@@ -269,6 +262,177 @@ def inner():
  r"^<frame at 0x[0-9a-fA-F]+, file %s, line %d, code inner>$"
  % (file_repr, offset + 5))
 
+class TestFrameLocals(unittest.TestCase):
+ def test_scope(self):
+ class A:
+ x = 1
+ sys._getframe().f_locals['x'] = 2
+ sys._getframe().f_locals['y'] = 2
+
+ self.assertEqual(A.x, 2)
+ self.assertEqual(A.y, 2)
+
+ def f():
+ x = 1
+ sys._getframe().f_locals['x'] = 2
+ sys._getframe().f_locals['y'] = 2
+ self.assertEqual(x, 2)
+ self.assertEqual(locals()['y'], 2)
+ f()
+
+ def test_closure(self):
+ x = 1
+ y = 2
+
+ def f():
+ z = x + y
+ d = sys._getframe().f_locals
+ self.assertEqual(d['x'], 1)
+ self.assertEqual(d['y'], 2)
+ d['x'] = 2
+ d['y'] = 3
+
+ f()
+ self.assertEqual(x, 2)
+ self.assertEqual(y, 3)
+
+ def test_as_dict(self):
+ x = 1
+ y = 2
+ d = sys._getframe().f_locals
+ # self, x, y, d
+ self.assertEqual(len(d), 4)
+ self.assertIs(d['d'], d)
+ self.assertEqual(set(d.keys()), set(['x', 'y', 'd', 'self']))
+ self.assertEqual(len(d.values()), 4)
+ self.assertIn(1, d.values())
+ self.assertEqual(len(d.items()), 4)
+ self.assertIn(('x', 1), d.items())
+ self.assertEqual(d.__getitem__('x'), 1)
+ d.__setitem__('x', 2)
+ self.assertEqual(d['x'], 2)
+ self.assertEqual(d.get('x'), 2)
+ self.assertIs(d.get('non_exist', None), None)
+ self.assertEqual(d.__len__(), 4)
+ self.assertEqual(set([key for key in d]), set(['x', 'y', 'd', 'self']))
+ self.assertIn('x', d)
+ self.assertTrue(d.__contains__('x'))
+
+ self.assertEqual(reversed(d), list(reversed(d.keys())))
+
+ d.update({'x': 3, 'z': 4})
+ self.assertEqual(d['x'], 3)
+ self.assertEqual(d['z'], 4)
+
+ with self.assertRaises(TypeError):
+ d.update([1, 2])
+
+ self.assertEqual(d.setdefault('x', 5), 3)
+ self.assertEqual(d.setdefault('new', 5), 5)
+ self.assertEqual(d['new'], 5)
+
+ with self.assertRaises(KeyError):
+ d['non_exist']
+
+ def test_as_number(self):
+ x = 1
+ y = 2
+ d = sys._getframe().f_locals
+ self.assertIn('z', d |{'z': 3})
+ d |={'z': 3}
+ self.assertEqual(d['z'], 3)
+ d |={'y': 3}
+ self.assertEqual(d['y'], 3)
+ with self.assertRaises(TypeError):
+ d |= 3
+ with self.assertRaises(TypeError):
+ _ = d | [3]
+
+ def test_non_string_key(self):
+ d = sys._getframe().f_locals
+ d[1] = 2
+ self.assertEqual(d[1], 2)
+
+ def test_write_with_hidden(self):
+ def f():
+ f_locals = [sys._getframe().f_locals for b in [0]][0]
+ f_locals['b'] = 2
+ f_locals['c'] = 3
+ self.assertEqual(b, 2)
+ self.assertEqual(c, 3)
+ b = 0
+ c = 0
+ f()
+
+ def test_repr(self):
+ x = 1
+ # Introduce a reference cycle
+ frame = sys._getframe()
+ self.assertEqual(repr(frame.f_locals), repr(dict(frame.f_locals)))
+
+ def test_delete(self):
+ x = 1
+ d = sys._getframe().f_locals
+ with self.assertRaises(TypeError):
+ del d['x']
+
+ with self.assertRaises(AttributeError):
+ d.clear()
+
+ with self.assertRaises(AttributeError):
+ d.pop('x')
+
+ @support.cpython_only
+ def test_sizeof(self):
+ proxy = sys._getframe().f_locals
+ support.check_sizeof(self, proxy, support.calcobjsize("P"))
+
+ def test_unsupport(self):
+ x = 1
+ d = sys._getframe().f_locals
+ with self.assertRaises(AttributeError):
+ d.copy()
+
+ with self.assertRaises(TypeError):
+ copy.copy(d)
+
+ with self.assertRaises(TypeError):
+ copy.deepcopy(d)
+
+
+class TestFrameCApi(unittest.TestCase):
+ def test_basic(self):
+ x = 1
+ ctypes = import_helper.import_module('ctypes')
+ PyEval_GetFrameLocals = ctypes.pythonapi.PyEval_GetFrameLocals
+ PyEval_GetFrameLocals.restype = ctypes.py_object
+ frame_locals = PyEval_GetFrameLocals()
+ self.assertTrue(type(frame_locals), dict)
+ self.assertEqual(frame_locals['x'], 1)
+ frame_locals['x'] = 2
+ self.assertEqual(x, 1)
+
+ PyEval_GetFrameGlobals = ctypes.pythonapi.PyEval_GetFrameGlobals
+ PyEval_GetFrameGlobals.restype = ctypes.py_object
+ frame_globals = PyEval_GetFrameGlobals()
+ self.assertTrue(type(frame_globals), dict)
+ self.assertIs(frame_globals, globals())
+
+ PyEval_GetFrameBuiltins = ctypes.pythonapi.PyEval_GetFrameBuiltins
+ PyEval_GetFrameBuiltins.restype = ctypes.py_object
+ frame_builtins = PyEval_GetFrameBuiltins()
+ self.assertEqual(frame_builtins, __builtins__)
+
+ PyFrame_GetLocals = ctypes.pythonapi.PyFrame_GetLocals
+ PyFrame_GetLocals.argtypes = [ctypes.py_object]
+ PyFrame_GetLocals.restype = ctypes.py_object
+ frame = sys._getframe()
+ f_locals = PyFrame_GetLocals(frame)
+ self.assertTrue(f_locals['x'], 1)
+ f_locals['x'] = 2
+ self.assertEqual(x, 2)
+
+
 class TestIncompleteFrameAreInvisible(unittest.TestCase):
 
  def test_issue95818(self):

Lib/test/test_listcomps.py

@@ -622,9 +622,14 @@ def test_exception_in_post_comp_call(self):
 
  def test_frame_locals(self):
  code = """
- val = [sys._getframe().f_locals for a in [0]][0]["a"]
+ val = "a" in [sys._getframe().f_locals for a in [0]][0]
  """
  import sys
+ self._check_in_scopes(code,{"val": False}, ns={"sys": sys})
+
+ code = """
+ val = [sys._getframe().f_locals["a"] for a in [0]][0]
+ """
  self._check_in_scopes(code,{"val": 0}, ns={"sys": sys})
 
  def _recursive_replace(self, maybe_code):

Lib/test/test_peepholer.py

@@ -933,23 +933,6 @@ def f():
  self.assertNotInBytecode(f, "LOAD_FAST_CHECK")
  return f
 
- def test_deleting_local_warns_and_assigns_none(self):
- f = self.make_function_with_no_checks()
- co_code = f.__code__.co_code
- def trace(frame, event, arg):
- if event == 'line' and frame.f_lineno == 4:
- del frame.f_locals["x"]
- sys.settrace(None)
- return None
- return trace
- e = r"assigning None to unbound local 'x'"
- with self.assertWarnsRegex(RuntimeWarning, e):
- sys.settrace(trace)
- f()
- self.assertInBytecode(f, "LOAD_FAST")
- self.assertNotInBytecode(f, "LOAD_FAST_CHECK")
- self.assertEqual(f.__code__.co_code, co_code)
-
  def test_modifying_local_does_not_add_check(self):
  f = self.make_function_with_no_checks()
  def trace(frame, event, arg):

Lib/test/test_sys.py

@@ -1555,7 +1555,7 @@ class C(object): pass
  def func():
  return sys._getframe()
  x = func()
- check(x, size('3Pi3c7P2ic??2P'))
+ check(x, size('3Pi2cP7P2ic??2P'))
  # function
  def func(): pass
  check(func, size('15Pi'))

Misc/NEWS.d/next/Core and Builtins/2024-04-27-21-44-40.gh-issue-74929.C2nESp.rst

@@ -0,0 +1 @@
+Implement PEP 667 - converted ``frame.f_locals`` to a write through proxy

Misc/stable_abi.toml

@@ -2501,3 +2501,9 @@
  added = '3.13'
 [function.PyType_GetModuleByDef]
  added = '3.13'
+[function.PyEval_GetFrameBuiltins]
+ added = '3.13'
+[function.PyEval_GetFrameGlobals]
+ added = '3.13'
+[function.PyEval_GetFrameLocals]
+ added = '3.13'