gh-141510: Update specializer to support frozendict

Include/internal/pycore_interp_structs.h

@@ -496,7 +496,7 @@ struct _py_func_state {
 
 /* For now we hard-code this to a value for which we are confident
    all the static builtin types will fit (for all builds). */
-#define _Py_MAX_MANAGED_STATIC_BUILTIN_TYPES 200
+#define _Py_MAX_MANAGED_STATIC_BUILTIN_TYPES 201
 #define _Py_MAX_MANAGED_STATIC_EXT_TYPES 10
 #define _Py_MAX_MANAGED_STATIC_TYPES \
     (_Py_MAX_MANAGED_STATIC_BUILTIN_TYPES + _Py_MAX_MANAGED_STATIC_EXT_TYPES)

Lib/test/test_opcache.py

@@ -1548,6 +1548,27 @@ def contains_op_dict():
         self.assert_specialized(contains_op_dict, "CONTAINS_OP_DICT")
         self.assert_no_opcode(contains_op_dict, "CONTAINS_OP")
 
+        def contains_op_frozen_dict():
+            for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
+                a, b = 1, frozendict({1: 2, 2: 5})
+                self.assertTrue(a in b)
+                self.assertFalse(3 in b)
+
+        contains_op_frozen_dict()
+        self.assert_specialized(contains_op_frozen_dict, "CONTAINS_OP_DICT")
+        self.assert_no_opcode(contains_op_frozen_dict, "CONTAINS_OP")
+
+        def contains_op_frozen_dict_subclass():
+            class MyFrozenDict(frozendict):
+                pass
+            for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
+                a, b = 1, MyFrozenDict({1: 2, 2: 5})
+                self.assertTrue(a in b)
+                self.assertFalse(3 in b)
+
+        contains_op_frozen_dict_subclass()
+        self.assert_no_opcode(contains_op_frozen_dict_subclass, "CONTAINS_OP_DICT")
+
         def contains_op_set():
             for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
                 a, b = 1, {1, 2}
@@ -1808,6 +1829,27 @@ def binary_subscr_dict():
         self.assert_specialized(binary_subscr_dict, "BINARY_OP_SUBSCR_DICT")
         self.assert_no_opcode(binary_subscr_dict, "BINARY_OP")
 
+        def binary_subscr_frozen_dict():
+            for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
+                a = frozendict({1: 2, 2: 3})
+                self.assertEqual(a[1], 2)
+                self.assertEqual(a[2], 3)
+
+        binary_subscr_frozen_dict()
+        self.assert_specialized(binary_subscr_frozen_dict, "BINARY_OP_SUBSCR_DICT")
+        self.assert_no_opcode(binary_subscr_frozen_dict, "BINARY_OP")
+
+        def binary_subscr_frozen_dict_subclass():
+            class MyFrozenDict(frozendict):
+                pass
+            for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
+                a = MyFrozenDict({1: 2, 2: 3})
+                self.assertEqual(a[1], 2)
+                self.assertEqual(a[2], 3)
+
+        binary_subscr_frozen_dict_subclass()
+        self.assert_no_opcode(binary_subscr_frozen_dict_subclass, "BINARY_OP_SUBSCR_DICT")
+
         def binary_subscr_str_int():
             for _ in range(_testinternalcapi.SPECIALIZATION_THRESHOLD):
                 a = "foobar"

Misc/NEWS.d/next/Core_and_Builtins/2026-02-18-21-44-39.gh-issue-141510.7LST2O.rst

@@ -0,0 +1 @@
+Update specializer to support frozendict. Patch by Donghee Na.

Python/bytecodes.c

@@ -1058,12 +1058,12 @@ dummy_func(
 
         op(_GUARD_NOS_DICT, (nos, unused -- nos, unused)) {
             PyObject *o = PyStackRef_AsPyObjectBorrow(nos);
-            EXIT_IF(!PyDict_CheckExact(o));
+            EXIT_IF(!PyAnyDict_CheckExact(o));
         }
 
         op(_GUARD_TOS_DICT, (tos -- tos)) {
             PyObject *o = PyStackRef_AsPyObjectBorrow(tos);
-            EXIT_IF(!PyDict_CheckExact(o));
+            EXIT_IF(!PyAnyDict_CheckExact(o));
         }
 
         macro(BINARY_OP_SUBSCR_DICT) =
@@ -1073,7 +1073,7 @@ dummy_func(
             PyObject *sub = PyStackRef_AsPyObjectBorrow(sub_st);
             PyObject *dict = PyStackRef_AsPyObjectBorrow(dict_st);
 
-            assert(PyDict_CheckExact(dict));
+            assert(PyAnyDict_CheckExact(dict));
             STAT_INC(BINARY_OP, hit);
             PyObject *res_o;
             int rc = PyDict_GetItemRef(dict, sub, &res_o);
@@ -2940,7 +2940,7 @@ dummy_func(
             PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
             PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
 
-            assert(PyDict_CheckExact(right_o));
+            assert(PyAnyDict_CheckExact(right_o));
             STAT_INC(CONTAINS_OP, hit);
             int res = PyDict_Contains(right_o, left_o);
             if (res < 0) {

Python/specialize.c

@@ -2287,7 +2287,7 @@ _Py_Specialize_BinaryOp(_PyStackRef lhs_st, _PyStackRef rhs_st, _Py_CODEUNIT *in
                     }
                 }
             }
-            if (PyDict_CheckExact(lhs)) {
+            if (PyAnyDict_CheckExact(lhs)) {
                 specialize(instr, BINARY_OP_SUBSCR_DICT);
                 return;
             }
@@ -2767,7 +2767,7 @@ _Py_Specialize_ContainsOp(_PyStackRef value_st, _Py_CODEUNIT *instr)
 
     assert(ENABLE_SPECIALIZATION);
     assert(_PyOpcode_Caches[CONTAINS_OP] == INLINE_CACHE_ENTRIES_COMPARE_OP);
-    if (PyDict_CheckExact(value)) {
+    if (PyAnyDict_CheckExact(value)) {
         specialize(instr, CONTAINS_OP_DICT);
         return;
     }