Narrow to true but keep the isinstance call

Author: tomasr8

Lib/test/test_capi/test_opt.py

@@ -2234,7 +2234,8 @@ def testfunc(n):
             x = 0
             for _ in range(n):
                 # One of the classes is unknown, but it comes
-                # after a known class, so we can narrow to True
+                # after a known class, so we can narrow to True and
+                # remove the isinstance call.
                 y = isinstance(42, (int, eval('str')))
                 if y:
                     x += 1
@@ -2246,16 +2247,17 @@ def testfunc(n):
         uops = get_opnames(ex)
         self.assertNotIn("_CALL_ISINSTANCE", uops)
         self.assertNotIn("_TO_BOOL_BOOL", uops)
-        self.assertNotIn("_GUARD_IS_FALSE_POP", uops)
+        self.assertNotIn("_GUARD_IS_TRUE_POP", uops)
         self.assertIn("_BUILD_TUPLE", uops)
         self.assertIn("_POP_CALL_TWO_LOAD_CONST_INLINE_BORROW", uops)
 
     def test_call_isinstance_tuple_of_classes_true_unknown_2(self):
         def testfunc(n):
             x = 0
             for _ in range(n):
-                # One of the classes is unknown, so we can't narrow
-                # to True or False, only bool
+                # We can narrow to True, but since the unknown class comes
+                # first and could potentially trigger an __instancecheck__,
+                # we can't remove the isinstance call.
                 y = isinstance(42, (eval('str'), int))
                 if y:
                     x += 1
@@ -2267,14 +2269,13 @@ def testfunc(n):
         uops = get_opnames(ex)
         self.assertIn("_CALL_ISINSTANCE", uops)
         self.assertNotIn("_TO_BOOL_BOOL", uops)
-        self.assertIn("_GUARD_IS_TRUE_POP", uops)
+        self.assertNotIn("_GUARD_IS_TRUE_POP", uops)
 
     def test_call_isinstance_tuple_of_classes_true_unknown_3(self):
         def testfunc(n):
             x = 0
             for _ in range(n):
-                # One of the classes is unknown, so we can't narrow
-                # to True or False, only bool
+                # We can only narrow to bool here
                 y = isinstance(42, (str, eval('int')))
                 if y:
                     x += 1
@@ -2292,8 +2293,7 @@ def test_call_isinstance_tuple_of_classes_true_unknown_4(self):
         def testfunc(n):
             x = 0
             for _ in range(n):
-                # One of the classes is unknown, so we can't narrow
-                # to True or False, only bool
+                # We can only narrow to bool here
                 y = isinstance(42, (eval('int'), str))
                 if y:
                     x += 1

Python/optimizer_bytecodes.c

@@ -973,15 +973,17 @@ dummy_func(void) {
             int length = sym_tuple_length(cls);
             if (length != -1) {
                 // We cannot do anything about tuples with unknown length
+                bool can_replace_op = true;
                 PyObject *out = Py_False;
                 for (int i = 0; i < length; i++) {
                     JitOptRef item = sym_tuple_getitem(ctx, cls, i);
                     if (!sym_has_type(item)) {
                         // There is an unknown item in the tuple.
                         // It could potentially define its own __instancecheck__
-                        // method so we can only deduce bool.
+                        // so it is no longer possible to replace the op with a const load.
                         out = NULL;
-                        break;
+                        can_replace_op = false;
+                        continue;
                     }
                     PyTypeObject *cls_o = (PyTypeObject *)sym_get_const(ctx, item);
                     if (cls_o &&
@@ -994,7 +996,9 @@ dummy_func(void) {
                 }
                 if (out) {
                     sym_set_const(res, out);
-                    REPLACE_OP(this_instr, _POP_CALL_TWO_LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)out);
+                    if (can_replace_op) {
+                        REPLACE_OP(this_instr, _POP_CALL_TWO_LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)out);
+                    }
                 }
             }
         }