python
diff --git a/Include/internal/pycore_dict.h b/Include/internal/pycore_dict.h
@@ -42,6 +42,8 @@ extern uint32_t _PyDictKeys_GetVersionForCurrentState(
 
 extern size_t _PyDict_KeysSize(PyDictKeysObject *keys);
 
+extern void _PyDictKeys_DecRef(PyDictKeysObject *keys);
+
 /* _Py_dict_lookup() returns index of entry which can be used like DK_ENTRIES(dk)[index].
  * -1 when no entry found, -3 when compare raises error.
  */

diff --git a/Include/pystats.h b/Include/pystats.h
@@ -65,6 +65,7 @@ typedef struct _object_stats {
     uint64_t dict_materialized_new_key;
     uint64_t dict_materialized_too_big;
     uint64_t dict_materialized_str_subclass;
+    uint64_t dict_unmaterialized;
     uint64_t type_cache_hits;
     uint64_t type_cache_misses;
     uint64_t type_cache_dunder_hits;

diff --git a/Lib/test/test_opcache.py b/Lib/test/test_opcache.py
@@ -864,19 +864,20 @@ class C:
 
             items = []
             for _ in range(self.ITEMS):
-                item = C()
-                item.__dict__
-                item.a = None
+                o = C()
+                o.a = None
+                # Need to keep a __dict__ reference so it isn't un-materialized:
+                item = o, o.__dict__
                 items.append(item)
             return items
 
         def read(items):
             for item in items:
-                item.a
+                item[0].a
 
         def write(items):
             for item in items:
-                item.__dict__[None] = None
+                item[1][None] = None
 
         opname = "LOAD_ATTR_WITH_HINT"
         self.assert_races_do_not_crash(opname, get_items, read, write)

@@ -4973,9 +4973,6 @@ type_setattro(PyTypeObject *type, PyObject *name, PyObject *value)
     return res;
 }
 
-extern void
-_PyDictKeys_DecRef(PyDictKeysObject *keys);
-
 
 static void
 type_dealloc_common(PyTypeObject *type)

@@ -1902,9 +1902,9 @@ dummy_func(
             assert(type_version != 0);
             DEOPT_IF(tp->tp_version_tag != type_version, LOAD_ATTR);
             assert(tp->tp_flags & Py_TPFLAGS_MANAGED_DICT);
-            PyDictOrValues dorv = *_PyObject_DictOrValuesPointer(owner);
-            DEOPT_IF(_PyDictOrValues_IsValues(dorv), LOAD_ATTR);
-            PyDictObject *dict = (PyDictObject *)_PyDictOrValues_GetDict(dorv);
+            PyDictOrValues *dorv = _PyObject_DictOrValuesPointer(owner);
+            DEOPT_IF(_PyDictOrValues_IsValues(*dorv), LOAD_ATTR);
+            PyDictObject *dict = (PyDictObject *)_PyDictOrValues_GetDict(*dorv);
             DEOPT_IF(dict == NULL, LOAD_ATTR);
             assert(PyDict_CheckExact((PyObject *)dict));
             PyObject *name = GETITEM(FRAME_CO_NAMES, oparg>>1);
@@ -1920,7 +1920,27 @@ dummy_func(
                 DEOPT_IF(ep->me_key != name, LOAD_ATTR);
                 res = ep->me_value;
             }
-            DEOPT_IF(res == NULL, LOAD_ATTR);
+            if (res == NULL) {
+                // This is almost never an AttributeError. It's way more likely
+                // that this __dict__ still shares its keys (for example, if it
+                // was materialized on request and not heavily modified):
+                assert(_PyType_HasFeature(tp, Py_TPFLAGS_HEAPTYPE));
+                PyHeapTypeObject *ht = (PyHeapTypeObject *)tp;
+                DEOPT_IF(dict->ma_keys != ht->ht_cached_keys, LOAD_ATTR);
+                assert(dict->ma_values);
+                DEOPT_IF(Py_REFCNT(dict) != 1, LOAD_ATTR);
+                // We have an opportunity to do something *really* cool:
+                // un-materialize it!
+                _PyDictKeys_DecRef(dict->ma_keys);
+                _PyDictOrValues_SetValues(dorv, dict->ma_values);
+                OBJECT_STAT_INC(dict_unmaterialized);
+                // Don't try this at home, kids:
+                dict->ma_keys = NULL;
+                dict->ma_values = NULL;
+                Py_DECREF(dict);
+                // Guess what... our caches are still valid!
+                GO_TO_INSTRUCTION(LOAD_ATTR_INSTANCE_VALUE);
+            }
             STAT_INC(LOAD_ATTR, hit);
             Py_INCREF(res);
             res2 = NULL;