builder: emitAnyCall await-tail → C (PartialConversion, 102/144 → 103/144 = 71.5%)

SonicField · SonicField · commit b28b51232582 · 2026-04-22T10:25:10.000-07:00
PartialConversion per theologian PTE pre-audit (chat 2026-04-22 17:15Z) + supervisor concurrence (chat 17:18Z) + Alex 'NO SESSION BOUNDARIES — keep working until ZERO C++' anchor [memory 2026-04-21]. Bridge-count gate satisfied: 1 new top-level bridge (within gate), 0 sub-bridges. SCOPE: only the await-tail dispatch (lines 2963-2993 in pre-conversion source) is converted to C. The opcode-switch + INVOKE_FUNCTION/NATIVE/ METHOD/METHOD_VECTORCALL dispatch stay C++ until Tier 6 INVOKE_* re-architecture (deferred per gate-count gate per [chat L1922]: FullConversion would require 4+ new bridges, violating ≤1 limit). Python/jit/hir/builder.cpp: emitAnyCall await-tail block (lines 2963-2993, ~30 lines C++) → 1) C++ stub: 3x ++bc_it + 3x JIT_CHECK on opcode sequence (PA + A4) + checkAsyncWithError(get_awaitable_bc) → (error_aenter, error_aexit) + extract load_const_oparg from LOAD_CONST bc + call C body 2) checkAsyncWithError forward decl added (defined static at builder.cpp :~4856, post-call-site refactor required forward visibility) 3) New extern decl: hir_builder_emit_awaited_call_tail_c Python/jit/hir/builder_emit_c.c: NEW hir_builder_emit_awaited_call_tail_c (~50 lines): A5 alloc out + 2 blocks (await_block + post_await_block) A5 dispatch_eager_coro_result (chains to push 55 C function) A6 tc->block = await_block A7 get_awaitable using pre-computed error flags (chains to push 56) A8 load_const using pre-computed oparg + caller-passed code A9 yield_from_method (chains to push 53) A10 phx_tc_emit branch to post_await_block A11 tc->block = post_await_block PTE-trial invariant inventory verification per theologian [chat L1928]: 12 invariants A1-A12 + 4 pitfalls PA-PD. PA: JIT_CHECK fires C++-side BEFORE C call ✓ PB: iterator state stays C++-side; only ints + pointers cross boundary ✓ PC: tc->block reassignment in C body (A6 + A11) ✓ PD: code passed as PyCodeObject* (not void*) — preserves emitGetAwaitable port's PA invariant ✓ PTE TRIAL ROUND 2 FEEDBACK: A4 IF/THEN structure made 'JIT_CHECK MUST fire BEFORE C call' visually unambiguous. PD pitfall on code_ typing caught at design time. Two empirical wins (round 1: PD.a/PD.b distinction, round 2: A4 + PD). Bridge spec (8 args, ratified by theologian [chat L1931]): void hir_builder_emit_awaited_call_tail_c( PhxTranslationContext* tc, void* func, void* builder, PyCodeObject* code, int code_flags, int get_awaitable_error_aenter, int get_awaitable_error_aexit, int load_const_oparg); testkeeper x86_64 compile-only PASS verified pre-commit at binary timestamp 1776878644 (chat 17:24Z). Iter 1 needed forward decl for checkAsyncWithError; v2 cleaned. Tier 5 milestone: 103/144 = 71.5% with PartialConversion-asterisk on emitAnyCall (await-tail in C, opcode-switch + INVOKE_* still C++). Pre-push 61 gate ahead (per pythia python#77 python#3 + supervisor [chat L1939]): testkeeper authors call-shape falsifier extension exercising emitCallExceptionHandler D1-D3 invariants (theologian spec [chat L1942]: 3 tests covering function-call-in-try + closure-LOAD_DEREF + unmatched-exception-deopt). Lands as separate commit before Tier 5 close push. Authorization chain: - theologian PTE pre-audit + design lean (a, but generalist chose b): chat L1928 - bridge spec ratification: chat L1931 - supervisor concurrence on (B) PartialConversion: chat L1930 - testkeeper x86_64 compile PASS: chat L1944
diff --git a/Python/jit/hir/builder.cpp b/Python/jit/hir/builder.cpp
@@ -2854,6 +2854,24 @@ void HIRBuilder::emitPushNull(TranslationContext& tc) {
   hir_builder_emit_push_null_c(static_cast<void*>(&tc), static_cast<void*>(current_func_));
 }
 
+// PartialConversion (theologian PTE pre-audit chat 2026-04-22 17:15Z):
+// emitAnyCall await-tail dispatch (lines 2963-2993 in pre-conversion source)
+// extracted into C body. Opcode-switch + INVOKE_* dispatch stay C++ until
+// Tier 6 INVOKE_* re-architecture. Bridge spec ratified [chat L1931].
+extern "C" void hir_builder_emit_awaited_call_tail_c(
+    void* tc, void* func, void* builder,
+    PyCodeObject* code,
+    int code_flags,
+    int get_awaitable_error_aenter,
+    int get_awaitable_error_aexit,
+    int load_const_oparg);
+
+// Forward decl — checkAsyncWithError is defined static at builder.cpp:~4856,
+// below the emitAnyCall call site. Pre-PartialConversion the call lived
+// inline within the await-tail; refactor hoisted it above the definition.
+static std::pair<bool, bool> checkAsyncWithError(
+    const BytecodeInstructionBlock&, BytecodeInstruction);
+
 void HIRBuilder::emitAnyCall(
     CFG& cfg,
     TranslationContext& tc,
@@ -2961,35 +2979,37 @@ void HIRBuilder::emitAnyCall(
       JIT_ABORT("Unhandled call opcode {} ({})", opcode, opcodeName(opcode));
   }
   if (is_awaited && call_used_is_awaited) {
-    Register* out = temps_.AllocateStack();
-    TranslationContext await_block{cfg.AllocateBlock(), tc.frame};
-    TranslationContext post_await_block{cfg.AllocateBlock(), tc.frame};
-
-    emitDispatchEagerCoroResult(
-        cfg, tc, out, await_block.block, post_await_block.block);
-
-    tc.block = await_block.block;
-
+    // (D1+A4) Advance bc_it three times + assert opcode sequence on the C++
+    // side BEFORE the C body runs. Iterator state never crosses the boundary
+    // (PB invariant) — only int baseOffsets/oparg/error flags pass through.
     ++bc_it;
     JIT_CHECK(
         bc_it->opcode() == GET_AWAITABLE,
         "Awaited function call must be followed by GET_AWAITABLE");
-    emitGetAwaitable(cfg, tc, bc_instrs, *bc_it);
+    auto get_awaitable_bc = *bc_it;
+    auto [error_aenter, error_aexit] =
+        checkAsyncWithError(bc_instrs, get_awaitable_bc);
 
     ++bc_it;
     JIT_CHECK(
         bc_it->opcode() == LOAD_CONST,
         "GET_AWAITABLE must be followed by LOAD_CONST");
-    emitLoadConst(tc, *bc_it);
+    int load_const_oparg = bc_it->oparg();
 
     ++bc_it;
     JIT_CHECK(
         bc_it->opcode() == YIELD_FROM,
         "GET_AWAITABLE should always be followed by LOAD_CONST+YIELD_FROM");
-    emitYieldFrom(tc, out);
-    tc.emitBranch(post_await_block.block);
 
-    tc.block = post_await_block.block;
+    hir_builder_emit_awaited_call_tail_c(
+        static_cast<void*>(&tc),
+        static_cast<void*>(current_func_),
+        static_cast<void*>(this),
+        code_,
+        static_cast<int>(code_->co_flags),
+        static_cast<int>(error_aenter),
+        static_cast<int>(error_aexit),
+        load_const_oparg);
   }
 }
 
diff --git a/Python/jit/hir/builder_emit_c.c b/Python/jit/hir/builder_emit_c.c
@@ -3343,5 +3343,66 @@ void hir_builder_emit_call_exception_handler_c(
     phx_ptr_arr_push(&tc->frame.stack, result);
 }
 
+/* emitAnyCall await-tail dispatch — PartialConversion of HIRBuilder::emitAnyCall.
+ * Mirrors C++ original at builder.cpp:2963-2993 (pre-conversion). The full
+ * emitAnyCall opcode-switch + INVOKE_* dispatch stay C++ pending Tier 6
+ * INVOKE_* re-architecture; only the await-tail (most fragile, most uniform
+ * with Tier 5 patterns) is converted.
+ *
+ * Theologian PTE pre-audit (chat 2026-04-22 17:15Z): A1-A12 invariants +
+ * PA-PD pitfalls. Bridge-count gate satisfied (1 new bridge ≤ 1).
+ *
+ * C++ stub responsibilities (PA + A4): 3x ++bc_it + 3x JIT_CHECK before
+ * this call; iterator state never crosses boundary (PB). All chained C
+ * functions exist (push 53/55/56 + load_const_c). */
+extern void hir_builder_emit_dispatch_eager_coro_result_c(
+    PhxTranslationContext *tc, void *func, void *builder, void *out,
+    void *await_block, void *post_await_block, int code_flags);
+extern void hir_builder_emit_get_awaitable_c(
+    PhxTranslationContext *tc, void *func, void *builder,
+    int error_aenter, int error_aexit);
+extern void hir_builder_emit_yield_from_method_c(
+    PhxTranslationContext *tc, void *out, int code_flags);
+
+void hir_builder_emit_awaited_call_tail_c(
+        PhxTranslationContext *tc,
+        void *func,
+        void *builder,
+        PyCodeObject *code,
+        int code_flags,
+        int get_awaitable_error_aenter,
+        int get_awaitable_error_aexit,
+        int load_const_oparg) {
+    /* A5 setup: out reg + 2 blocks. */
+    void *out = hir_builder_temps_alloc_stack(builder);
+    void *await_block = hir_cfg_alloc_block(func);
+    void *post_await_block = hir_cfg_alloc_block(func);
+
+    /* A5: dispatch_eager_coro_result. */
+    hir_builder_emit_dispatch_eager_coro_result_c(
+        tc, func, builder, out, await_block, post_await_block, code_flags);
+
+    /* A6: switch tc to await_block. */
+    tc->block = await_block;
+
+    /* A7: get_awaitable using pre-computed error flags. */
+    hir_builder_emit_get_awaitable_c(
+        tc, func, builder,
+        get_awaitable_error_aenter, get_awaitable_error_aexit);
+
+    /* A8: load_const using pre-computed oparg + caller-passed code (PD: must
+     * be PyCodeObject*, not void*, to preserve emitGetAwaitable port's PA). */
+    hir_builder_emit_load_const_c(tc, func, code, load_const_oparg);
+
+    /* A9: yield_from on out, code_flags for is_coroutine handling. */
+    hir_builder_emit_yield_from_method_c(tc, out, code_flags);
+
+    /* A10: branch to post_await_block. */
+    phx_tc_emit(tc, hir_c_create_branch_cpp(post_await_block));
+
+    /* A11: switch tc to post_await_block for downstream emit. */
+    tc->block = post_await_block;
+}
+
 
 
