gh-130382: add missing _PyReftracerTrack to ceval DECREF

Lib/test/test_capi/test_misc.py

@@ -2884,5 +2884,28 @@ def test_pack_version_ctypes(self):
                 self.assertEqual(result, expected)
 
 
+class TestCEval(unittest.TestCase):
+   def test_ceval_decref(self):
+        def f():
+            l = []
+            del l
+
+        def g():
+            l = [], []
+            del l
+
+        _testcapi.toggle_reftrace_counter()
+        f()
+        refs = _testcapi.toggle_reftrace_counter()
+        # sometimes we get a stray DECREF from somewhere else (other thread?)
+        # doesn't happen outside of test
+        self.assertIn(refs, ((1, 1), (1, 2)))
+
+        _testcapi.toggle_reftrace_counter()
+        g()
+        refs = _testcapi.toggle_reftrace_counter()
+        self.assertIn(refs, ((3, 3), (3, 4)))
+
+
 if __name__ == "__main__":
     unittest.main()

Misc/NEWS.d/next/Core_and_Builtins/2025-02-28-16-13-02.gh-issue-130382.66VTmy.rst

@@ -0,0 +1 @@
+Fix ``PyRefTracer_DESTROY`` not being sent from :file:`Python/ceval.c` ``Py_DECREF()``.

Modules/_testcapimodule.c

@@ -2515,6 +2515,108 @@ code_offset_to_line(PyObject* self, PyObject* const* args, Py_ssize_t nargsf)
 }
 
 
+typedef struct {
+    Py_ssize_t create_count;
+    Py_ssize_t destroy_count;
+    void *prev_data;
+    int (*prev_tracer)(PyObject *, PyRefTracerEvent, void *);
+} reftrace_counter_data;
+
+static int
+_reftrace_counter(PyObject *obj, PyRefTracerEvent event, void *counter_data)
+{
+    if (event == PyRefTracer_CREATE) {
+        ((reftrace_counter_data *)counter_data)->create_count++;
+    }
+    else {  // PyRefTracer_DESTROY
+        ((reftrace_counter_data *)counter_data)->destroy_count++;
+    }
+    return 0;
+}
+
+void
+reftrace_counter_capsule_destructor(PyObject *capsule)
+{
+    reftrace_counter_data *counter_data = (reftrace_counter_data *)PyCapsule_GetPointer(capsule, "counter_data");
+
+    if (counter_data) {
+        if (counter_data->prev_tracer != (void *)_reftrace_counter) {
+            // juuust in case, to not segfault
+            PyRefTracer_SetTracer(counter_data->prev_tracer, counter_data->prev_data);
+        }
+
+        PyMem_Free(counter_data);
+    }
+}
+
+// A simple reftrace counter for very simple tests
+static PyObject *
+toggle_reftrace_counter(PyObject *ob, PyObject *args)
+{
+    reftrace_counter_data *counter_data;
+    PyObject *capsule;
+
+    if (PyObject_GetOptionalAttrString(ob, "_reftrace_counter_data", &capsule)) {
+        if (!PyCapsule_IsValid(capsule, "counter_data")) {
+            PyErr_SetString(PyExc_ValueError, "something went wrong, _reftrace_counter_data is invalid");
+            return NULL;
+        }
+
+        counter_data = PyCapsule_GetPointer(capsule, "counter_data");
+
+        if (counter_data == NULL) {
+            PyErr_SetString(PyExc_ValueError, "something went wrong, _reftrace_counter_data is invalid");
+            return NULL;
+        }
+    }
+    else {
+        counter_data = (reftrace_counter_data *)PyMem_Malloc(sizeof(reftrace_counter_data));
+
+        if (counter_data == NULL) {
+            PyErr_NoMemory();
+            return NULL;
+        }
+
+        capsule = PyCapsule_New(counter_data, "counter_data", reftrace_counter_capsule_destructor);
+
+        if (capsule == NULL) {
+            PyMem_Free(counter_data);
+            return NULL;
+        }
+
+        counter_data->prev_tracer = (void *)_reftrace_counter;  // sentinel
+
+        if (PyModule_Add(ob, "_reftrace_counter_data", capsule)) {
+            return NULL;
+        }
+
+        Py_INCREF(capsule);
+    }
+
+    if (counter_data->prev_tracer == (void *)_reftrace_counter) {
+        // toggle counter on
+        counter_data->create_count = counter_data->destroy_count = 0;
+        counter_data->prev_tracer = PyRefTracer_GetTracer(&counter_data->prev_data);
+
+        PyRefTracer_SetTracer(_reftrace_counter, counter_data);
+
+        Py_DECREF(capsule);
+        Py_RETURN_NONE;
+    }
+
+    // toggle counter off
+    PyRefTracer_SetTracer(counter_data->prev_tracer, counter_data->prev_data);
+
+    Py_ssize_t create_count = counter_data->create_count - 1;  // because of PyObject_GetOptionalAttrString
+    Py_ssize_t destroy_count = counter_data->destroy_count;
+    counter_data->prev_tracer = (void *)_reftrace_counter;
+
+    Py_DECREF(capsule);
+
+    return Py_BuildValue("(nn)", create_count, destroy_count);
+}
+
+
 static PyMethodDef TestMethods[] = {
     {"set_errno",               set_errno,                       METH_VARARGS},
     {"test_config",             test_config,                     METH_NOARGS},
@@ -2608,6 +2710,7 @@ static PyMethodDef TestMethods[] = {
     {"finalize_thread_hang", finalize_thread_hang, METH_O, NULL},
     {"test_atexit", test_atexit, METH_NOARGS},
     {"code_offset_to_line", _PyCFunction_CAST(code_offset_to_line), METH_FASTCALL},
+    {"toggle_reftrace_counter", toggle_reftrace_counter, METH_VARARGS},
     {NULL, NULL} /* sentinel */
 };
 

Python/ceval.c

@@ -80,6 +80,7 @@
         } \
         _Py_DECREF_STAT_INC(); \
         if (--op->ob_refcnt == 0) { \
+            _PyReftracerTrack(op, PyRefTracer_DESTROY); \
             destructor dealloc = Py_TYPE(op)->tp_dealloc; \
             (*dealloc)(op); \
         } \