Simplify test to use tempDirWithFiles helper

Use tempDirWithFiles instead of tempDir for cleaner test setup.
Keep async spawn pattern as it properly tests the CLI behavior.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

src/ast/parseFn.zig

@@ -61,14 +61,14 @@ pub fn ParseFn(
                 ifStmtScopeIndex = try p.pushScopeForParsePass(js_ast.Scope.Kind.block, loc);
             }
 
-            var scopeIndex: usize = 0;
-            var pushedScopeForFunctionArgs = false;
-            // Push scope if the current lexer token is an open parenthesis token.
-            // That is, the parser is about parsing function arguments
-            if (p.lexer.token == .t_open_paren) {
-                scopeIndex = try p.pushScopeForParsePass(js_ast.Scope.Kind.function_args, p.lexer.loc());
-                pushedScopeForFunctionArgs = true;
-            }
+            // Always push function_args scope at the current lexer position.
+            // This must happen before parseFn() is called, and must use the same location
+            // that parseFn will capture as open_parens_loc (which is p.lexer.loc() before
+            // expect(t_open_paren)). Even in error recovery cases where we're not at the
+            // open paren, we must push this scope so that parseFnBody's assertion holds.
+            const scopeIndex = try p.pushScopeForParsePass(js_ast.Scope.Kind.function_args, p.lexer.loc());
+            const pushedScopeForFunctionArgs = true;
+            errdefer p.popScope();
 
             var func = try p.parseFn(name, FnOrArrowDataParse{
                 .needs_async_loc = loc,

test/regression/issue/23712.test.ts

@@ -0,0 +1,69 @@
+import { expect, test } from "bun:test";
+import { bunEnv, bunExe, tempDirWithFiles } from "harness";
+import { join } from "path";
+
+test("parser should not crash with assertion error on invalid async function syntax", async () => {
+  // This used to cause: panic(main thread): reached unreachable code
+  // when parsing invalid syntax where async function appears after missing comma
+  const dir = tempDirWithFiles("parser-assertion", {
+    "input.js": `
+const object = {
+  a(el) {
+  } // <-- no comma here
+  b: async function(first) {
+
+  }
+}
+`,
+  });
+
+  await using proc = Bun.spawn({
+    cmd: [bunExe(), "build", join(dir, "input.js")],
+    env: bunEnv,
+    cwd: dir,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]);
+
+  const output = stderr + stdout;
+
+  // Should report parse errors, not crash with assertion
+  expect(exitCode).not.toBe(0);
+  expect(output).toContain("error:");
+});
+
+test("parser should not crash with assertion error on labeled async function statement", async () => {
+  // Similar case: labeled statement with async function
+  const dir = tempDirWithFiles("parser-assertion-label", {
+    "input.js": `
+b: async function(first) {
+}
+`,
+  });
+
+  await using proc = Bun.spawn({
+    cmd: [bunExe(), "build", join(dir, "input.js")],
+    env: bunEnv,
+    cwd: dir,
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]);
+
+  const output = stderr + stdout;
+
+  // Should report parse errors, not crash
+  expect(exitCode).not.toBe(0);
+  expect(output).toContain("error:");
+});