gh-140232: Do not track frozenset objects with immutables

Lib/test/test_set.py

@@ -9,6 +9,7 @@
 import warnings
 import weakref
 from random import randrange, shuffle
+import _testcapi
 from test import support
 from test.support import warnings_helper
 
@@ -2212,6 +2213,31 @@ def test_cuboctahedron(self):
             for cubevert in edge:
                 self.assertIn(cubevert, g)
 
+class TestPySet_Add(unittest.TestCase):
+    def test_set(self):
+        # Test the PySet_Add c-api for set objects
+        s = set()
+        self.assertEqual(_testcapi.pyset_add(s, 1), {1})
+        self.assertRaises(TypeError, _testcapi.pyset_add, s, [])
+
+    def test_frozenset(self):
+        # Test the PySet_Add c-api for frozenset objects
+        self.assertEqual(_testcapi.pyset_add(frozenset(), 1), frozenset([1]))
+        frozen_set = frozenset()
+        # if the argument to PySet_Add is a frozenset that is not uniquely references an error is generated
+        self.assertRaises(SystemError, _testcapi.pyset_add, frozen_set, 1)
+
+    def test_frozenset_gc_tracking(self):
+        # see gh-140234
+        class TrackedHashableClass():
+            pass
+
+        a = TrackedHashableClass()
+        result_set = _testcapi.pyset_add(frozenset(), 1)
+        self.assertFalse(gc.is_tracked(result_set))
+        result_set = _testcapi.pyset_add(frozenset(), a)
+        self.assertTrue(gc.is_tracked(result_set))
+
 
 #==============================================================================
 

Lib/test/test_sys.py

@@ -1876,7 +1876,10 @@ class S(set):
         check(S(), set(), '3P')
         class FS(frozenset):
             __slots__ = 'a', 'b', 'c'
-        check(FS(), frozenset(), '3P')
+
+        class mytuple(tuple):
+            pass
+        check(FS([mytuple()]), frozenset([mytuple()]), '3P')
         from collections import OrderedDict
         class OD(OrderedDict):
             __slots__ = 'a', 'b', 'c'

Misc/NEWS.d/next/Core_and_Builtins/2025-10-16-22-36-05.gh-issue-140232.u3srgv.rst

@@ -0,0 +1 @@
+Frozenset objects with immutable elements are no longer tracked by the garbage collector.

Modules/_testcapimodule.c

@@ -2435,6 +2435,26 @@ test_critical_sections(PyObject *module, PyObject *Py_UNUSED(args))
 }
 
 
+
+static PyObject *
+// Interface to PySet_Add, returning the set
+pyset_add(PyObject* self, PyObject* const* args, Py_ssize_t nargsf)
+{
+    Py_ssize_t nargs = _PyVectorcall_NARGS(nargsf);
+    if (nargs != 2) {
+        PyErr_SetString(PyExc_ValueError, "pyset_add requires exactly two arguments");
+        return NULL;
+    }
+    PyObject *set = args[0];
+    PyObject *item = args[1];
+
+    int return_value = PySet_Add(set, item);
+    if (return_value < 0) {
+        return NULL;
+    }
+    return Py_NewRef(set);
+}
+
 // Used by `finalize_thread_hang`.
 #if defined(_POSIX_THREADS) && !defined(__wasi__)
 static void finalize_thread_hang_cleanup_callback(void *Py_UNUSED(arg)) {
@@ -2658,7 +2678,7 @@ static PyMethodDef TestMethods[] = {
     {"return_null_without_error", return_null_without_error, METH_NOARGS},
     {"return_result_with_error", return_result_with_error, METH_NOARGS},
     {"getitem_with_error", getitem_with_error, METH_VARARGS},
-    {"Py_CompileString",     pycompilestring, METH_O},
+    {"Py_CompileString", pycompilestring, METH_O},
     {"raise_SIGINT_then_send_None", raise_SIGINT_then_send_None, METH_VARARGS},
     {"stack_pointer", stack_pointer, METH_NOARGS},
 #ifdef W_STOPCODE
@@ -2679,6 +2699,7 @@ static PyMethodDef TestMethods[] = {
     {"gen_get_code", gen_get_code, METH_O, NULL},
     {"get_feature_macros", get_feature_macros, METH_NOARGS, NULL},
     {"test_code_api", test_code_api, METH_NOARGS, NULL},
+    {"pyset_add", _PyCFunction_CAST(pyset_add), METH_FASTCALL, NULL},
     {"settrace_to_error", settrace_to_error, METH_O, NULL},
     {"settrace_to_record", settrace_to_record, METH_O, NULL},
     {"test_macros", test_macros, METH_NOARGS, NULL},

Objects/setobject.c

@@ -1368,6 +1368,26 @@ make_new_set_basetype(PyTypeObject *type, PyObject *iterable)
     return make_new_set(type, iterable);
 }
 
+void
+// gh-140232: check whether a frozenset can be untracked from the GC
+_PyFrozenSet_MaybeUntrack(PyObject *op)
+{
+    assert(op != NULL);
+    // subclasses of a frozenset can generate reference cycles, so do not untrack
+    if (!PyFrozenSet_CheckExact(op)) {
+        return;
+    }
+    // if no elements of a frozenset are tracked by the GC, we untrack the object
+    Py_ssize_t pos = 0;
+    setentry *entry;
+    while (set_next((PySetObject *)op, &pos, &entry)) {
+        if (_PyObject_GC_MAY_BE_TRACKED(entry->key)) {
+            return;
+        }
+    }
+    _PyObject_GC_UNTRACK(op);
+}
+
 static PyObject *
 make_new_frozenset(PyTypeObject *type, PyObject *iterable)
 {
@@ -1379,7 +1399,11 @@ make_new_frozenset(PyTypeObject *type, PyObject *iterable)
         /* frozenset(f) is idempotent */
         return Py_NewRef(iterable);
     }
-    return make_new_set(type, iterable);
+    PyObject *obj = make_new_set(type, iterable);
+    if (obj != NULL) {
+        _PyFrozenSet_MaybeUntrack(obj);
+    }
+    return obj;
 }
 
 static PyObject *
@@ -2932,7 +2956,11 @@ PySet_New(PyObject *iterable)
 PyObject *
 PyFrozenSet_New(PyObject *iterable)
 {
-    return make_new_set(&PyFrozenSet_Type, iterable);
+    PyObject *result = make_new_set(&PyFrozenSet_Type, iterable);
+    if (result != 0) {
+        _PyFrozenSet_MaybeUntrack(result);
+    }
+    return result;
 }
 
 Py_ssize_t
@@ -3010,6 +3038,11 @@ PySet_Add(PyObject *anyset, PyObject *key)
         // API limits the usage of `PySet_Add` to "fill in the values of brand
         // new frozensets before they are exposed to other code". In this case,
         // this can be done without a lock.
+
+        // since another key is added to the set, we must track the frozenset if needed
+        if (PyFrozenSet_CheckExact(anyset) && PyObject_GC_IsTracked(key) && !PyObject_GC_IsTracked(anyset) ) {
+            _PyObject_GC_TRACK(anyset);
+        }
         return set_add_key((PySetObject *)anyset, key);
     }