@@ -169,10 +169,12 @@ PyAPI_FUNC(int) _PyDict_SetItem_KnownHash_LockHeld(PyDictObject *mp, PyObject *k
 PyAPI_FUNC(int) _PyDict_GetItemRef_KnownHash_LockHeld(PyDictObject *op, PyObject *key, Py_hash_t hash, PyObject **result);
 PyAPI_FUNC(int) _PyDict_GetItemRef_KnownHash(PyDictObject *op, PyObject *key, Py_hash_t hash, PyObject **result);
 extern int _PyDict_GetItemRef_Unicode_LockHeld(PyDictObject *op, PyObject *key, PyObject **result);
+#ifdef Py_GIL_DISABLED
 extern PyObject *_PyDict_GetItem_ExactUnicode(PyDictObject *mp, PyObject *key);
 extern int _PyDict_GetItemStackRef_ExactUnicode(PyDictObject *mp,
                                                 PyObject *key,
                                                 _PyStackRef *value_addr);
+#endif
 PyAPI_FUNC(int) _PyObjectDict_SetItem(PyTypeObject *tp, PyObject *obj, PyObject **dictptr, PyObject *name, PyObject *value);
 
 extern int _PyDict_Pop_KnownHash(
 
@@ -4371,6 +4371,22 @@ class B_tuple(tuple):
         B_tuple.__bases__ = (tuple,)
         self.assertEqual(repr(b), '(1, 2)')
 
+    @support.cpython_only
+    def test_assign_bases_tuple_identity(self):
+        class A:
+            pass
+
+        class B(A):
+            pass
+
+        bases = (A,)
+        B.__bases__ = bases
+        self.assertEqual(B.__bases__, bases)
+        if support.Py_GIL_DISABLED:
+            self.assertIsNot(B.__bases__, bases)
+        else:
+            self.assertIs(B.__bases__, bases)
+
     def test_assign_bases_many_subclasses(self):
         # This is intended to check that typeobject.c:queue_slot_update() can
         # handle updating many subclasses when a slot method is re-assigned.
@@ -5098,6 +5114,22 @@ def __new__(mcls, name, bases, ns):
         with self.assertWarnsRegex(RuntimeWarning, 'MyClass'):
             MyClass = meta('MyClass', (), {})
 
+    @support.cpython_only
+    def test_str_subclass_namespace_key_identity(self):
+        class Key(str):
+            pass
+
+        key = Key('other')
+        C = type('C', (), {key: 1})
+        stored_key = next(iter(C.__dict__))
+        self.assertEqual(stored_key, key)
+        self.assertEqual(C.other, 1)
+        if support.Py_GIL_DISABLED:
+            self.assertIs(type(stored_key), str)
+        else:
+            self.assertIs(stored_key, key)
+
+    @unittest.skipUnless(support.Py_GIL_DISABLED, 'needs a free-threaded build')
     def test_str_subclass_namespace_keys(self):
         # Keys of the class namespace that are str subclasses are copied
         # to exact str in the type's __dict__, like type.__setattr__ does.
 
@@ -6,7 +6,9 @@
 from threading import Thread
 from unittest import TestCase
 
-from test.support import threading_helper
+from test.support import import_helper, threading_helper
+
+_testinternalcapi = import_helper.import_module("_testinternalcapi")
 
 
 
 
@@ -2580,6 +2580,7 @@ PyDict_GetItemRef(PyObject *op, PyObject *key, PyObject **result)
     return _PyDict_GetItemRef_KnownHash((PyDictObject *)op, key, hash, result);
 }
 
+#ifdef Py_GIL_DISABLED
 static inline int
 compare_generic_exact_unicode(PyDictObject *mp, PyDictKeysObject *dk,
                               void *ep0, Py_ssize_t ix, PyObject *key,
@@ -2632,7 +2633,6 @@ _PyDict_GetItemStackRef_ExactUnicode(PyDictObject *mp, PyObject *key,
 {
     assert(PyUnicode_CheckExact(key));
     PyObject *value;
-#ifdef Py_GIL_DISABLED
     ensure_shared_on_read(mp);
     PyDictKeysObject *dk = _Py_atomic_load_ptr_acquire(&mp->ma_keys);
     if (dk->dk_kind == DICT_KEYS_UNICODE) {
@@ -2648,12 +2648,9 @@ _PyDict_GetItemStackRef_ExactUnicode(PyDictObject *mp, PyObject *key,
     value = _PyDict_GetItem_ExactUnicode(mp, key);
     *value_addr = value ? PyStackRef_FromPyObjectNew(value) : PyStackRef_NULL;
     Py_END_CRITICAL_SECTION();
-#else
-    value = _PyDict_GetItem_ExactUnicode(mp, key);
-    *value_addr = value ? PyStackRef_FromPyObjectNew(value) : PyStackRef_NULL;
-#endif
     return value != NULL;
 }
+#endif
 
 int
 _PyDict_GetItemRef_Unicode_LockHeld(PyDictObject *op, PyObject *key, PyObject **result)
 
@@ -2116,6 +2116,7 @@ type_set_bases(PyObject *tp, PyObject *new_bases, void *Py_UNUSED(closure))
     if (type_check_new_bases(type, new_bases) < 0) {
         return -1;
     }
+#ifdef Py_GIL_DISABLED
     // Create a fresh bases tuple to store.  Its identity tells whether
     // tp_bases was replaced again while TYPE_LOCK was released or due to
     // re-entrancy from the mro() call.
@@ -2124,6 +2125,9 @@ type_set_bases(PyObject *tp, PyObject *new_bases, void *Py_UNUSED(closure))
     if (bases == NULL) {
         return -1;
     }
+#else
+    PyObject *bases = Py_NewRef(new_bases);
+#endif
     BEGIN_TYPE_LOCK();
     res = type_set_bases_unlocked(type, bases);
     END_TYPE_LOCK();
@@ -4902,6 +4906,7 @@ type_new_get_slots(type_new_ctx *ctx, PyObject *dict)
 }
 
 
+#ifdef Py_GIL_DISABLED
 /* Copy the class namespace.  Keys that are str subclasses are replaced by
    exact str copies so that the type dict only holds exact str keys (see
    type_setattro() which does the same for assigned names).  Lookups in a
@@ -4963,11 +4968,16 @@ type_new_copy_dict(PyObject *orig_dict)
     Py_DECREF(newdict);
     return NULL;
 }
+#endif
 
 static PyTypeObject*
 type_new_init(type_new_ctx *ctx)
 {
+#ifdef Py_GIL_DISABLED
     PyObject *dict = type_new_copy_dict(ctx->orig_dict);
+#else
+    PyObject *dict = _PyDict_CopyAsDict(ctx->orig_dict);
+#endif
     if (dict == NULL) {
         goto error;
     }
@@ -6797,11 +6807,12 @@ type_update_dict(PyTypeObject *type, PyDictObject *dict, PyObject *name,
     // We don't want any re-entrancy between when we update the dict
     // and call type_modified_unlocked, including running the destructor
     // of the current value as it can observe the cache in an inconsistent
-    // state.  The name is an exact unicode (see type_setattro()) and
-    // str subclass keys are copied to exact str by type_new_copy_dict()
-    // and type_setattro().  The type dict can still hold non-str keys
-    // (type_new_impl() only warns about them) and comparing with one of
-    // those can run user code that releases the locks.
+    // state.  The name is an exact unicode (see type_setattro()).  In the
+    // free-threaded build, str subclass keys are copied to exact str by
+    // type_new_copy_dict().  The type dict can still hold non-str keys
+    // (type_new_impl() only warns about them), or str subclass keys in the
+    // default build.  Comparing with those can run user code that releases
+    // the locks.
     if (_PyDict_GetItemRef_Unicode_LockHeld(dict, name, old_value) < 0) {
         return -1;
     }