Replace PyDict_Check() with _PyAnyDict_Check()

vstinner · vstinner · commit 439c98c307e0 · 2025-11-13T21:38:14.000+01:00
diff --git a/Modules/_collectionsmodule.c b/Modules/_collectionsmodule.c
@@ -2403,7 +2403,7 @@ defdict_or(PyObject* left, PyObject* right)
         self = right;
         other = left;
     }
-    if (!PyDict_Check(other)) {
+    if (!_PyAnyDict_Check(other)) {
         Py_RETURN_NOTIMPLEMENTED;
     }
     // Like copy(), this calls the object's class.
diff --git a/Objects/abstract.c b/Objects/abstract.c
@@ -208,7 +208,7 @@ PyObject_GetItem(PyObject *o, PyObject *key)
 int
 PyMapping_GetOptionalItem(PyObject *obj, PyObject *key, PyObject **result)
 {
-    if (PyDict_CheckExact(obj)) {
+    if (_PyAnyDict_CheckExact(obj)) {
         return PyDict_GetItemRef(obj, key, result);
     }
 
@@ -1672,7 +1672,7 @@ PyNumber_ToBase(PyObject *n, int base)
 int
 PySequence_Check(PyObject *s)
 {
-    if (PyDict_Check(s))
+    if (_PyAnyDict_Check(s))
         return 0;
     return Py_TYPE(s)->tp_as_sequence &&
         Py_TYPE(s)->tp_as_sequence->sq_item != NULL;
@@ -2454,7 +2454,7 @@ PyMapping_Keys(PyObject *o)
     if (o == NULL) {
         return null_error();
     }
-    if (PyDict_CheckExact(o)) {
+    if (_PyAnyDict_CheckExact(o)) {
         return PyDict_Keys(o);
     }
     return method_output_as_list(o, &_Py_ID(keys));
@@ -2466,7 +2466,7 @@ PyMapping_Items(PyObject *o)
     if (o == NULL) {
         return null_error();
     }
-    if (PyDict_CheckExact(o)) {
+    if (_PyAnyDict_CheckExact(o)) {
         return PyDict_Items(o);
     }
     return method_output_as_list(o, &_Py_ID(items));
@@ -2478,7 +2478,7 @@ PyMapping_Values(PyObject *o)
     if (o == NULL) {
         return null_error();
     }
-    if (PyDict_CheckExact(o)) {
+    if (_PyAnyDict_CheckExact(o)) {
         return PyDict_Values(o);
     }
     return method_output_as_list(o, &_Py_ID(values));
diff --git a/Objects/descrobject.c b/Objects/descrobject.c
@@ -1089,7 +1089,7 @@ static int
 mappingproxy_contains(PyObject *self, PyObject *key)
 {
     mappingproxyobject *pp = (mappingproxyobject *)self;
-    if (PyDict_CheckExact(pp->mapping))
+    if (_PyAnyDict_CheckExact(pp->mapping))
         return PyDict_Contains(pp->mapping, key);
     else
         return PySequence_Contains(pp->mapping, key);
diff --git a/Objects/dictobject.c b/Objects/dictobject.c
@@ -914,7 +914,7 @@ new_dict_with_shared_keys(PyDictKeysObject *keys)
 static PyDictKeysObject *
 clone_combined_dict_keys(PyDictObject *orig)
 {
-    assert(PyDict_Check(orig));
+    assert(_PyAnyDict_Check(orig));
     assert(Py_TYPE(orig)->tp_iter == dict_iter);
     assert(orig->ma_values == NULL);
     assert(orig->ma_keys != Py_EMPTY_KEYS);
@@ -2374,7 +2374,7 @@ _PyDict_GetItem_KnownHash(PyObject *op, PyObject *key, Py_hash_t hash)
     PyDictObject *mp = (PyDictObject *)op;
     PyObject *value;
 
-    if (!PyDict_Check(op)) {
+    if (!_PyAnyDict_Check(op)) {
         PyErr_BadInternalCall();
         return NULL;
     }
@@ -3280,8 +3280,8 @@ _PyDict_FromKeys(PyObject *cls, PyObject *iterable, PyObject *value)
         return NULL;
 
 
-    if (PyDict_CheckExact(d)) {
-        if (PyDict_CheckExact(iterable)) {
+    if (_PyAnyDict_CheckExact(d)) {
+        if (_PyAnyDict_CheckExact(iterable)) {
             PyDictObject *mp = (PyDictObject *)d;
 
             Py_BEGIN_CRITICAL_SECTION2(d, iterable);
@@ -3496,7 +3496,7 @@ dict_subscript(PyObject *self, PyObject *key)
     if (ix == DKIX_ERROR)
         return NULL;
     if (ix == DKIX_EMPTY || value == NULL) {
-        if (!PyDict_CheckExact(mp)) {
+        if (!_PyAnyDict_CheckExact(mp)) {
             /* Look up __missing__ method if we're a subclass. */
             PyObject *missing, *res;
             missing = _PyObject_LookupSpecial(
@@ -3535,7 +3535,7 @@ keys_lock_held(PyObject *dict)
 {
     ASSERT_DICT_LOCKED(dict);
 
-    if (dict == NULL || !PyDict_Check(dict)) {
+    if (dict == NULL || !_PyAnyDict_Check(dict)) {
         PyErr_BadInternalCall();
         return NULL;
     }
@@ -3584,7 +3584,7 @@ values_lock_held(PyObject *dict)
 {
     ASSERT_DICT_LOCKED(dict);
 
-    if (dict == NULL || !PyDict_Check(dict)) {
+    if (dict == NULL || !_PyAnyDict_Check(dict)) {
         PyErr_BadInternalCall();
         return NULL;
     }
@@ -3632,7 +3632,7 @@ items_lock_held(PyObject *dict)
 {
     ASSERT_DICT_LOCKED(dict);
 
-    if (dict == NULL || !PyDict_Check(dict)) {
+    if (dict == NULL || !_PyAnyDict_Check(dict)) {
         PyErr_BadInternalCall();
         return NULL;
     }
@@ -3712,7 +3712,7 @@ dict_fromkeys_impl(PyTypeObject *type, PyObject *iterable, PyObject *value)
 static int
 dict_update_arg(PyObject *self, PyObject *arg)
 {
-    if (PyDict_CheckExact(arg)) {
+    if (_PyAnyDict_CheckExact(arg)) {
         return PyDict_Merge(self, arg, 1);
     }
     int has_keys = PyObject_HasAttrWithError(arg, &_Py_ID(keys));
@@ -3982,7 +3982,7 @@ dict_merge(PyInterpreterState *interp, PyObject *a, PyObject *b, int override)
     }
     mp = (PyDictObject*)a;
     int res = 0;
-    if (PyDict_Check(b) && (Py_TYPE(b)->tp_iter == dict_iter)) {
+    if (_PyAnyDict_Check(b) && (Py_TYPE(b)->tp_iter == dict_iter)) {
         other = (PyDictObject*)b;
         int res;
         Py_BEGIN_CRITICAL_SECTION2(a, b);
@@ -4243,7 +4243,7 @@ PyDict_Copy(PyObject *o)
 Py_ssize_t
 PyDict_Size(PyObject *mp)
 {
-    if (mp == NULL || !PyDict_Check(mp)) {
+    if (mp == NULL || !_PyAnyDict_Check(mp)) {
         PyErr_BadInternalCall();
         return -1;
     }
@@ -5789,7 +5789,7 @@ dictreviter_iter_lock_held(PyDictObject *d, PyObject *self)
 {
     dictiterobject *di = (dictiterobject *)self;
 
-    assert (PyDict_Check(d));
+    assert (_PyAnyDict_Check(d));
     ASSERT_DICT_LOCKED(d);
 
     if (di->di_used != d->ma_used) {
@@ -5919,7 +5919,7 @@ static PyObject *
 dict___reversed___impl(PyDictObject *self)
 /*[clinic end generated code: output=e674483336d1ed51 input=23210ef3477d8c4d]*/
 {
-    assert (PyDict_Check(self));
+    assert (_PyAnyDict_Check(self));
     return dictiter_new(self, &PyDictRevIterKey_Type);
 }
 
@@ -6194,7 +6194,7 @@ dictviews_to_set(PyObject *self)
     if (PyDictKeys_Check(self)) {
         // PySet_New() has fast path for the dict object.
         PyObject *dict = (PyObject *)((_PyDictViewObject *)self)->dv_dict;
-        if (PyDict_CheckExact(dict)) {
+        if (_PyAnyDict_CheckExact(dict)) {
             left = dict;
         }
     }
@@ -7714,7 +7714,7 @@ validate_watcher_id(PyInterpreterState *interp, int watcher_id)
 int
 PyDict_Watch(int watcher_id, PyObject* dict)
 {
-    if (!PyDict_Check(dict)) {
+    if (!_PyAnyDict_Check(dict)) {
         PyErr_SetString(PyExc_ValueError, "Cannot watch non-dictionary");
         return -1;
     }
@@ -7729,7 +7729,7 @@ PyDict_Watch(int watcher_id, PyObject* dict)
 int
 PyDict_Unwatch(int watcher_id, PyObject* dict)
 {
-    if (!PyDict_Check(dict)) {
+    if (!_PyAnyDict_Check(dict)) {
         PyErr_SetString(PyExc_ValueError, "Cannot watch non-dictionary");
         return -1;
     }
diff --git a/Objects/listobject.c b/Objects/listobject.c
@@ -1424,7 +1424,7 @@ _list_extend(PyListObject *self, PyObject *iterable)
         res = list_extend_set(self, (PySetObject *)iterable);
         Py_END_CRITICAL_SECTION2();
     }
-    else if (PyDict_CheckExact(iterable)) {
+    else if (_PyAnyDict_CheckExact(iterable)) {
         Py_BEGIN_CRITICAL_SECTION2(self, iterable);
         res = list_extend_dict(self, (PyDictObject *)iterable, 0 /*keys*/);
         Py_END_CRITICAL_SECTION2();
diff --git a/Objects/object.c b/Objects/object.c
@@ -57,7 +57,7 @@ _PyObject_CheckConsistency(PyObject *op, int check_content)
     if (PyUnicode_Check(op)) {
         _PyUnicode_CheckConsistency(op, check_content);
     }
-    else if (PyDict_Check(op)) {
+    else if (_PyAnyDict_Check(op)) {
         _PyDict_CheckConsistency(op, check_content);
     }
     return 1;
diff --git a/Objects/odictobject.c b/Objects/odictobject.c
@@ -2272,7 +2272,7 @@ static int
 mutablemapping_update_arg(PyObject *self, PyObject *arg)
 {
     int res = 0;
-    if (PyDict_CheckExact(arg)) {
+    if (_PyAnyDict_CheckExact(arg)) {
         PyObject *items = PyDict_Items(arg);
         if (items == NULL) {
             return -1;
diff --git a/Objects/setobject.c b/Objects/setobject.c
@@ -989,7 +989,7 @@ set_iter(PyObject *so)
 static int
 set_update_dict_lock_held(PySetObject *so, PyObject *other)
 {
-    assert(PyDict_CheckExact(other));
+    assert(_PyAnyDict_CheckExact(other));
 
     _Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(so);
     _Py_CRITICAL_SECTION_ASSERT_OBJECT_LOCKED(other);
@@ -1048,7 +1048,7 @@ set_update_lock_held(PySetObject *so, PyObject *other)
     if (PyAnySet_Check(other)) {
         return set_merge_lock_held(so, other);
     }
-    else if (PyDict_CheckExact(other)) {
+    else if (_PyAnyDict_CheckExact(other)) {
         return set_update_dict_lock_held(so, other);
     }
     return set_update_iterable_lock_held(so, other);
@@ -1066,7 +1066,7 @@ set_update_local(PySetObject *so, PyObject *other)
         Py_END_CRITICAL_SECTION();
         return rv;
     }
-    else if (PyDict_CheckExact(other)) {
+    else if (_PyAnyDict_CheckExact(other)) {
         int rv;
         Py_BEGIN_CRITICAL_SECTION(other);
         rv = set_update_dict_lock_held(so, other);
@@ -1089,7 +1089,7 @@ set_update_internal(PySetObject *so, PyObject *other)
         Py_END_CRITICAL_SECTION2();
         return rv;
     }
-    else if (PyDict_CheckExact(other)) {
+    else if (_PyAnyDict_CheckExact(other)) {
         int rv;
         Py_BEGIN_CRITICAL_SECTION2(so, other);
         rv = set_update_dict_lock_held(so, other);
@@ -1781,7 +1781,7 @@ set_difference(PySetObject *so, PyObject *other)
     if (PyAnySet_Check(other)) {
         other_size = PySet_GET_SIZE(other);
     }
-    else if (PyDict_CheckExact(other)) {
+    else if (_PyAnyDict_CheckExact(other)) {
         other_size = PyDict_GET_SIZE(other);
     }
     else {
@@ -1798,7 +1798,7 @@ set_difference(PySetObject *so, PyObject *other)
     if (result == NULL)
         return NULL;
 
-    if (PyDict_CheckExact(other)) {
+    if (_PyAnyDict_CheckExact(other)) {
         while (set_next(so, &pos, &entry)) {
             key = entry->key;
             hash = entry->hash;
@@ -1989,7 +1989,7 @@ set_symmetric_difference_update_impl(PySetObject *so, PyObject *other)
     }
 
     int rv;
-    if (PyDict_CheckExact(other)) {
+    if (_PyAnyDict_CheckExact(other)) {
         Py_BEGIN_CRITICAL_SECTION2(so, other);
         rv = set_symmetric_difference_update_dict(so, other);
         Py_END_CRITICAL_SECTION2();
diff --git a/Objects/unicodeobject.c b/Objects/unicodeobject.c
@@ -13189,7 +13189,7 @@ unicode_maketrans_impl(PyObject *x, PyObject *y, PyObject *z)
         const void *data;
 
         /* x must be a dict */
-        if (!PyDict_CheckExact(x)) {
+        if (!_PyAnyDict_CheckExact(x)) {
             PyErr_SetString(PyExc_TypeError, "if you give only one argument "
                             "to maketrans it must be a dict");
             goto err;

Original file line number	Diff line number	Diff line change
`@@ -2403,7 +2403,7 @@ defdict_or(PyObject* left, PyObject* right)`
`2403`	`2403`	`self = right;`
`2404`	`2404`	`other = left;`
`2405`	`2405`	`}`
`2406`		`- if (!PyDict_Check(other)) {`
	`2406`	`+ if (!_PyAnyDict_Check(other)) {`
`2407`	`2407`	`Py_RETURN_NOTIMPLEMENTED;`
`2408`	`2408`	`}`
`2409`	`2409`	`// Like copy(), this calls the object's class.`
Original file line number	Diff line number	Diff line change
`@@ -208,7 +208,7 @@ PyObject_GetItem(PyObject o, PyObject key)`
`208`	`208`	`int`
`209`	`209`	`PyMapping_GetOptionalItem(PyObject obj, PyObject key, PyObject **result)`
`210`	`210`	`{`
`211`		`- if (PyDict_CheckExact(obj)) {`
	`211`	`+ if (_PyAnyDict_CheckExact(obj)) {`
`212`	`212`	`return PyDict_GetItemRef(obj, key, result);`
`213`	`213`	`}`
`214`	`214`
`@@ -1672,7 +1672,7 @@ PyNumber_ToBase(PyObject *n, int base)`
`1672`	`1672`	`int`
`1673`	`1673`	`PySequence_Check(PyObject *s)`
`1674`	`1674`	`{`
`1675`		`- if (PyDict_Check(s))`
	`1675`	`+ if (_PyAnyDict_Check(s))`
`1676`	`1676`	`return 0;`
`1677`	`1677`	`return Py_TYPE(s)->tp_as_sequence &&`
`1678`	`1678`	`Py_TYPE(s)->tp_as_sequence->sq_item != NULL;`
`@@ -2454,7 +2454,7 @@ PyMapping_Keys(PyObject *o)`
`2454`	`2454`	`if (o == NULL) {`
`2455`	`2455`	`return null_error();`
`2456`	`2456`	`}`
`2457`		`- if (PyDict_CheckExact(o)) {`
	`2457`	`+ if (_PyAnyDict_CheckExact(o)) {`
`2458`	`2458`	`return PyDict_Keys(o);`
`2459`	`2459`	`}`
`2460`	`2460`	`return method_output_as_list(o, &_Py_ID(keys));`
`@@ -2466,7 +2466,7 @@ PyMapping_Items(PyObject *o)`
`2466`	`2466`	`if (o == NULL) {`
`2467`	`2467`	`return null_error();`
`2468`	`2468`	`}`
`2469`		`- if (PyDict_CheckExact(o)) {`
	`2469`	`+ if (_PyAnyDict_CheckExact(o)) {`
`2470`	`2470`	`return PyDict_Items(o);`
`2471`	`2471`	`}`
`2472`	`2472`	`return method_output_as_list(o, &_Py_ID(items));`
`@@ -2478,7 +2478,7 @@ PyMapping_Values(PyObject *o)`
`2478`	`2478`	`if (o == NULL) {`
`2479`	`2479`	`return null_error();`
`2480`	`2480`	`}`
`2481`		`- if (PyDict_CheckExact(o)) {`
	`2481`	`+ if (_PyAnyDict_CheckExact(o)) {`
`2482`	`2482`	`return PyDict_Values(o);`
`2483`	`2483`	`}`
`2484`	`2484`	`return method_output_as_list(o, &_Py_ID(values));`
Original file line number	Diff line number	Diff line change
`@@ -1089,7 +1089,7 @@ static int`
`1089`	`1089`	`mappingproxy_contains(PyObject self, PyObject key)`
`1090`	`1090`	`{`
`1091`	`1091`	`mappingproxyobject pp = (mappingproxyobject )self;`
`1092`		`- if (PyDict_CheckExact(pp->mapping))`
	`1092`	`+ if (_PyAnyDict_CheckExact(pp->mapping))`
`1093`	`1093`	`return PyDict_Contains(pp->mapping, key);`
`1094`	`1094`	`else`
`1095`	`1095`	`return PySequence_Contains(pp->mapping, key);`
Original file line number	Diff line number	Diff line change
`@@ -914,7 +914,7 @@ new_dict_with_shared_keys(PyDictKeysObject *keys)`
`914`	`914`	`static PyDictKeysObject *`
`915`	`915`	`clone_combined_dict_keys(PyDictObject *orig)`
`916`	`916`	`{`
`917`		`- assert(PyDict_Check(orig));`
	`917`	`+ assert(_PyAnyDict_Check(orig));`
`918`	`918`	`assert(Py_TYPE(orig)->tp_iter == dict_iter);`
`919`	`919`	`assert(orig->ma_values == NULL);`
`920`	`920`	`assert(orig->ma_keys != Py_EMPTY_KEYS);`
`@@ -2374,7 +2374,7 @@ _PyDict_GetItem_KnownHash(PyObject op, PyObject key, Py_hash_t hash)`
`2374`	`2374`	`PyDictObject mp = (PyDictObject )op;`
`2375`	`2375`	`PyObject *value;`
`2376`	`2376`
`2377`		`- if (!PyDict_Check(op)) {`
	`2377`	`+ if (!_PyAnyDict_Check(op)) {`
`2378`	`2378`	`PyErr_BadInternalCall();`
`2379`	`2379`	`return NULL;`
`2380`	`2380`	`}`
`@@ -3280,8 +3280,8 @@ _PyDict_FromKeys(PyObject cls, PyObject iterable, PyObject *value)`
`3280`	`3280`	`return NULL;`
`3281`	`3281`
`3282`	`3282`
`3283`		`- if (PyDict_CheckExact(d)) {`
`3284`		`- if (PyDict_CheckExact(iterable)) {`
	`3283`	`+ if (_PyAnyDict_CheckExact(d)) {`
	`3284`	`+ if (_PyAnyDict_CheckExact(iterable)) {`
`3285`	`3285`	`PyDictObject mp = (PyDictObject )d;`
`3286`	`3286`
`3287`	`3287`	`Py_BEGIN_CRITICAL_SECTION2(d, iterable);`
`@@ -3496,7 +3496,7 @@ dict_subscript(PyObject self, PyObject key)`
`3496`	`3496`	`if (ix == DKIX_ERROR)`
`3497`	`3497`	`return NULL;`
`3498`	`3498`	`if (ix == DKIX_EMPTY \|\| value == NULL) {`
`3499`		`- if (!PyDict_CheckExact(mp)) {`
	`3499`	`+ if (!_PyAnyDict_CheckExact(mp)) {`
`3500`	`3500`	`/* Look up __missing__ method if we're a subclass. */`
`3501`	`3501`	`PyObject missing, res;`
`3502`	`3502`	`missing = _PyObject_LookupSpecial(`
`@@ -3535,7 +3535,7 @@ keys_lock_held(PyObject *dict)`
`3535`	`3535`	`{`
`3536`	`3536`	`ASSERT_DICT_LOCKED(dict);`
`3537`	`3537`
`3538`		`- if (dict == NULL \|\| !PyDict_Check(dict)) {`
	`3538`	`+ if (dict == NULL \|\| !_PyAnyDict_Check(dict)) {`
`3539`	`3539`	`PyErr_BadInternalCall();`
`3540`	`3540`	`return NULL;`
`3541`	`3541`	`}`
`@@ -3584,7 +3584,7 @@ values_lock_held(PyObject *dict)`
`3584`	`3584`	`{`
`3585`	`3585`	`ASSERT_DICT_LOCKED(dict);`
`3586`	`3586`
`3587`		`- if (dict == NULL \|\| !PyDict_Check(dict)) {`
	`3587`	`+ if (dict == NULL \|\| !_PyAnyDict_Check(dict)) {`
`3588`	`3588`	`PyErr_BadInternalCall();`
`3589`	`3589`	`return NULL;`
`3590`	`3590`	`}`
`@@ -3632,7 +3632,7 @@ items_lock_held(PyObject *dict)`
`3632`	`3632`	`{`
`3633`	`3633`	`ASSERT_DICT_LOCKED(dict);`
`3634`	`3634`
`3635`		`- if (dict == NULL \|\| !PyDict_Check(dict)) {`
	`3635`	`+ if (dict == NULL \|\| !_PyAnyDict_Check(dict)) {`
`3636`	`3636`	`PyErr_BadInternalCall();`
`3637`	`3637`	`return NULL;`
`3638`	`3638`	`}`
`@@ -3712,7 +3712,7 @@ dict_fromkeys_impl(PyTypeObject type, PyObject iterable, PyObject *value)`
`3712`	`3712`	`static int`
`3713`	`3713`	`dict_update_arg(PyObject self, PyObject arg)`
`3714`	`3714`	`{`
`3715`		`- if (PyDict_CheckExact(arg)) {`
	`3715`	`+ if (_PyAnyDict_CheckExact(arg)) {`
`3716`	`3716`	`return PyDict_Merge(self, arg, 1);`
`3717`	`3717`	`}`
`3718`	`3718`	`int has_keys = PyObject_HasAttrWithError(arg, &_Py_ID(keys));`
`@@ -3982,7 +3982,7 @@ dict_merge(PyInterpreterState interp, PyObject a, PyObject *b, int override)`
`3982`	`3982`	`}`
`3983`	`3983`	`mp = (PyDictObject*)a;`
`3984`	`3984`	`int res = 0;`
`3985`		`- if (PyDict_Check(b) && (Py_TYPE(b)->tp_iter == dict_iter)) {`
	`3985`	`+ if (_PyAnyDict_Check(b) && (Py_TYPE(b)->tp_iter == dict_iter)) {`
`3986`	`3986`	`other = (PyDictObject*)b;`
`3987`	`3987`	`int res;`
`3988`	`3988`	`Py_BEGIN_CRITICAL_SECTION2(a, b);`
`@@ -4243,7 +4243,7 @@ PyDict_Copy(PyObject *o)`
`4243`	`4243`	`Py_ssize_t`
`4244`	`4244`	`PyDict_Size(PyObject *mp)`
`4245`	`4245`	`{`
`4246`		`- if (mp == NULL \|\| !PyDict_Check(mp)) {`
	`4246`	`+ if (mp == NULL \|\| !_PyAnyDict_Check(mp)) {`
`4247`	`4247`	`PyErr_BadInternalCall();`
`4248`	`4248`	`return -1;`
`4249`	`4249`	`}`
`@@ -5789,7 +5789,7 @@ dictreviter_iter_lock_held(PyDictObject d, PyObject self)`
`5789`	`5789`	`{`
`5790`	`5790`	`dictiterobject di = (dictiterobject )self;`
`5791`	`5791`
`5792`		`- assert (PyDict_Check(d));`
	`5792`	`+ assert (_PyAnyDict_Check(d));`
`5793`	`5793`	`ASSERT_DICT_LOCKED(d);`
`5794`	`5794`
`5795`	`5795`	`if (di->di_used != d->ma_used) {`
`@@ -5919,7 +5919,7 @@ static PyObject *`
`5919`	`5919`	`dict___reversed___impl(PyDictObject *self)`
`5920`	`5920`	`/[clinic end generated code: output=e674483336d1ed51 input=23210ef3477d8c4d]/`
`5921`	`5921`	`{`
`5922`		`- assert (PyDict_Check(self));`
	`5922`	`+ assert (_PyAnyDict_Check(self));`
`5923`	`5923`	`return dictiter_new(self, &PyDictRevIterKey_Type);`
`5924`	`5924`	`}`
`5925`	`5925`
`@@ -6194,7 +6194,7 @@ dictviews_to_set(PyObject *self)`
`6194`	`6194`	`if (PyDictKeys_Check(self)) {`
`6195`	`6195`	`// PySet_New() has fast path for the dict object.`
`6196`	`6196`	`PyObject dict = (PyObject )((_PyDictViewObject *)self)->dv_dict;`
`6197`		`- if (PyDict_CheckExact(dict)) {`
	`6197`	`+ if (_PyAnyDict_CheckExact(dict)) {`
`6198`	`6198`	`left = dict;`
`6199`	`6199`	`}`
`6200`	`6200`	`}`
`@@ -7714,7 +7714,7 @@ validate_watcher_id(PyInterpreterState *interp, int watcher_id)`
`7714`	`7714`	`int`
`7715`	`7715`	`PyDict_Watch(int watcher_id, PyObject* dict)`
`7716`	`7716`	`{`
`7717`		`- if (!PyDict_Check(dict)) {`
	`7717`	`+ if (!_PyAnyDict_Check(dict)) {`
`7718`	`7718`	`PyErr_SetString(PyExc_ValueError, "Cannot watch non-dictionary");`
`7719`	`7719`	`return -1;`
`7720`	`7720`	`}`
`@@ -7729,7 +7729,7 @@ PyDict_Watch(int watcher_id, PyObject* dict)`
`7729`	`7729`	`int`
`7730`	`7730`	`PyDict_Unwatch(int watcher_id, PyObject* dict)`
`7731`	`7731`	`{`
`7732`		`- if (!PyDict_Check(dict)) {`
	`7732`	`+ if (!_PyAnyDict_Check(dict)) {`
`7733`	`7733`	`PyErr_SetString(PyExc_ValueError, "Cannot watch non-dictionary");`
`7734`	`7734`	`return -1;`
`7735`	`7735`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1424,7 +1424,7 @@ _list_extend(PyListObject self, PyObject iterable)`
`1424`	`1424`	`res = list_extend_set(self, (PySetObject *)iterable);`
`1425`	`1425`	`Py_END_CRITICAL_SECTION2();`
`1426`	`1426`	`}`
`1427`		`- else if (PyDict_CheckExact(iterable)) {`
	`1427`	`+ else if (_PyAnyDict_CheckExact(iterable)) {`
`1428`	`1428`	`Py_BEGIN_CRITICAL_SECTION2(self, iterable);`
`1429`	`1429`	`res = list_extend_dict(self, (PyDictObject )iterable, 0 /keys*/);`
`1430`	`1430`	`Py_END_CRITICAL_SECTION2();`
Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ _PyObject_CheckConsistency(PyObject *op, int check_content)`
`57`	`57`	`if (PyUnicode_Check(op)) {`
`58`	`58`	`_PyUnicode_CheckConsistency(op, check_content);`
`59`	`59`	`}`
`60`		`- else if (PyDict_Check(op)) {`
	`60`	`+ else if (_PyAnyDict_Check(op)) {`
`61`	`61`	`_PyDict_CheckConsistency(op, check_content);`
`62`	`62`	`}`
`63`	`63`	`return 1;`
Original file line number	Diff line number	Diff line change
`@@ -2272,7 +2272,7 @@ static int`
`2272`	`2272`	`mutablemapping_update_arg(PyObject self, PyObject arg)`
`2273`	`2273`	`{`
`2274`	`2274`	`int res = 0;`
`2275`		`- if (PyDict_CheckExact(arg)) {`
	`2275`	`+ if (_PyAnyDict_CheckExact(arg)) {`
`2276`	`2276`	`PyObject *items = PyDict_Items(arg);`
`2277`	`2277`	`if (items == NULL) {`
`2278`	`2278`	`return -1;`