python
diff --git a/‎Objects/typeobject.c‎
Lines changed: 55 additions & 4 deletions b/‎Objects/typeobject.c‎
Lines changed: 55 additions & 4 deletions
@@ -5636,6 +5636,26 @@ find_name_in_mro(PyTypeObject *type, PyObject *name, int *error)
     return res;
 }
 
+static PyObject *
+find_name_in_mro_new(PyObject *mro_dict, PyObject *name, int *error)
+{
+    ASSERT_TYPE_LOCK_HELD();
+
+    Py_hash_t hash = _PyObject_HashFast(name);
+    if (hash == -1) {
+        *error = -1;
+        return NULL;
+    }
+
+    PyObject *res = NULL;
+    if (_PyDict_GetItemRef_KnownHash((PyDictObject *)mro_dict, name, hash, &res) < 0) {
+        *error = -1;
+    } else {
+        *error = 0;
+    }
+    return res;
+}
+
 /* Check if the "readied" PyUnicode name
    is a double-underscore special name. */
 static int
@@ -11086,7 +11106,7 @@ resolve_slotdups(PyTypeObject *type, PyObject *name)
  * because that's convenient for fixup_slot_dispatchers(). This function never
  * sets an exception: if an internal error happens (unlikely), it's ignored. */
 static pytype_slotdef *
-update_one_slot(PyTypeObject *type, pytype_slotdef *p)
+update_one_slot(PyTypeObject *type, pytype_slotdef *p, PyObject *mro_dict)
 {
     ASSERT_TYPE_LOCK_HELD();
 
@@ -11117,7 +11137,11 @@ update_one_slot(PyTypeObject *type, pytype_slotdef *p)
     assert(!PyErr_Occurred());
     do {
         /* Use faster uncached lookup as we won't get any cache hits during type setup. */
-        descr = find_name_in_mro(type, p->name_strobj, &error);
+        if (mro_dict == NULL) {
+            descr = find_name_in_mro(type, p->name_strobj, &error);
+        } else {
+            descr = find_name_in_mro_new(mro_dict, p->name_strobj, &error);
+        }
         if (descr == NULL) {
             if (error == -1) {
                 /* It is unlikely but not impossible that there has been an exception
@@ -11208,7 +11232,7 @@ update_slots_callback(PyTypeObject *type, void *data)
 
     pytype_slotdef **pp = (pytype_slotdef **)data;
     for (; *pp; pp++) {
-        update_one_slot(type, *pp);
+        update_one_slot(type, *pp, NULL);
     }
     return 0;
 }
@@ -11261,11 +11285,38 @@ fixup_slot_dispatchers(PyTypeObject *type)
     // where we'd like to assert that the type is locked.
     BEGIN_TYPE_LOCK();
 
+    PyObject *mro = lookup_tp_mro(type);
+    assert(mro);
+
+    PyObject *mro_dict = NULL;
+    Py_ssize_t n = PyTuple_GET_SIZE(mro);
+    for (Py_ssize_t i = 0; i < n; i++) {
+        PyObject *base = PyTuple_GET_ITEM(mro, n-i-1);
+        PyObject *dict = lookup_tp_dict(_PyType_CAST(base));
+        assert(dict && PyDict_Check(dict));
+
+        if (i == 0) {
+            mro_dict = PyDict_Copy(dict);
+            if (!mro_dict) {
+                PyErr_Clear();
+                break;
+            }
+        } else {
+            if (PyDict_Merge(mro_dict, dict, 1) < 0) {
+                Py_CLEAR(mro_dict);
+                PyErr_Clear();
+                break;
+            }
+        }
+    }
+
     assert(!PyErr_Occurred());
     for (pytype_slotdef *p = slotdefs; p->name; ) {
-        p = update_one_slot(type, p);
+        p = update_one_slot(type, p, mro_dict);
     }
 
+    Py_XDECREF(mro_dict);
+
     END_TYPE_LOCK();
 }