constant fold on classes as well

Author: kumaraditya303

Include/internal/pycore_opcode_metadata.h

@@ -3196,10 +3196,12 @@ def f(n):
                 x += e.m()  # _LOAD_ATTR_METHOD_LAZY_DICT
                 x += f.class_method()  # _LOAD_ATTR
                 x += f.static_method()  # _LOAD_ATTR
+                x += F.class_method()  # _LOAD_ATTR
+                x += F.static_method()  # _LOAD_ATTR
             return x
 
         res, ex = self._run_with_optimizer(f, TIER2_THRESHOLD)
-        self.assertEqual(res, 8 * TIER2_THRESHOLD)
+        self.assertEqual(res, 10 * TIER2_THRESHOLD)
         self.assertIsNotNone(ex)
         uops = get_opnames(ex)
         self.assertNotIn("_LOAD_ATTR", uops)

Lib/test/test_capi/test_opt.py

@@ -2728,7 +2728,7 @@ dummy_func(
 
         macro(LOAD_ATTR) =
             _SPECIALIZE_LOAD_ATTR +
-            _RECORD_TOS_TYPE +
+            _RECORD_TOS +
             unused/8 +
             _LOAD_ATTR;
 

Python/bytecodes.c

@@ -873,7 +873,15 @@ dummy_func(void) {
     }
 
     op(_LOAD_ATTR, (owner -- attr, self_or_null[oparg&1])) {
-        PyTypeObject *type = sym_get_probable_type(owner);
+        PyObject *value = sym_get_probable_value(owner);
+        PyTypeObject *type = NULL;
+        if (value != NULL && PyType_Check(value)) {
+            type = (PyTypeObject *)value;
+        }
+        else {
+            type = sym_get_probable_type(owner);
+        }
+
         if (oparg & 1 && type != NULL) {
             PyObject *name = get_co_name(ctx, oparg >> 1);
             PyObject *descr = _PyType_Lookup(type, name);
@@ -890,24 +898,32 @@ dummy_func(void) {
                 }
                 assert(callable);
                 bool immortal = _Py_IsImmortal(callable) || (type->tp_flags & Py_TPFLAGS_IMMUTABLETYPE);
-                ADD_OP(_GUARD_TYPE_VERSION, 0, type->tp_version_tag);
+                if (PyType_Check(value)) {
+                    ADD_OP(_CHECK_ATTR_CLASS, 0, type->tp_version_tag);
+                }
+                else {
+                    ADD_OP(_GUARD_TYPE_VERSION, 0, type->tp_version_tag);
+                }
                 ADD_OP(_POP_TOP, 0, 0);
                 ADD_OP(immortal ? _LOAD_CONST_INLINE_BORROW : _LOAD_CONST_INLINE, 0, (uintptr_t)callable);
                 if (class_method) {
                     ADD_OP(_LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)type);
                     self_or_null[0] = sym_new_const(ctx, (PyObject *)type);
-                } else if (static_method) {
+                }
+                else {
                     ADD_OP(_PUSH_NULL, 0, 0);
                     self_or_null[0] = sym_new_null(ctx);
                 }
                 attr = sym_new_const(ctx, callable);
                 PyType_Watch(TYPE_WATCHER_ID, (PyObject *)type);
                 _Py_BloomFilter_Add(dependencies, (PyTypeObject *)type);
-            } else {
+            }
+            else {
                 attr = sym_new_not_null(ctx);
                 self_or_null[0] = sym_new_unknown(ctx);
             }
-        } else {
+        }
+        else {
             attr = sym_new_not_null(ctx);
         }
     }