Backtestsvuerun-20261009-161443#15495

Issue #15495 Merged fix PR #15498 Run 9 Oct 2026 · run-20261009-161443 vuejs/core

[compiler-sfc] Top-level await inside switch case generates invalid code (missing semicolon before rewrite)

Better

Our patch was judged better than the merged fix.

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

The source changes are functionally identical. Both push `SwitchCase.consequent` onto the scope stack on enter and pop it on leave. That makes the `needsSemi` check see sibling statements inside a case branch, which is the root cause named in the issue. The only source difference is brace style in `leave`, which doesn't matter. The deciding factor is the tests. Patch A compiles the SFC, actually runs `setup()` with a stubbed `_withAsyncContext`, and checks execution order through a `calls` array. That proves the generated code behaves correctly at runtime, not just that a `;` appears in the output. Patch A also covers the variants the issue lists: an await after an expression statement in a case, consecutive awaits in one case (the `(...)(...)` problem the issue calls out), an await as the first statement of a case (should get no prefix), and a root-level await after a switch (checks the scope stack is popped correctly). Each of these would fail or misbehave before the fix. Patch B adds two snapshot tests with a regex for `;(`, covering the basic case and the nested-in-`if` case from the issue. They are valid regression tests but only check the text shape. They skip the consecutive-awaits variant and the scope-restoration edge cases, and they add snapshot churn. With equal correctness, Patch A's broader, behavior-level tests make it the better patch.

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

4m 9s

Wall-clock time in the container

Full test suite

No new failures

637 passed · 1 skipped · 638 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

79vs 76 merged

Changed lines, ours vs merged

[compiler-sfc] Top-level await inside switch case generates invalid code (missing semicolon before rewrite)

Vue version

3.5.42 — also reproduced on main (5409708)

Link to minimal reproduction

https://play.vuejs.org/#N4IgbgpgTgzglgewHYgFwgMwDoCsWAsATCADQgBmcANhDGqDFAMYD0AggA4dZgCuE9EE2QAXCEhFoQAHjEBbDlQCGYgHwAdJAAIt0gCZwwqqBA5QE0lgaObL8xSogaktmEyhwOIrTAgjeHM5wCghQ3sBaJuRaAL5a5OZyWgDkfBDJmprCSDDeSloAvJEQ5AAUIlD8AJRZyLlaAEaFxWUAjDUuSOS8SEwiiNoAjrwAHqVVWsCaOiwsxf5QOVo9eiVwSBB6WshaHLxQHAi+mjGZSEowAJ698T19A41KUOOT0-P72kQnZ3DRpUo8JRUaqvbQ+ADucBETAAFlpSg1AcCIBMpmCdEwLhAtK1UG8dDphmMOgSCUpwUooY9niTYt8kJY3B4vM5SCA4DA2PdIGgKvwYmRGKw5JSkFgRHRUKBsmIJFJgocwpMtO4II5OBxYvFEik0hkkArQt4NdqEElklh2FwePx9VkTOquKUNVUsHIED0RKVkgBiJRcZIdNkcrn9HmoPkQGICkAILwDSXAaNAA

Steps to reproduce

  1. Open the playground link above (or compile the SFC below with @vue/compiler-sfc).
  2. The component setup() throws TypeError: object is not iterable (cannot read property Symbol(Symbol.iterator)).

SFC:

<script setup>
const a = true
const b = 1
function qux() {}
async function bar() { return 42 }
if (a) {
  switch (b) {
    case 1:
      qux()
      await bar()
  }
}
</script>

What is expected?

The compiled setup() should run fine: qux() and await bar() should be two independent statements.

What is actually happening?

The top-level await rewrite in compileScript emits the withAsyncContext wrapper expression without a leading semicolon when the await is inside a switch case that is not the first statement:

async setup(__props, { expose: __expose }) {
  ...
  if (a) {
    switch (b) {
      case 1:
        qux()
        (
  ([__temp,__restore] = _withAsyncContext(() => bar())),
  await __temp,
  __restore()
)
    }
  }
}

Because the next line starts with (, ASI does not insert a semicolon, so the two lines are parsed as a single call expression qux()(...). bar() is never awaited in the intended way and the runtime throws TypeError: object is not iterable.

The same code inside a plain block (not a switch) is compiled correctly with a leading ;:

if (a) {
  qux()
  ;(
  ([__temp,__restore] = _withAsyncContext(() => bar())),
  await __temp,
  __restore()
)
}

Additional comments

Root cause: in packages/compiler-sfc/src/compileScript.ts, the scope stack used to decide whether the rewrite needs a semicolon only pushes/pops on BlockStatement. A switch statement's SwitchCase.consequent statement list is not tracked, so needsSemi is misjudged as false for await expressions inside case branches (unless the await happens to be the very first statement of the case).

Related variants also affected:

  • Two consecutive top-level awaits inside one case produce (...)(...) back-to-back (second one also parsed as a call of the first result).
  • Any await that follows an expression statement inside a case branch.

No prior issue found for this.

The two patches

Our patch+78 −1
packages/compiler-sfc/__tests__/compileScript.spec.tsindex a1cc885cd..3eb6e34ef 100644@@ -1045,6 +1045,80 @@ describe('SFC compile <script setup>', () => {       )((getAwaitable: () => unknown) => [getAwaitable(), () => {}])       await expect(component.setup({}, { expose() {} })).resolves.toEqual({})     })++    describe('await statements inside switch cases', () => {+      async function runSetup(code: string) {+        const { content } = compile(`<script setup>${code}</script>`, {+          genDefaultAs: '_sfc_',+        })+        const calls: string[] = []+        const component = new Function(+          '_withAsyncContext',+          'calls',+          `${content.replace(/^import .*\n/, '')};return _sfc_`,+        )((getAwaitable: () => unknown) => [getAwaitable(), () => {}], calls)+        await component.setup({}, { expose() {} })+        return { content, calls }+      }++      test('await after an expression statement in a case', async () => {+        const { content, calls } = await runSetup(`+        const b = 1+        function qux() { calls.push('qux') }+        async function bar() { calls.push('bar') }+        if (true) {+          switch (b) {+            case 1:+              qux()+              await bar()+          }+        }+        `)+        expect(content).toMatch(`qux()\n              ;(`)+        expect(calls).toEqual(['qux', 'bar'])+      })++      test('consecutive awaits in a case', async () => {+        const { calls } = await runSetup(`+        switch (1) {+          case 1:+            await Promise.resolve(calls.push('a'))+            await Promise.resolve(calls.push('b'))+            break+          default:+            await Promise.resolve(calls.push('c'))+        }+        `)+        expect(calls).toEqual(['a', 'b'])+      })++      test('await as first statement of a case is not prefixed', async () => {+        const { content, calls } = await runSetup(`+        switch (1) {+          case 1:+            await Promise.resolve(calls.push('a'))+        }+        `)+        expect(content).not.toMatch(`case 1:\n            ;(`)+        expect(calls).toEqual(['a'])+      })++      test('await after a switch statement at the root', async () => {+        const { content, calls } = await runSetup(`+        function qux() { calls.push('qux') }+        switch (1) {+          case 1: {+            qux()+            await Promise.resolve(calls.push('a'))+          }+        }+        qux()+        await Promise.resolve(calls.push('b'))+        `)+        expect(content).toMatch(`qux()\n        ;(`)+        expect(calls).toEqual(['qux', 'a', 'qux', 'b'])+      })+    })   })    describe('errors', () => {packages/compiler-sfc/src/compileScript.tsindex 901196235..9337d5cd1 100644@@ -646,6 +646,8 @@ export function compileScript(           }           if (child.type === 'BlockStatement') {             scope.push(child.body)+          } else if (child.type === 'SwitchCase') {+            scope.push(child.consequent)           }           if (child.type === 'AwaitExpression') {             hasAwait = true@@ -670,7 +672,8 @@ export function compileScript(           }         },         leave(node: Node) {-          if (node.type === 'BlockStatement') scope.pop()+          if (node.type === 'BlockStatement' || node.type === 'SwitchCase')+            scope.pop()         },       })     } 
Merged fix · PR #15498+75 −1
packages/compiler-sfc/__tests__/__snapshots__/compileScript.spec.ts.snapindex 795f0ae88..c718e7690 100644@@ -206,6 +206,54 @@ return { n, get x() { return x } } })" `; +exports[`SFC compile <script setup> > async/await detection > await in switch case 1`] = `+"import { withAsyncContext as _withAsyncContext } from 'vue'++export default {+  async setup(__props, { expose: __expose }) {+  __expose();++let __temp, __restore+switch (a) {+        case 1:+          foo()+          ;(+  ([__temp,__restore] = _withAsyncContext(() => bar())),+  await __temp,+  __restore()+)+      }+return {  }+}++}"+`;++exports[`SFC compile <script setup> > async/await detection > await in switch case nested in a block 1`] = `+"import { withAsyncContext as _withAsyncContext } from 'vue'++export default {+  async setup(__props, { expose: __expose }) {+  __expose();++let __temp, __restore+if (a) {+        switch (b) {+          case 1:+            qux()+            ;(+  ([__temp,__restore] = _withAsyncContext(() => bar())),+  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 a1cc885cd..caaae92b4 100644@@ -960,6 +960,28 @@ describe('SFC compile <script setup>', () => {       assertAwaitDetection(`if (ok) { await foo } else { await bar }`)     }) +    // #15495+    test('await in switch case', () => {+      const code = assertAwaitDetection(`switch (a) {+        case 1:+          foo()+          await bar()+      }`)+      expect(code).toMatch(/foo\(\)\s*;\(/)+    })++    // #15495+    test('await in switch case nested in a block', () => {+      const code = assertAwaitDetection(`if (a) {+        switch (b) {+          case 1:+            qux()+            await bar()+        }+      }`)+      expect(code).toMatch(/qux\(\)\s*;\(/)+    })+     test('multiple `if` nested statements', () => {       assertAwaitDetection(`if (ok) {         let a = 'foo'packages/compiler-sfc/src/compileScript.tsindex 901196235..3c070a0e0 100644@@ -646,6 +646,8 @@ export function compileScript(           }           if (child.type === 'BlockStatement') {             scope.push(child.body)+          } else if (child.type === 'SwitchCase') {+            scope.push(child.consequent)           }           if (child.type === 'AwaitExpression') {             hasAwait = true@@ -670,7 +672,9 @@ export function compileScript(           }         },         leave(node: Node) {-          if (node.type === 'BlockStatement') scope.pop()+          if (node.type === 'BlockStatement' || node.type === 'SwitchCase') {+            scope.pop()+          }         },       })     }