Backtestsvuerun-20261021-133314#15126

Issue #15126 Merged fix PR #15136 Run 21 Oct 2026 · run-20261021-133314 vuejs/core

compileScript drops template imports from returned when analysis re-runs on a transformed template AST

Worse

The merged fix was judged better than our patch.

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

Both patches fix the root cause the same way: when the shared descriptor's template AST has already been transformed in place by compileTemplate, the import-usage/v-model analysis re-parses the SFC source instead of walking the mutated tree, mirroring the existing guard in compileTemplate. Both pass the five core independent tests (expression, v-for, components/directives, v-model demotion, 600-file cache eviction).

The deciding difference is correctness of the re-parse. Patch B always calls compiler-dom's parse with default options, ignoring any template compiler options. The descriptor's original AST was parsed with the user's templateParseOptions (e.g. custom delimiters, custom compiler, isCustomElement), so B's re-parsed AST can differ from the <500 case, which is precisely the issue's expectation ("same output as when fewer than 500 templates are compiled"). The independent custom-delimiters test confirms this: B still drops the import (FAIL-EXC) while A passes. Patch A threads options.templateOptions (compiler, compilerOptions, ssr) into the analysis and reuses one shared resolveTemplateAST helper for both compileTemplate and the analysis, so the re-parse uses the same configuration compileTemplate itself uses; plugin-vue does pass templateOptions to compileScript, so this holds in the real scenario.

Tests: B's tests are more direct and cover more cases (v-for, v-model, recoverable parse error), while A's test exports the cache to simulate eviction and specifically covers custom delimiters. Both tests fail before and pass after. Scope: A's refactor of compileTemplate into a shared helper is small churn but reduces duplication and keeps the two guards consistent; exporting templateAnalysisCache for tests is a minor wart. Craft is comparable. The remaining correctness gap in B with non-default parser options outweighs its somewhat better test coverage, so A is the better fix.

Four judges ruled on this ticket in parallel, and the verdict comes from counting their votes. Each saw the issue and the two patches, labelled A and B in random order (two of them saw ours as A), with issue links and version numbers removed. Where tests could check the fix, they also saw the results of tests a separate agent wrote for the issue, run on both patches. None was told which patch was ours. The reasoning above is one judge's, shown verbatim.

Solve

6m 6s

Wall-clock time in the container

Full test suite

No new failures

619 passed · 1 skipped · 620 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

96vs 173 merged

Changed lines, ours vs merged

Vue version

3.5.40

Link to minimal reproduction

https://stackblitz.com/edit/vitejs-vite-evwepvbu?file=package.json

Steps to reproduce

Compile more than 500 unique SFCs for client + SSR (non-inline mode), share each file's descriptor between the two passes (the same way @vitejs/plugin-vue does). The client pass compileTemplate changes the shared template.ast in place, when the analysis cache (capped at 500) evicts a file entry, its SSR compileScript pass re-runs the import usage analysis on that already transformed AST

What is expected?

__returned__ contains every import the template references, same output as when fewer than 500 templates are compiled. The analysis should re-parse when the AST was already transformed, the same guard compileTemplate has with if (inAST?.transformed) in line 214.

What is actually happening?

Imports referenced only from template expressions or with v-for are dropped from __returned__. While the render function still emits $setup.foo(...) and throws TypeError: $setup.foo is not a function at runtime. Because it only happens with more than 500 unique templates it only comes up in large apps in development, in production builds the template are inlined and are unaffected.

System Info

Any additional comments?

Might be the cause for vitejs/vite-plugin-vue#764, vitest-dev/vitest#9855?

The two patches

Our patch+95 −1
packages/compiler-sfc/__tests__/compileScript/importUsageCheck.spec.tsindex 210fa0968..6b5943411 100644@@ -1,3 +1,5 @@+import { BindingTypes } from '@vue/compiler-core'+import { compileScript, compileTemplate, parse } from '../../src' import { assertCode, compileSFCScript as compile } from '../utils'  // in dev mode, declared bindings are returned as an object from setup()@@ -265,3 +267,67 @@ test('shorthand binding w/ kebab-case', () => {   )   expect(content).toMatch('return { get fooBar() { return fooBar }') })++describe('template AST already transformed by compileTemplate', () => {+  // e.g. @vitejs/plugin-vue shares the descriptor between the client and SSR+  // passes: the client compileTemplate transforms `template.ast` in place, and+  // once the analysis cache entry is evicted the SSR compileScript pass must+  // not analyze that transformed AST.+  function compileAfterTemplate(src: string) {+    const { descriptor } = parse(src)+    compileTemplate({+      id: 'xxx',+      filename: 'test.vue',+      ast: descriptor.template!.ast,+      source: descriptor.template!.content,+      compilerOptions: { bindingMetadata: {} },+    })+    expect(descriptor.template!.ast!.transformed).toBe(true)+    return compileScript(descriptor, { id: 'xxx' })+  }++  test('imports used in template expressions and v-for', () => {+    const { content } = compileAfterTemplate(`+      <script setup lang="ts">+        import { formatTransformed, itemsTransformed, Unused } from './x'+      </script>+      <template>+        <div v-for="item in itemsTransformed()">{{ formatTransformed(item) }}</div>+      </template>+    `)+    expect(content).toMatch(+      'return { get formatTransformed() { return formatTransformed }, ' ++        'get itemsTransformed() { return itemsTransformed } }',+    )+  })++  test('v-model target demotion', () => {+    const { content, bindings } = compileAfterTemplate(`+      <script setup>+        import { reactive } from 'vue'+        const nameTransformed = reactive({ first: 'john' })+      </script>+      <template>+        <MyComponent v-model="nameTransformed" />+      </template>+    `)+    expect(content).toMatch(+      `let nameTransformed = reactive({ first: 'john' })`,+    )+    expect(bindings!.nameTransformed).toBe(BindingTypes.SETUP_LET)+  })++  test('template with recoverable parse errors', () => {+    const { content } = compileAfterTemplate(`+      <script setup lang="ts">+        import { fooWithError } from './x'+      </script>+      <template>+        <div>{{ fooWithError() }}+      </template>+    `)+    expect(content).toMatch(+      'return { get fooWithError() { return fooWithError } }',+    )+  })+})packages/compiler-sfc/src/script/importUsageCheck.tsindex 9c087b466..57c59ce0f 100644@@ -1,10 +1,14 @@ import type { SFCDescriptor } from '../parse' import {+  type ElementNode,   type ExpressionNode,   NodeTypes,+  type RootNode,   type SimpleExpressionNode,   type TemplateChildNode,+  createRoot,   isSimpleIdentifier,+  parse,   parserOptions,   walkIdentifiers, } from '@vue/compiler-dom'@@ -53,7 +57,7 @@ function resolveTemplateAnalysisResult(   const ids = collectUsedIds ? new Set<string>() : undefined   const vModelIds = new Set<string>() -  ast!.children.forEach(walk)+  resolveUntransformedAST(ast!).children.forEach(walk)    function walk(node: TemplateChildNode) {     switch (node.type) {@@ -134,6 +138,30 @@ function resolveTemplateAnalysisResult(   return result } +/**+ * The descriptor's template AST is shared with compileTemplate, which+ * transforms it in place (rewriting expressions, v-for, props etc.). If that+ * has already happened, the analysis must run on a freshly parsed AST, the same+ * way compileTemplate re-parses an already transformed input AST.+ */+function resolveUntransformedAST(ast: RootNode): RootNode {+  if (!ast.transformed) {+    return ast+  }+  // parse the full SFC source so that location info stays consistent with+  // the descriptor's AST+  const newAST = parse(ast.source, {+    prefixIdentifiers: true,+    parseMode: 'sfc',+    // errors were already reported when the descriptor was parsed+    onError: () => {},+  })+  const template = newAST.children.find(+    node => node.type === NodeTypes.ELEMENT && node.tag === 'template',+  ) as ElementNode+  return createRoot(template.children, ast.source)+}+ function extractIdentifiers(ids: Set<string>, node: ExpressionNode) {   if (node.ast) {     walkIdentifiers(node.ast, n => ids.add(n.name)) 
Merged fix · PR #15136+137 −36
packages/compiler-sfc/__tests__/compileScript.spec.tsindex 5e547f6b2..d54541019 100644@@ -7,6 +7,8 @@ import {   mockId, } from './utils' import { type RawSourceMap, SourceMapConsumer } from 'source-map-js'+import { compileScript, compileTemplate, parse } from '../src'+import { templateAnalysisCache } from '../src/script/importUsageCheck'  vi.mock('../src/warn', () => ({   warn: vi.fn(),@@ -345,6 +347,43 @@ describe('SFC compile <script setup>', () => {       expect(content).toMatch(`import { useCssVars, ref } from 'vue'`)     }) +    test('should re-analyze a transformed template after cache invalidation', () => {+      const delimiters: [string, string] = ['[[', ']]']+      const { descriptor } = parse(+        `+        <script setup lang="ts">+        import { cachedMsg } from './cachedMsg'+        </script>+        <template><p>[[ cachedMsg ]]</p></template>+        `,+        { templateParseOptions: { delimiters } },+      )++      const templateOptions = { compilerOptions: { delimiters } }+      compileScript(descriptor, { id: mockId, templateOptions })+      expect(templateAnalysisCache.has(descriptor.template!.content)).toBe(true)++      compileTemplate({+        filename: 'example.vue',+        id: mockId,+        source: descriptor.template!.content,+        ast: descriptor.template!.ast,+        compilerOptions: { delimiters },+      })+      expect(descriptor.template!.ast!.transformed).toBe(true)++      templateAnalysisCache.clear()+      expect(templateAnalysisCache.has(descriptor.template!.content)).toBe(+        false,+      )++      const { content } = compileScript(descriptor, {+        id: mockId,+        templateOptions,+      })+      expect(content).toMatch(`return { get cachedMsg() { return cachedMsg } }`)+    })+     test('import dedupe between <script> and <script setup>', () => {       const { content } = compile(`         <script>packages/compiler-sfc/src/compileScript.tsindex a60aba17a..d2047c5b2 100644@@ -266,7 +266,7 @@ export function compileScript(       !sfc.template.src &&       !sfc.template.lang     ) {-      isUsedInTemplate = isImportUsed(local, sfc)+      isUsedInTemplate = isImportUsed(local, sfc, options.templateOptions)     }      ctx.userImports[local] = {@@ -769,7 +769,10 @@ export function compileScript(   // which requires a SETUP_LET binding (getter + setter) to keep script state in sync.   // In inline mode, it generates `foo = $event`, which also requires `let`.   if (sfc.template && !sfc.template.src && sfc.template.ast) {-    const vModelIds = resolveTemplateVModelIdentifiers(sfc)+    const vModelIds = resolveTemplateVModelIdentifiers(+      sfc,+      options.templateOptions,+    )     if (vModelIds.size) {       const toDemote = new Set<string>()       for (const id of vModelIds) {packages/compiler-sfc/src/compileTemplate.tsindex b043cf813..6c8ad3988 100644@@ -1,14 +1,11 @@-import {-  type CodegenResult,-  type CompilerError,-  type CompilerOptions,-  type ElementNode,-  type NodeTransform,-  NodeTypes,-  type ParserOptions,-  type RawSourceMap,-  type RootNode,-  createRoot,+import type {+  CodegenResult,+  CompilerError,+  CompilerOptions,+  NodeTransform,+  ParserOptions,+  RawSourceMap,+  RootNode, } from '@vue/compiler-core' import { SourceMapConsumer, SourceMapGenerator } from 'source-map-js' import {@@ -28,6 +25,7 @@ import * as CompilerSSR from '@vue/compiler-ssr' import consolidate from '@vue/consolidate' import { warnOnce } from './warn' import { genCssVarsFromList } from './style/cssVars'+import { resolveTemplateAST } from './template/resolveTemplateAST'  export interface TemplateCompiler {   compile(source: string | RootNode, options: CompilerOptions): CodegenResult@@ -211,21 +209,12 @@ function doCompileTemplate({     inAST = undefined   } -  if (inAST?.transformed) {-    // If input AST has already been transformed, then it cannot be reused.-    // We need to parse a fresh one. Can't just use `source` here since we need-    // the AST location info to be relative to the entire SFC.-    const newAST = (ssr ? CompilerDOM : compiler).parse(inAST.source, {-      prefixIdentifiers: true,-      ...compilerOptions,-      parseMode: 'sfc',-      onError: e => errors.push(e),-    })-    const template = newAST.children.find(-      node => node.type === NodeTypes.ELEMENT && node.tag === 'template',-    ) as ElementNode-    inAST = createRoot(template.children, inAST.source)-  }+  inAST = resolveTemplateAST(inAST, {+    compiler,+    compilerOptions,+    ssr,+    onError: e => errors.push(e),+  })    let { code, ast, preamble, map } = compiler.compile(inAST || source, {     mode: 'module',packages/compiler-sfc/src/script/importUsageCheck.tsindex 9c087b466..fa16a1adc 100644@@ -1,4 +1,5 @@ import type { SFCDescriptor } from '../parse'+import type { SFCTemplateCompileOptions } from '../compileTemplate' import {   type ExpressionNode,   NodeTypes,@@ -8,36 +9,57 @@ import {   parserOptions,   walkIdentifiers, } from '@vue/compiler-dom'+import type { LRUCache } from 'lru-cache' import { createCache } from '../cache' import { camelize, capitalize, isBuiltInDirective } from '@vue/shared'+import { resolveTemplateAST } from '../template/resolveTemplateAST'++type TemplateOptions = Pick<+  SFCTemplateCompileOptions,+  'compiler' | 'compilerOptions' | 'ssr'+>  /**  * Check if an import is used in the SFC's template. This is used to determine  * the properties that should be included in the object returned from setup()  * when not using inline mode.  */-export function isImportUsed(local: string, sfc: SFCDescriptor): boolean {-  return resolveTemplateUsedIdentifiers(sfc).has(local)+export function isImportUsed(+  local: string,+  sfc: SFCDescriptor,+  options?: TemplateOptions,+): boolean {+  return resolveTemplateUsedIdentifiers(sfc, options).has(local) } -const templateAnalysisCache = createCache<{+type TemplateAnalysisResult = {   usedIds?: Set<string>   vModelIds: Set<string>-}>()+}++export const templateAnalysisCache:+  | Map<string, TemplateAnalysisResult>+  | LRUCache<string, TemplateAnalysisResult> =+  createCache<TemplateAnalysisResult>()  export function resolveTemplateVModelIdentifiers(   sfc: SFCDescriptor,+  options?: TemplateOptions, ): Set<string> {-  return resolveTemplateAnalysisResult(sfc, false).vModelIds+  return resolveTemplateAnalysisResult(sfc, false, options).vModelIds } -function resolveTemplateUsedIdentifiers(sfc: SFCDescriptor): Set<string> {-  return resolveTemplateAnalysisResult(sfc).usedIds!+function resolveTemplateUsedIdentifiers(+  sfc: SFCDescriptor,+  options?: TemplateOptions,+): Set<string> {+  return resolveTemplateAnalysisResult(sfc, true, options).usedIds! }  function resolveTemplateAnalysisResult(   sfc: SFCDescriptor,   collectUsedIds = true,+  options?: TemplateOptions, ): {   usedIds?: Set<string>   vModelIds: Set<string>@@ -53,7 +75,15 @@ function resolveTemplateAnalysisResult(   const ids = collectUsedIds ? new Set<string>() : undefined   const vModelIds = new Set<string>() -  ast!.children.forEach(walk)+  const root = resolveTemplateAST(ast, {+    compiler: options?.compiler,+    compilerOptions: options?.compilerOptions,+    ssr: options?.ssr,+    // ignore errors since they were already reported by the SFC parser+    onError: () => {},+  })++  root!.children.forEach(walk)    function walk(node: TemplateChildNode) {     switch (node.type) {packages/compiler-sfc/src/template/resolveTemplateAST.tsnew file mode 100644index 000000000..b2897e56d@@ -0,0 +1,40 @@+import {+  type CompilerError,+  type ElementNode,+  NodeTypes,+  type ParserOptions,+  type RootNode,+  createRoot,+} from '@vue/compiler-core'+import * as CompilerDOM from '@vue/compiler-dom'++interface TemplateParser {+  parse(template: string, options: ParserOptions): RootNode+}++export function resolveTemplateAST(+  inAST: RootNode | undefined,+  options: {+    compiler?: TemplateParser+    compilerOptions?: ParserOptions+    ssr?: boolean+    onError: (error: CompilerError) => void+  },+): RootNode | undefined {+  if (!inAST?.transformed) {+    return inAST+  }++  // Parse the full SFC source to preserve template locations relative to it.+  const { compiler = CompilerDOM, compilerOptions, ssr, onError } = options+  const newAST = (ssr ? CompilerDOM : compiler).parse(inAST.source, {+    prefixIdentifiers: true,+    ...compilerOptions,+    parseMode: 'sfc',+    onError,+  })+  const template = newAST.children.find(+    node => node.type === NodeTypes.ELEMENT && node.tag === 'template',+  ) as ElementNode+  return createRoot(template.children, inAST.source)+}