test: call-shape falsifier extension for emitCallExceptionHandler D1-D3

SonicField · SonicField · commit a642405a5ccd · 2026-04-22T10:28:51.000-07:00
Per pythia python#77 python#3 [chat L1937] gap + supervisor [chat L1939] authorization + theologian [chat L1942] spec: extend test_phoenix_jit_inline_except_closure.py with TestJitCallExceptionHandler class covering 3 tests that exercise the emitCallExceptionHandler unique invariants (D1-D3) NOT covered by the existing inline-except (BINARY_SUBSCR_DICT) tests. GAP CONTEXT: push 60 (9630005) landed emitCallExceptionHandler with shared-helper design — D1-D3 unique invariants ride only the shared P2+P3+P4 helper through the closure-LOAD_DEREF inline-except falsifier. Call-shape (function-call-in-try) was empirically untested at push 60. This falsifier closes that coverage gap retroactively. Lib/test/test_phoenix_jit_inline_except_closure.py: +135 lines, new class TestJitCallExceptionHandler with 3 tests: - C1 test_call_in_try_simple_except: function-call-in-try, ValueError matched + return from except. Exercises D1 (setSuppressExceptionDeopt + pop result pre-call) + D3 (RefineType + result push on OK path). - C2 test_call_in_try_with_closure_load_deref: function-call-in-try, LOAD_DEREF on closure variable in except body. Exercises D1-D3 + PA (D-1774910012 prev_exc Py_None placeholder under emitCallExceptionHandler entry). - C3 test_call_in_try_deopt_path: function-call-in-try, unmatched exception (TypeError vs except ValueError). Exercises D2 (DeoptTC zero re-push, no left/right context — call-handler doesn't have left/right unlike inline-match). EXISTING TESTS PRESERVED unchanged: TestJitInlineExceptClosure (3 tests) — D-1774910012 PA invariant via inline-except path, retained as the original falsifier. EMPIRICAL VALIDATION RESULT (testkeeper [chat L1946]): Run on push 60 binary 9630005 (ARM64 pydebug): 6/6 PASS, OK, 0.177s, EXIT=0, NO core dump. All D1-D3 invariants empirically validated; PA preserved across both call-handler and inline-match entry paths. PYTHIA python#77 python#3 SUBSTANCE CLOSED: D1-D3 unique invariants now empirically exercised, not only ride-along through shared helper. Falsifier-pre-port discipline restored for emitCallExceptionHandler (regression test exists post-port; ideal would have been pre-port but supervisor [chat L1939] accepted post-port retroactive validation as remediation). Bundled with push 61 (b28b512 emitAnyCall PartialConversion, Tier 5 close) per testkeeper [chat L1946] (a) sequencing — single gate cycle, single push, no separate gate ceremony for .py-only change. Authorization chain: - pythia python#77 python#3: chat L1937 (gap surfaced) - supervisor authorization: chat L1939 - theologian spec: chat L1942 - testkeeper draft + push-60-binary validation: chat L1946
diff --git a/Lib/test/test_phoenix_jit_inline_except_closure.py b/Lib/test/test_phoenix_jit_inline_except_closure.py
@@ -138,5 +138,120 @@ def inner(should_raise):
         self.assertEqual(r2, ("post-except", before + 2))
 
 
+@unittest.skipUnless(HAS_JIT, "requires JIT")
+class TestJitCallExceptionHandler(unittest.TestCase):
+    """Falsifier for emitCallExceptionHandler D1-D3 unique invariants.
+
+    Per theologian [chat 17:23:36Z] spec — push 60 emitCallExceptionHandler C
+    port (9630005502) introduced D1 (setSuppressExceptionDeopt + pop result
+    pre-call), D2 (DeoptTC zero re-push), D3 (RefineType + result push) on top
+    of the shared P2+P3+P4 helper. The shared helper is exercised by
+    TestJitInlineExceptClosure above; D1-D3 unique invariants are exercised
+    here via function-call-in-try shape (NOT BINARY_SUBSCR_DICT).
+
+    Pythia #77 #3 + supervisor [chat 17:23:12Z] authorized this as pre-push-61
+    gate (regression-test-pre-exists discipline matching D-1774910012).
+    """
+
+    def test_call_in_try_simple_except(self):
+        """C1 — function call in try, ValueError matched, return from except.
+
+        Triggers D1 (setSuppressExceptionDeopt + pop) and D3 (RefineType +
+        result push). D3 omission would NameError-on-result on OK path; D1
+        omission would deopt instead of inline-handle.
+        """
+        def _helper(should_raise):
+            if should_raise:
+                raise ValueError("test")
+            return 42
+
+        def caller(should_raise):
+            try:
+                return _helper(should_raise)
+            except ValueError:
+                return -1
+
+        for _ in range(WARMUP):
+            self.assertEqual(caller(False), 42)
+        self.assertTrue(cinderjit.is_jit_compiled(caller),
+                        "caller was NOT JIT-compiled after warmup")
+
+        # Exercise both OK (D3) and except (D1) paths under JIT
+        self.assertEqual(caller(False), 42)
+        self.assertEqual(caller(True), -1)
+        for _ in range(100):
+            self.assertEqual(caller(False), 42)
+            self.assertEqual(caller(True), -1)
+
+    def test_call_in_try_with_closure_load_deref(self):
+        """C2 — function call in try, except body LOAD_DEREFs closure variable.
+
+        Exercises BOTH D1-D3 (call-handler entry path) AND PA (D-1774910012
+        prev_exc Py_None placeholder push + POP_EXCEPT pop semantics). PA
+        failure would corrupt sys.exc_info post-loop.
+        """
+        def _helper(should_raise):
+            if should_raise:
+                raise ValueError("test")
+            return 42
+
+        def make_handler(default):
+            def caller(should_raise):
+                try:
+                    return _helper(should_raise)
+                except ValueError:
+                    return default  # LOAD_DEREF on closure
+            return caller
+
+        handler = make_handler(-99)
+        for _ in range(WARMUP):
+            self.assertEqual(handler(False), 42)
+        self.assertTrue(cinderjit.is_jit_compiled(handler),
+                        "handler was NOT JIT-compiled after warmup")
+
+        self.assertEqual(handler(False), 42)
+        self.assertEqual(handler(True), -99)
+        # exc_info chain must remain clean post-loop (PA invariant)
+        for _ in range(100):
+            self.assertEqual(handler(True), -99)
+            self.assertEqual(handler(False), 42)
+            self.assertIsNone(sys.exc_info()[1],
+                              "sys.exc_info corrupted by call-handler path")
+
+    def test_call_in_try_deopt_path(self):
+        """C3 — function call in try, exception NOT matched (TypeError vs ValueError).
+
+        Triggers D2 (DeoptTC zero re-push, no left/right context). D2 omission
+        would corrupt deopt frame state when unmatched exception propagates
+        through the call-handler path.
+        """
+        def _maybe_raise(should_raise):
+            if should_raise:
+                raise TypeError("wrong type")
+            return 42
+
+        def caller(should_raise):
+            try:
+                return _maybe_raise(should_raise)
+            except ValueError:  # WRONG type — TypeError will not match
+                return -1
+
+        for _ in range(WARMUP):
+            self.assertEqual(caller(False), 42)
+        self.assertTrue(cinderjit.is_jit_compiled(caller),
+                        "caller was NOT JIT-compiled after warmup")
+
+        # Exercise deopt path: TypeError propagates out of caller (unmatched)
+        with self.assertRaises(TypeError):
+            caller(True)
+        # OK path still correct post-deopt
+        self.assertEqual(caller(False), 42)
+        # Run several deopts in a row
+        for _ in range(50):
+            with self.assertRaises(TypeError):
+                caller(True)
+            self.assertEqual(caller(False), 42)
+
+
 if __name__ == "__main__":
     unittest.main()
