Backtestsvuerun-20261005-124535#15465

Issue #15465 Merged fix PR # Run 5 Oct 2026 · run-20261005-124535 vuejs/core

[compiler-sfc] Typo 'exit' instead of 'leave' in estree-walker causes missing ASI guard and runtime error with consecutive awaits

Better

Our patch was judged better than the merged fix.

In this judgment, Patch B = our agent, Patch A = the merged fix.

The source change is identical in both patches: `exit` becomes `leave` in the estree-walker options in compileScript.ts. This fixes the root cause. `scope.pop()` now runs when a BlockStatement is left, so `needsSemi` is computed against the correct enclosing block, and consecutive awaits after a nested block get their `;` guard. Correctness is therefore equal, and the decision rests on tests and craft.

Patch A adds one test. It compiles a nested-block case, strips the import line with a regex, evaluates the output through `new Function` with a mocked `_withAsyncContext`, and checks that `setup` resolves. This would fail before the fix, because the missing semicolon makes `(...)(...)` call `undefined` and throw a TypeError. It directly reproduces the runtime symptom from the issue. However, it depends on the exact output shape: the import line format, the `genDefaultAs` binding, and the setup context. It also breaks from how the surrounding async/await tests are written.

Patch B adds two tests inside the existing `async/await detection` block using the established `assertAwaitDetection` helper and snapshots. One covers a nested `if` and the other a `for` inside a `while`. Each asserts that a `;(` precedes the second `_withAsyncContext` and that no bare `)(` juxtaposition appears. Both would fail before the fix, because the regex requiring `;` would not match. They cover two block-nesting shapes, not one. They also follow the file's conventions, and the snapshots make the expected output easy to read.

Both test suites are meaningful regression tests. Patch B fits the codebase better and covers more scenarios, without Patch A's ad-hoc evaluation approach, so it is the somewhat better patch overall.

The judge saw only the two patches, labelled A and B in random order, with issue links and version numbers removed. The reasoning above is shown verbatim.

Solve

6m 32s

Wall-clock time in the container

Full test suite

No new failures

3,721 passed · 6 skipped · 3,727 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

88vs 21 merged

Changed lines, ours vs merged

Vue version

3.5.40

Link to minimal reproduction

https://play.vuejs.org/#eNp9kk9PAyEQxb/KhIttUln/xYNumqjxoAc12ngiMevuuEVZIDBsa0y/u8M21h60J8j8HsN7A1/iwnvZJxRnoox10J4gIiU/VbYo4FDChf0Ei5GwgVfj6g8Y+RTnGIEcxNp5nMBrIpb0GMA7H6FJmCHNkUk7Vla/wYhCwjF8KQtQOxudQWlcO9rbbr3H2pWyw81HEmYLN2ixTqT73NPvG77GQLWoNEVlhxUegut0RBmQ2/Y4Ohyf/4eOMiqLdVCOWBJ23lSE07LR/XTGZsoi78piQ8REEAe1b7qV79FZntQQQ4nadV4bDPeeNPtU4mwdMLPKGLe4HWo5+uSnXs+x/vij/h6XuabEA3vF0KMSG0ZVaJHW+PrpDpe838DONcmwegd8zOl5hs6uZZfJNmx7Sze4vem8C6RtO4vXS0Ibf0Jlo1m5GvRK8He52hH91+6xPBnO8bPyFF8oPmPIXXmEp/JAHovVNzTb1oo=

Steps to reproduce

  1. Open the SFC Playground link.
  2. Click on the "JS" tab in the right panel to view the compiled output.
  3. Observe the compiled code for the two await statements.
  4. Notice that there is no semicolon (;) inserted between the two _withAsyncContext blocks.

What is expected?

  1. Open the SFC Playground link.
  2. Click on the "JS" tab in the right panel to view the compiled output.
  3. Observe the compiled code for the two await statements.
  4. Notice that there is no semicolon (;) inserted between the two _withAsyncContext blocks.

What is actually happening?

What is actually happening? *

The ASI guard (`;`) is missing. 

Because of this, the JavaScript engine interprets the second statement as a function call invoked on the result of the first statement, causing a runtime error: `TypeError: (...) is not a function`.

([temp,restore] = _withAsyncContext(() => Promise.resolve(1))),
await __temp,
__restore()
)( // <--- RUNTIME ERROR
([temp,restore] = _withAsyncContext(() => Promise.resolve(2))),
await __temp,
__restore()
)


### System Info

System:
OS: Linux 5.10 Debian GNU/Linux 11 (bullseye) 11 (bullseye)
CPU: (4) x64 AMD EPYC 9575F 64-Core Processor
Memory: 6.69 GB / 11.65 GB
Container: Yes
Shell: 5.1.4 - /bin/bash
Binaries:
Node: 24.14.1 - /root/.nvm/versions/node/v24.14.1/bin/node
Yarn: 1.22.22 - /root/.yarn/bin/yarn
npm: 11.11.0 - /root/.nvm/versions/node/v24.14.1/bin/npm
pnpm: 10.33.0 - /root/.nvm/versions/node/v24.14.1/bin/pnpm
Browsers:
Chrome: 150.0.7871.181
npmPackages:
vue: ^3.5.40 => 3.5.40


### Any additional comments?

**Root Cause:**
The bug is caused by a typo in the AST walker configuration inside `compiler-sfc`. The compiler uses `estree-walker` which expects the hooks `{ enter, leave }`. However, the code currently passes `{ enter, exit }`.

Since `exit` is not a valid hook in `estree-walker`, it is never called. Consequently, `scope.pop()` is never executed when leaving a `BlockStatement` (like the `if` block in the reproduction). This corrupts the `scope` stack, causing the `needsSemi` calculation to fail for all subsequent `AwaitExpression` nodes.

**Proposed Fix:**
Simply change `exit` to `leave` in the walker options:
  • exit(node2) {
  • leave(node2) { if (node2.type === "BlockStatement") scope.pop(); }

The two patches

Our patch+87 −1
packages/compiler-sfc/__tests__/__snapshots__/compileScript.spec.ts.snapindex 795f0ae88..faffa34eb 100644@@ -206,6 +206,64 @@ return { n, get x() { return x } } })" `; +exports[`SFC compile <script setup> > async/await detection > consecutive awaits after a nested block in loop should prepend semicolon 1`] = `+"import { withAsyncContext as _withAsyncContext } from 'vue'++export default {+  async setup(__props, { expose: __expose }) {+  __expose();++let __temp, __restore+while (ok) {+        for (const x of list) {+          foo(x)+        }+        ;(+  ([__temp,__restore] = _withAsyncContext(() => 1)),+  await __temp,+  __restore()+)+        ;(+  ([__temp,__restore] = _withAsyncContext(() => 2)),+  await __temp,+  __restore()+)+      }+return {  }+}++}"+`;++exports[`SFC compile <script setup> > async/await detection > consecutive awaits after a nested block should prepend semicolon 1`] = `+"import { withAsyncContext as _withAsyncContext } from 'vue'++export default {+  async setup(__props, { expose: __expose }) {+  __expose();++let __temp, __restore+if (ok) {+        if (a) {+          foo()+        }+        ;(+  ([__temp,__restore] = _withAsyncContext(() => 1)),+  await __temp,+  __restore()+)+        ;(+  ([__temp,__restore] = _withAsyncContext(() => 2)),+  await __temp,+  __restore()+)+      }+return {  }+}++}"+`;+ exports[`SFC compile <script setup> > async/await detection > expression statement 1`] = ` "import { withAsyncContext as _withAsyncContext } from 'vue' packages/compiler-sfc/__tests__/compileScript.spec.tsindex d54541019..8c549c256 100644@@ -960,6 +960,34 @@ describe('SFC compile <script setup>', () => {       assertAwaitDetection(`if (ok) { await foo } else { await bar }`)     }) +    test('consecutive awaits after a nested block should prepend semicolon', () => {+      const code = assertAwaitDetection(`if (ok) {+        if (a) {+          foo()+        }+        await 1+        await 2+      }`)+      expect(code).toMatch(+        /__restore\(\)\n\)\s*;\(\s*\(\[__temp,__restore\] = _withAsyncContext\(\(\) => 2\)\)/,+      )+      expect(code).not.toMatch(/__restore\(\)\n\)\s*\(/)+    })++    test('consecutive awaits after a nested block in loop should prepend semicolon', () => {+      const code = assertAwaitDetection(`while (ok) {+        for (const x of list) {+          foo(x)+        }+        await 1+        await 2+      }`)+      expect(code).toMatch(+        /__restore\(\)\n\)\s*;\(\s*\(\[__temp,__restore\] = _withAsyncContext\(\(\) => 2\)\)/,+      )+      expect(code).not.toMatch(/__restore\(\)\n\)\s*\(/)+    })+     test('multiple `if` nested statements', () => {       assertAwaitDetection(`if (ok) {         let a = 'foo'packages/compiler-sfc/src/compileScript.tsindex d2047c5b2..901196235 100644@@ -669,7 +669,7 @@ export function compileScript(             )           }         },-        exit(node: Node) {+        leave(node: Node) {           if (node.type === 'BlockStatement') scope.pop()         },       }) 
Merged fix · PR #+20 −1
packages/compiler-sfc/__tests__/compileScript.spec.tsindex d54541019..a1cc885cd 100644@@ -1026,6 +1026,25 @@ describe('SFC compile <script setup>', () => {         false,       )     })++    // #15465+    test('await statements after a nested block should be separated', async () => {+      const { content } = compile(+        `<script setup>+        if (true) {+          if (false) {}+          await Promise.resolve(1)+          await Promise.resolve(2)+        }+        </script>`,+        { genDefaultAs: '_sfc_' },+      )+      const component = new Function(+        '_withAsyncContext',+        `${content.replace(/^import .*\n/, '')};return _sfc_`,+      )((getAwaitable: () => unknown) => [getAwaitable(), () => {}])+      await expect(component.setup({}, { expose() {} })).resolves.toEqual({})+    })   })    describe('errors', () => {packages/compiler-sfc/src/compileScript.tsindex d2047c5b2..901196235 100644@@ -669,7 +669,7 @@ export function compileScript(             )           }         },-        exit(node: Node) {+        leave(node: Node) {           if (node.type === 'BlockStatement') scope.pop()         },       })