python · tomasr8 · May 22, 2025 · May 22, 2025 · May 22, 2025 · Jul 5, 2025
diff --git a/Lib/test/test_capi/test_opt.py b/Lib/test/test_capi/test_opt.py
@@ -2105,17 +2105,116 @@ def testfunc(n):
         self.assertNotIn("_TO_BOOL_BOOL", uops)
         self.assertIn("_GUARD_IS_TRUE_POP", uops)
 
-    def test_call_isinstance_tuple_of_classes(self):
+    def test_call_isinstance_tuple_of_classes_is_true(self):
         def testfunc(n):
             x = 0
             for _ in range(n):
-                # A tuple of classes is currently not optimized,
-                # so this is only narrowed to bool:
                 y = isinstance(42, (int, str))
                 if y:
                     x += 1
             return x
 
+        res, ex = self._run_with_optimizer(testfunc, TIER2_THRESHOLD)
+        self.assertEqual(res, TIER2_THRESHOLD)
+        self.assertIsNotNone(ex)
+        uops = get_opnames(ex)
+        self.assertNotIn("_CALL_ISINSTANCE", uops)
+        self.assertNotIn("_TO_BOOL_BOOL", 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_is_false(self):
+        def testfunc(n):
+            x = 0
+            for _ in range(n):
+                y = isinstance(42, (bool, str))
+                if not y:
+                    x += 1
+            return x
+
+        res, ex = self._run_with_optimizer(testfunc, TIER2_THRESHOLD)
+        self.assertEqual(res, TIER2_THRESHOLD)
+        self.assertIsNotNone(ex)
+        uops = get_opnames(ex)
+        self.assertNotIn("_CALL_ISINSTANCE", uops)
+        self.assertNotIn("_TO_BOOL_BOOL", uops)
+        self.assertNotIn("_GUARD_IS_FALSE_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(self):
+        def testfunc(n):
+            x = 0
+            for _ in range(n):
+                # One of the classes is unknown, but we can still
+                # narrow to True
+                y = isinstance(42, (eval('str'), int))
+                if y:
+                    x += 1
+            return x
+
+        res, ex = self._run_with_optimizer(testfunc, TIER2_THRESHOLD)
+        self.assertEqual(res, TIER2_THRESHOLD)
+        self.assertIsNotNone(ex)
+        uops = get_opnames(ex)
+        self.assertNotIn("_CALL_ISINSTANCE", uops)
+        self.assertNotIn("_TO_BOOL_BOOL", 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_unknown_not_narrowed(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
+                y = isinstance(42, (str, eval('int')))
+                if y:
+                    x += 1
+            return x
+
+        res, ex = self._run_with_optimizer(testfunc, TIER2_THRESHOLD)
+        self.assertEqual(res, TIER2_THRESHOLD)
+        self.assertIsNotNone(ex)
+        uops = get_opnames(ex)
+        self.assertIn("_CALL_ISINSTANCE", uops)
+        self.assertNotIn("_TO_BOOL_BOOL", uops)
+        self.assertIn("_GUARD_IS_TRUE_POP", uops)
+
+    def test_call_isinstance_empty_tuple(self):
+        def testfunc(n):
+            x = 0
+            for _ in range(n):
+                y = isinstance(42, ())
+                if not y:
+                    x += 1
+            return x
+
+        res, ex = self._run_with_optimizer(testfunc, TIER2_THRESHOLD)
+        self.assertEqual(res, TIER2_THRESHOLD)
+        self.assertIsNotNone(ex)
+        uops = get_opnames(ex)
+        self.assertNotIn("_CALL_ISINSTANCE", uops)
+        self.assertNotIn("_TO_BOOL_BOOL", uops)
+        self.assertNotIn("_GUARD_IS_FALSE_POP", uops)
+        self.assertNotIn("_POP_TOP_LOAD_CONST_INLINE_BORROW", uops)
+        self.assertNotIn("_POP_CALL_LOAD_CONST_INLINE_BORROW", uops)
+        self.assertNotIn("_POP_CALL_ONE_LOAD_CONST_INLINE_BORROW", uops)
+        self.assertNotIn("_POP_CALL_TWO_LOAD_CONST_INLINE_BORROW", uops)
+
+    def test_call_isinstance_tuple_unknown_length(self):
+        def testfunc(n):
+            x = 0
+            for _ in range(n):
+                # tuple with an unknown length, we only narrow to bool
+                tup = tuple(eval('(int, str)'))
+                y = isinstance(42, tup)
+                if y:
+                    x += 1
+            return x
+
         res, ex = self._run_with_optimizer(testfunc, TIER2_THRESHOLD)
         self.assertEqual(res, TIER2_THRESHOLD)
         self.assertIsNotNone(ex)

diff --git a/Misc/NEWS.d/next/Core_and_Builtins/2025-05-22-22-19-56.gh-issue-131798.kxRt1-.rst b/Misc/NEWS.d/next/Core_and_Builtins/2025-05-22-22-19-56.gh-issue-131798.kxRt1-.rst
@@ -0,0 +1,2 @@
+Optimize ``_CALL_ISINSTANCE`` in the JIT when the second argument is a tuple
+of classes.
@@ -938,6 +938,9 @@ dummy_func(void) {
     }
 
     op(_CALL_ISINSTANCE, (unused, unused, instance, cls -- res)) {
+// The below define is equivalent to PyObject_TypeCheck(inst, cls)
+#define sym_IS_SUBTYPE(inst, cls) ((inst) == (cls) || PyType_IsSubtype(inst, cls))
+
         // the result is always a bool, but sometimes we can
         // narrow it down to True or False
         res = sym_new_type(ctx, &PyBool_Type);
@@ -947,14 +950,54 @@ dummy_func(void) {
             // isinstance(inst, cls) where both inst and cls have
             // known types, meaning we can deduce either True or False
 
-            // The below check is equivalent to PyObject_TypeCheck(inst, cls)
             PyObject *out = Py_False;
-            if (inst_type == cls_o || PyType_IsSubtype(inst_type, cls_o)) {
+            if (sym_IS_SUBTYPE(inst_type, cls_o)) {
                 out = Py_True;
             }
             sym_set_const(res, out);
             REPLACE_OP(this_instr, _POP_CALL_TWO_LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)out);
         }
+        else if (inst_type && sym_matches_type(cls, &PyTuple_Type)) {
+            // isinstance(inst, tup) where inst has a known type and tup is a tuple.
+            // We can deduce True if inst is an instance of at least one of
+            // the items in the tuple.
+            // We can deduce False if all items in the tuple have known types and
+            // inst is not an instance of any of them.
+
+            int length = sym_tuple_length(cls);
+            if (length != -1) {
+                // We cannot do anything about tuples with unknown length
+                bool all_items_known = true;
+                PyObject *out = NULL;
+                for (int i = 0; i < length; i++) {
+                    JitOptSymbol *item = sym_tuple_getitem(ctx, cls, i);
+                    if (!sym_has_type(item)) {
+                        // There is an unknown item in the tuple,
+                        // we can no longer deduce False.
+                        all_items_known = false;
+                        continue;
+                    }
+                    PyTypeObject *cls_o = (PyTypeObject *)sym_get_const(ctx, item);
+                    if (cls_o &&
+                        sym_matches_type(item, &PyType_Type) &&
+                        sym_IS_SUBTYPE(inst_type, cls_o))
+                    {
+                        out = Py_True;
+                        break;
+                    }
+                }
+                if (!out && all_items_known) {
+                    // We haven't deduced True, but all items in the tuple are known
+                    // so we can deduce False
+                    out = Py_False;
+                }
+                if (out) {
+                    sym_set_const(res, out);
+                    REPLACE_OP(this_instr, _POP_CALL_TWO_LOAD_CONST_INLINE_BORROW, 0, (uintptr_t)out);
+                }
+            }
+        }
+#undef sym_IS_SUBTYPE
     }
 
     op(_GUARD_IS_TRUE_POP, (flag -- )) {

diff --git a/Python/optimizer_cases.c.h b/Python/optimizer_cases.c.h
Original file line number	Diff line number	Diff line change
		@@ -0,0 +1,2 @@
		Optimize ``_CALL_ISINSTANCE`` in the JIT when the second argument is a tuple
		of classes.