Fix free-threading

Author: lgeiger

Include/internal/pycore_dict.h

@@ -176,6 +176,7 @@ extern void _PyDict_Clear_LockHeld(PyObject *op);
 
 #ifdef Py_GIL_DISABLED
 PyAPI_FUNC(void) _PyDict_EnsureSharedOnRead(PyDictObject *mp);
+extern void _PyFrozenDict_ClearInternal(PyObject *op);
 #endif
 
 // Export for '_elementtree' shared extension

Objects/codeobject.c

@@ -14,6 +14,7 @@
 #include "pycore_pymem.h"         // _PyMem_FreeDelayed()
 #include "pycore_pystate.h"       // _PyInterpreterState_GET()
 #include "pycore_setobject.h"     // _PySet_NextEntry()
+#include "pycore_dict.h"          // _PyFrozenDict_ClearInternal()
 #include "pycore_tuple.h"         // _PyTuple_ITEMS()
 #include "pycore_unicodeobject.h" // _PyUnicode_InternImmortal()
 #include "pycore_uniqueid.h"      // _PyObject_AssignUniqueId()
@@ -167,6 +168,16 @@ should_immortalize_constant(PyObject *v)
         }
         return 1;
     }
+    else if (PyFrozenDict_CheckExact(v)) {
+        Py_ssize_t pos = 0;
+        PyObject *key, *value;
+        while (PyDict_Next(v, &pos, &key, &value)) {
+            if (!_Py_IsImmortal(key) || !_Py_IsImmortal(value)) {
+                return 0;
+            }
+        }
+        return 1;
+    }
     else if (PySlice_Check(v)) {
         PySliceObject *slice = (PySliceObject *)v;
         return (_Py_IsImmortal(slice->start) &&
@@ -248,6 +259,53 @@ intern_constants(PyObject *tuple, int *modified)
             }
             Py_DECREF(tmp);
         }
+        else if (PyFrozenDict_CheckExact(v)) {
+            PyObject *w = v;
+            PyObject *tmp = PyTuple_New(2 * PyDict_GET_SIZE(v));
+            if (tmp == NULL) {
+                return -1;
+            }
+            Py_ssize_t pos = 0;
+            PyObject *k, *val;
+            Py_ssize_t j = 0;
+            while (PyDict_Next(v, &pos, &k, &val)) {
+                PyTuple_SET_ITEM(tmp, j++, Py_NewRef(k));
+                PyTuple_SET_ITEM(tmp, j++, Py_NewRef(val));
+            }
+            int tmp_modified = 0;
+            if (intern_constants(tmp, &tmp_modified) < 0) {
+                Py_DECREF(tmp);
+                return -1;
+            }
+            if (tmp_modified) {
+                PyObject *new_dict = PyDict_New();
+                if (new_dict == NULL) {
+                    Py_DECREF(tmp);
+                    return -1;
+                }
+                for (j = 0; j < PyTuple_GET_SIZE(tmp); j += 2) {
+                    if (PyDict_SetItem(new_dict,
+                                      PyTuple_GET_ITEM(tmp, j),
+                                      PyTuple_GET_ITEM(tmp, j + 1)) < 0) {
+                        Py_DECREF(tmp);
+                        Py_DECREF(new_dict);
+                        return -1;
+                    }
+                }
+                v = PyFrozenDict_New(new_dict);
+                Py_DECREF(new_dict);
+                if (v == NULL) {
+                    Py_DECREF(tmp);
+                    return -1;
+                }
+                PyTuple_SET_ITEM(tuple, i, v);
+                Py_DECREF(w);
+                if (modified) {
+                    *modified = 1;
+                }
+            }
+            Py_DECREF(tmp);
+        }
 #ifdef Py_GIL_DISABLED
         else if (PySlice_Check(v)) {
             PySliceObject *slice = (PySliceObject *)v;
@@ -3199,6 +3257,21 @@ compare_constants(const void *key1, const void *key2)
         }
         return 1;
     }
+    else if (PyFrozenDict_CheckExact(op1)) {
+        if (PyDict_GET_SIZE(op1) != PyDict_GET_SIZE(op2)) {
+            return 0;
+        }
+        Py_ssize_t pos1 = 0, pos2 = 0;
+        PyObject *k1, *k2, *v1, *v2;
+        while (PyDict_Next(op1, &pos1, &k1, &v1) &&
+               PyDict_Next(op2, &pos2, &k2, &v2))
+        {
+            if (k1 != k2 || v1 != v2) {
+                return 0;
+            }
+        }
+        return 1;
+    }
     else if (PySlice_Check(op1)) {
         PySliceObject *s1 = (PySliceObject *)op1;
         PySliceObject *s2 = (PySliceObject *)op2;
@@ -3273,6 +3346,9 @@ clear_containers(_Py_hashtable_t *ht, const void *key, const void *value,
     else if (PyFrozenSet_CheckExact(op)) {
         _PySet_ClearInternal((PySetObject *)op);
     }
+    else if (PyFrozenDict_CheckExact(op)) {
+        _PyFrozenDict_ClearInternal(op);
+    }
     return 0;
 }
 

Objects/dictobject.c

@@ -3098,6 +3098,34 @@ _PyDict_Clear_LockHeld(PyObject *op) {
     clear_lock_held(op);
 }
 
+#ifdef Py_GIL_DISABLED
+void
+_PyFrozenDict_ClearInternal(PyObject *op)
+{
+    assert(PyFrozenDict_CheckExact(op));
+    PyDictObject *mp = (PyDictObject *)op;
+    PyDictKeysObject *keys = mp->ma_keys;
+    if (keys == Py_EMPTY_KEYS) {
+        return;
+    }
+    assert(mp->ma_values == NULL);
+    if (DK_IS_UNICODE(keys)) {
+        PyDictUnicodeEntry *entries = DK_UNICODE_ENTRIES(keys);
+        for (Py_ssize_t i = 0; i < keys->dk_nentries; i++) {
+            Py_CLEAR(entries[i].me_key);
+            Py_CLEAR(entries[i].me_value);
+        }
+    }
+    else {
+        PyDictKeyEntry *entries = DK_ENTRIES(keys);
+        for (Py_ssize_t i = 0; i < keys->dk_nentries; i++) {
+            Py_CLEAR(entries[i].me_key);
+            Py_CLEAR(entries[i].me_value);
+        }
+    }
+}
+#endif
+
 void
 PyDict_Clear(PyObject *op)
 {