Update backported code for 3.11 specifically

python · Fidget-Spinner · Feb 6, 2024 · Jan 11, 2024 · Jan 12, 2024 · Feb 5, 2024
commit 1d36a9c3a988aa869c7a0a40891eaeb6649e58f5
diff --git a/Lib/test/test_type_cache.py b/Lib/test/test_type_cache.py
@@ -12,10 +12,16 @@
 _testcapi = import_helper.import_module("_testcapi")
 type_get_version = _testcapi.type_get_version
 type_assign_specific_version_unsafe = _testcapi.type_assign_specific_version_unsafe
-type_assign_version = _testcapi.type_assign_version
 type_modified = _testcapi.type_modified
 
 
+def type_assign_version(type_):
+    try:
+        type_.x
+    except AttributeError:
+        pass
+
+
 @support.cpython_only
 @unittest.skipIf(_clear_type_cache is None, "requires sys._clear_type_cache")
 class TypeCacheTests(unittest.TestCase):
@@ -47,19 +53,6 @@ def test_tp_version_tag_unique(self):
         self.assertEqual(len(set(all_version_tags)), 30,
                          msg=f"{all_version_tags} contains non-unique versions")
 
-    def test_type_assign_version(self):
-        class C:
-            x = 5
-
-        self.assertEqual(type_assign_version(C), 1)
-        c_ver = type_get_version(C)
-
-        C.x = 6
-        self.assertEqual(type_get_version(C), 0)
-        self.assertEqual(type_assign_version(C), 1)
-        self.assertNotEqual(type_get_version(C), 0)
-        self.assertNotEqual(type_get_version(C), c_ver)
-
     def test_type_assign_specific_version(self):
         """meta-test for type_assign_specific_version_unsafe"""
         class C:
@@ -108,134 +101,103 @@ def _check_specialization(self, func, arg, opname, *, should_specialize):
         else:
             self.assertIn(opname, self._all_opnames(func))
 
-    def test_class_load_attr_specialization_user_type(self):
+    def test_load_method_specialization_user_type(self):
         class A:
             def foo(self):
                 pass
 
         self._assign_valid_version_or_skip(A)
 
-        def load_foo_1(type_):
-            type_.foo
+        def load_foo_1(instance):
+            instance.foo()
 
-        self._check_specialization(load_foo_1, A, "LOAD_ATTR", should_specialize=True)
+        self._check_specialization(
+            load_foo_1, A(), "LOAD_METHOD_ADAPTIVE", should_specialize=True
+        )
         del load_foo_1
 
         self._assign_and_check_version_0(A)
 
-        def load_foo_2(type_):
-            return type_.foo
-
-        self._check_specialization(load_foo_2, A, "LOAD_ATTR", should_specialize=False)
-
-    def test_class_load_attr_specialization_static_type(self):
-        self._assign_valid_version_or_skip(str)
-        self._assign_valid_version_or_skip(bytes)
-
-        def get_capitalize_1(type_):
-            return type_.capitalize
-
-        self._check_specialization(get_capitalize_1, str, "LOAD_ATTR", should_specialize=True)
-        self.assertEqual(get_capitalize_1(str)('hello'), 'Hello')
-        self.assertEqual(get_capitalize_1(bytes)(b'hello'), b'Hello')
-        del get_capitalize_1
-
-        # Permanently overflow the static type version counter, and force str and bytes
-        # to have tp_version_tag == 0
-        for _ in range(2**16):
-            type_modified(str)
-            type_assign_version(str)
-            type_modified(bytes)
-            type_assign_version(bytes)
-
-        self.assertEqual(type_get_version(str), 0)
-        self.assertEqual(type_get_version(bytes), 0)
-
-        def get_capitalize_2(type_):
-            return type_.capitalize
+        def load_foo_2(instance):
+            instance.foo()
 
-        self._check_specialization(get_capitalize_2, str, "LOAD_ATTR", should_specialize=False)
-        self.assertEqual(get_capitalize_2(str)('hello'), 'Hello')
-        self.assertEqual(get_capitalize_2(bytes)(b'hello'), b'Hello')
-
-    def test_property_load_attr_specialization_user_type(self):
-        class G:
-            @property
-            def x(self):
-                return 9
-
-        self._assign_valid_version_or_skip(G)
-
-        def load_x_1(instance):
-            instance.x
-
-        self._check_specialization(load_x_1, G(), "LOAD_ATTR", should_specialize=True)
-        del load_x_1
-
-        self._assign_and_check_version_0(G)
-
-        def load_x_2(instance):
-            instance.x
-
-        self._check_specialization(load_x_2, G(), "LOAD_ATTR", should_specialize=False)
+        self._check_specialization(
+            load_foo_2, A(), "LOAD_METHOD_ADAPTIVE", should_specialize=False
+        )
 
     def test_store_attr_specialization_user_type(self):
         class B:
             __slots__ = ("bar",)
 
         self._assign_valid_version_or_skip(B)
 
-        def store_bar_1(type_):
-            type_.bar = 10
+        def store_bar_1(instance):
+            instance.bar = 10
 
-        self._check_specialization(store_bar_1, B(), "STORE_ATTR", should_specialize=True)
+        self._check_specialization(
+            store_bar_1, B(), "STORE_ATTR_ADAPTIVE", should_specialize=True
+        )
         del store_bar_1
 
         self._assign_and_check_version_0(B)
 
-        def store_bar_2(type_):
-            type_.bar = 10
+        def store_bar_2(instance):
+            instance.bar = 10
 
-        self._check_specialization(store_bar_2, B(), "STORE_ATTR", should_specialize=False)
+        self._check_specialization(
+            store_bar_2, B(), "STORE_ATTR_ADAPTIVE", should_specialize=False
+        )
 
-    def test_class_call_specialization_user_type(self):
-        class F:
+    def test_load_attr_specialization_user_type(self):
+        class C:
+            __slots__ = ("biz",)
             def __init__(self):
-                pass
+                self.biz = 8
 
-        self._assign_valid_version_or_skip(F)
+        self._assign_valid_version_or_skip(C)
 
-        def call_class_1(type_):
-            type_()
+        def load_biz_1(type_):
+            type_.biz
 
-        self._check_specialization(call_class_1, F, "CALL", should_specialize=True)
-        del call_class_1
+        self._check_specialization(
+            load_biz_1, C(), "LOAD_ATTR_ADAPTIVE", should_specialize=True
+        )
+        del load_biz_1
 
-        self._assign_and_check_version_0(F)
+        self._assign_and_check_version_0(C)
 
-        def call_class_2(type_):
-            type_()
+        def load_biz_2(type_):
+            type_.biz
 
-        self._check_specialization(call_class_2, F, "CALL", should_specialize=False)
+        self._check_specialization(
+            load_biz_2, C(), "LOAD_ATTR_ADAPTIVE", should_specialize=False
+        )
 
-    def test_to_bool_specialization_user_type(self):
-        class H:
-            pass
+    def test_binary_subscript_specialization_user_type(self):
+        class D:
+            def __getitem__(self, _):
+                return 1
+
+        self._assign_valid_version_or_skip(D)
+
+        def subscript_1(instance):
+            instance[6]
 
-        self._assign_valid_version_or_skip(H)
+        self._check_specialization(
+            subscript_1, D(), "BINARY_SUBSCR_ADAPTIVE", should_specialize=True
+        )
+        del subscript_1
 
-        def to_bool_1(instance):
-            not instance
+        self._assign_and_check_version_0(D)
 
-        self._check_specialization(to_bool_1, H(), "TO_BOOL", should_specialize=True)
-        del to_bool_1
+        def subscript_2(instance):
+            instance[6]
 
-        self._assign_and_check_version_0(H)
+        self._check_specialization(
+            subscript_2, D(), "BINARY_SUBSCR_ADAPTIVE", should_specialize=False
+        )
 
-        def to_bool_2(instance):
-            not instance
 
-        self._check_specialization(to_bool_2, H(), "TO_BOOL", should_specialize=False)
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/Modules/_testcapimodule.c b/Modules/_testcapimodule.c
@@ -5926,17 +5926,6 @@ type_assign_specific_version_unsafe(PyObject *self, PyObject *args)
     Py_RETURN_NONE;
 }
 
-static PyObject *
-type_assign_version(PyObject *self, PyObject *type)
-{
-    if (!PyType_Check(type)) {
-        PyErr_SetString(PyExc_TypeError, "argument must be a type");
-        return NULL;
-    }
-    int res = PyUnstable_Type_AssignVersionTag((PyTypeObject *)type);
-    return PyLong_FromLong(res);
-}
-
 // Test PyThreadState C API
 static PyObject *
 test_tstate_capi(PyObject *self, PyObject *Py_UNUSED(args))
@@ -6822,7 +6811,6 @@ static PyMethodDef TestMethods[] = {
     {"type_modified", type_modified, METH_O, PyDoc_STR("PyType_Modified")},
     {"type_assign_specific_version_unsafe", type_assign_specific_version_unsafe, METH_VARARGS,
      PyDoc_STR("forcefully assign type->tp_version_tag")},
-    {"type_assign_version", type_assign_version, METH_O, PyDoc_STR("PyUnstable_Type_AssignVersionTag")},
     {"test_tstate_capi", test_tstate_capi, METH_NOARGS, NULL},
     {"float_pack", test_float_pack, METH_VARARGS, NULL},
     {"float_unpack", test_float_unpack, METH_VARARGS, NULL},

diff --git a/Python/specialize.c b/Python/specialize.c
@@ -896,7 +896,7 @@ specialize_class_load_method(PyObject *owner, _Py_CODEUNIT *instr,
     PyObject *descr = NULL;
     DescriptorClassification kind = 0;
     kind = analyze_descriptor((PyTypeObject *)owner, name, &descr, 0);
-    if (type_get_version((PyTypeObject *)owner, LOAD_ATTR) == 0) {
+    if (type_get_version((PyTypeObject *)owner, LOAD_METHOD) == 0) {
         return -1;
     }
     switch (kind) {
@@ -960,6 +960,9 @@ _Py_Specialize_LoadMethod(PyObject *owner, _Py_CODEUNIT *instr, PyObject *name)
     PyObject *descr = NULL;
     DescriptorClassification kind = 0;
     kind = analyze_descriptor(owner_cls, name, &descr, 0);
+    if (type_get_version(owner_cls, LOAD_METHOD) == 0) {
+        goto fail;
+    }
     assert(descr != NULL || kind == ABSENT || kind == GETSET_OVERRIDDEN);
     if (kind != METHOD) {
         SPECIALIZATION_FAIL(LOAD_METHOD, load_method_fail_kind(kind));
@@ -1253,6 +1256,9 @@ _Py_Specialize_BinarySubscr(
             SPECIALIZATION_FAIL(BINARY_SUBSCR, SPEC_FAIL_WRONG_NUMBER_ARGUMENTS);
             goto fail;
         }
+        if (type_get_version(cls, BINARY_SUBSCR) == 0) {
+            goto fail;
+        }
         assert(cls->tp_version_tag != 0);
         write_u32(cache->type_version, cls->tp_version_tag);
         int version = _PyFunction_GetVersionForCurrentState(func);