Update PyUnstable_InterpreterFrame_GetLocal to follow PyDict_GetItemRef convention

Author: guilhermeleobas

Doc/c-api/frame.rst

@@ -245,15 +245,15 @@ Unless using :pep:`523`, you will not need this.
    .. versionadded:: 3.12
 
 
-.. c:function:: PyObject* PyUnstable_InterpreterFrame_GetLocal(struct _PyInterpreterFrame *frame, Py_ssize_t index)
+.. c:function:: int PyUnstable_InterpreterFrame_GetLocal(struct _PyInterpreterFrame *frame, Py_ssize_t index, PyObject **result)
 
-   Return a new :term:`strong reference` to the local variable at *index* in the
-   frame's localsplus array, with cell and free variables unboxed to their
-   contents.  Free variables are resolved from the function closure, so this
-   also works on a frame that has not started executing.
+   Retrieve the local variable at *index* in the frame's localsplus array, with
+   cell and free variables unboxed to their contents.  Free variables are
+   resolved from the function closure, so this also works on a frame that has
+   not started executing.
 
-   *index* must be in range ``[0, co_nlocalsplus)``.  Return ``NULL`` with an
-   :exc:`IndexError` set if it is out of range, or ``NULL`` without an exception
-   set if the slot is unset or hidden.
+   * On success, store a new :term:`strong reference` in *result* and return ``1``.
+   * If the slot is unset or hidden, store ``NULL`` in *result* and return ``0``.
+   * On error, raise an exception, store ``NULL`` in *result* and return ``-1``.
 
    .. versionadded:: next

Include/cpython/pyframe.h

@@ -38,5 +38,5 @@ PyAPI_FUNC(int) PyUnstable_InterpreterFrame_GetLine(struct _PyInterpreterFrame *
 
 /* Returns a new (strong) reference to the local variable at `index` in the
  * frame's localsplus array. */
-PyAPI_FUNC(PyObject *) PyUnstable_InterpreterFrame_GetLocal(
-    struct _PyInterpreterFrame *frame, Py_ssize_t index);
+PyAPI_FUNC(int) PyUnstable_InterpreterFrame_GetLocal(
+    struct _PyInterpreterFrame *frame, Py_ssize_t index, PyObject **result);

Modules/_testinternalcapi.c

@@ -1533,12 +1533,13 @@ get_frame_locals(PyObject *self, PyObject *Py_UNUSED(ignored))
         return NULL;
     }
     for (Py_ssize_t i = 0; i < n; i++) {
-        PyObject *value = PyUnstable_InterpreterFrame_GetLocal(frame, i);
-        if (value == NULL) {
-            if (PyErr_Occurred()) {
-                Py_DECREF(dict);
-                return NULL;
-            }
+        PyObject *value;
+        int rc = PyUnstable_InterpreterFrame_GetLocal(frame, i, &value);
+        if (rc < 0) {
+            Py_DECREF(dict);
+            return NULL;
+        }
+        if (rc == 0) {
             continue;  // unset or hidden slot
         }
         PyObject *name = PyTuple_GET_ITEM(co->co_localsplusnames, i);

Objects/frameobject.c

@@ -2247,29 +2247,34 @@ frame_get_var(_PyInterpreterFrame *frame, PyCodeObject *co, int i,
 }
 
 
-PyObject *
+int
 PyUnstable_InterpreterFrame_GetLocal(_PyInterpreterFrame *frame,
-                                     Py_ssize_t index)
+                                     Py_ssize_t index, PyObject **result)
 {
     PyCodeObject *co = _PyFrame_GetCode(frame);
+    *result = NULL;
     if (index < 0 || index >= co->co_nlocalsplus) {
         PyErr_Format(
             PyExc_IndexError,
             "PyUnstable_InterpreterFrame_GetLocal: index %zd out of range [0, %d)",
             index, co->co_nlocalsplus);
-        return NULL;
+        return -1;
     }
 
     int offset = PyUnstable_Code_GetFirstFree(co);  // co_nlocalsplus - co_nfreevars
     if (index < offset) {
         // Local or cell variable. frame_get_var unboxes cells and copes with
         // not-yet-started frames and arguments not yet promoted by MAKE_CELL.
         if (_PyLocals_GetKind(co->co_localspluskinds, (int)index) & CO_FAST_HIDDEN) {
-            return NULL;
+            return 0;
         }
         PyObject *value = NULL;
         frame_get_var(frame, co, (int)index, &value);
-        return value;  // strong reference, or NULL if unset
+        if (value == NULL) {
+            return 0;
+        }
+        *result = value;  // strong reference
+        return 1;
     }
 
     // Free variable: read from the function closure rather than localsplus.
@@ -2278,9 +2283,14 @@ PyUnstable_InterpreterFrame_GetLocal(_PyInterpreterFrame *frame,
     {
         PyFunctionObject *func = _PyFrame_GetFunction(frame);
         PyObject *cell = PyTuple_GET_ITEM(func->func_closure, index - offset);
-        return PyCell_GetRef((PyCellObject *)cell);
+        PyObject *value = PyCell_GetRef((PyCellObject *)cell);
+        if (value == NULL) {
+            return 0;
+        }
+        *result = value;
+        return 1;
     }
-    return NULL;
+    return 0;
 }