Backtestsvuerun-20261003-231210#15126

Issue #15126 Merged fix PR #15136 Run 3 Oct 2026 · run-20261003-231210 vuejs/core

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

Better

Our patch was judged better than the merged fix.

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

Both patches fix the root cause the same way. When the descriptor's template AST is already `transformed`, the import-usage and v-model analysis now re-parses the template source in `sfc` mode with `prefixIdentifiers`, passing the user's compiler options (e.g. delimiters) through from compileScript. This mirrors the guard in compileTemplate, so both hold up under the cache-eviction scenario in the issue.

Patch A covers one more path. It also threads `templateParseOptions` into `hmrShouldReload`/`shouldForceReload`, which calls `isImportUsed` and can hit the same transformed-AST path. Patch B leaves that call without options, so a transformed AST using custom delimiters would be re-parsed incorrectly there.

Patch B's advantages:
- It extracts a shared `resolveTemplateAST` helper and reuses it in compileTemplate, removing duplication.
- It honors a custom `compiler` for non-SSR parsing.

The cost is extra churn in compileTemplate, and it exports the internal `templateAnalysisCache` only so the test can clear it. These are craft trade-offs, not correctness wins.

On tests, A is clearly stronger. Its tests directly exercise the issue's cases on an AST transformed by compileTemplate:
- imports used in template expressions and in v-for
- v-model demotion to `let`
- delimiter-aware re-parse
- HMR comparison, with and without parse options

B has a single test covering a delimiter interpolation after manually clearing the cache. It is valid but does not cover the v-for case the issue highlights.

Overall, A is equally correct on the main path, more complete on HMR, and better tested.

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

7m 51s

Wall-clock time in the container

Full test suite

No new failures

3,639 passed · 6 skipped · 3,645 total

Contamination audit

Clean

No sign the agent saw the real fix

Patch size

209vs 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+198 −11
packages/compiler-sfc/__tests__/compileScript/importUsageCheck.spec.tsindex 210fa0968..a01dbbc16 100644@@ -1,4 +1,5 @@-import { assertCode, compileSFCScript as compile } from '../utils'+import { compileScript, compileTemplate, parse } from '../../src'+import { assertCode, compileSFCScript as compile, mockId } from '../utils'  // in dev mode, declared bindings are returned as an object from setup() // when using TS, users may import types which should not be returned as@@ -265,3 +266,137 @@ test('shorthand binding w/ kebab-case', () => {   )   expect(content).toMatch('return { get fooBar() { return fooBar }') })++describe('template AST already transformed by compileTemplate', () => {+  // simulates a descriptor shared between the client and SSR passes (as+  // @vitejs/plugin-vue does): the client compileTemplate transforms the shared+  // AST in place before the SSR compileScript runs its usage analysis.+  function compileAfterTemplate(+    src: string,+    templateCompilerOptions?: Record<string, any>,+  ) {+    const { descriptor } = parse(src)+    compileTemplate({+      id: mockId,+      filename: descriptor.filename,+      source: descriptor.template!.content,+      ast: descriptor.template!.ast,+      compilerOptions: templateCompilerOptions,+    })+    expect(descriptor.template!.ast!.transformed).toBe(true)+    return compileScript(descriptor, {+      id: mockId,+      templateOptions: {+        ssr: true,+        compilerOptions: templateCompilerOptions,+      },+    })+  }++  test('imports used in expressions and v-for', () => {+    const { content } = compileAfterTemplate(`+    <script setup lang="ts">+      import { transformedFoo, transformedList, transformedFmt } from './x'+    </script>+    <template>+      <div :title="transformedFoo()">{{ transformedFmt(1) }}</div>+      <span v-for="item in transformedList" :key="item">{{ item }}</span>+    </template>+    `)+    expect(content).toMatch(`get transformedFoo() { return transformedFoo }`)+    expect(content).toMatch(`get transformedList() { return transformedList }`)+    expect(content).toMatch(`get transformedFmt() { return transformedFmt }`)+  })++  test('v-model target reactive is still demoted to let', () => {+    const { content } = compileAfterTemplate(`+    <script setup lang="ts">+      import { reactive } from 'vue'+      const transformedModel = reactive({})+    </script>+    <template>+      <input v-model="transformedModel">+    </template>+    `)+    expect(content).toMatch(`let transformedModel = reactive({})`)+  })++  test('re-parse respects template compiler options (delimiters)', () => {+    const { content } = compileAfterTemplate(+      `+    <script setup lang="ts">+      import { transformedDelim } from './x'+    </script>+    <template>+      <div>[[ transformedDelim ]]</div>+    </template>+    `,+      { delimiters: ['[[', ']]'] },+    )+    expect(content).toMatch(+      `get transformedDelim() { return transformedDelim }`,+    )+  })++  test('hmr import usage comparison', () => {+    const prev = parse(`+    <script setup lang="ts">+      import { transformedHmr } from './x'+    </script>+    <template><div /></template>+    `).descriptor+    const prevImports = compileScript(prev, { id: mockId }).imports!+    expect(prevImports.transformedHmr.isUsedInTemplate).toBe(false)++    const { descriptor: next } = parse(`+    <script setup lang="ts">+      import { transformedHmr } from './x'+    </script>+    <template><div>{{ transformedHmr() }}</div></template>+    `)+    compileTemplate({+      id: mockId,+      filename: next.filename,+      source: next.template!.content,+      ast: next.template!.ast,+    })+    expect(next.template!.ast!.transformed).toBe(true)+    expect(next.shouldForceReload(prevImports)).toBe(true)+  })++  test('hmr import usage comparison respects templateParseOptions', () => {+    const templateParseOptions = {+      delimiters: ['[[', ']]'] as [string, string],+    }+    const prev = parse(+      `+    <script setup lang="ts">+      import { transformedHmrDelim } from './x'+    </script>+    <template><div /></template>+    `,+      { templateParseOptions },+    ).descriptor+    const prevImports = compileScript(prev, { id: mockId }).imports!+    expect(prevImports.transformedHmrDelim.isUsedInTemplate).toBe(false)++    const { descriptor: next } = parse(+      `+    <script setup lang="ts">+      import { transformedHmrDelim } from './x'+    </script>+    <template><div>[[ transformedHmrDelim() ]]</div></template>+    `,+      { templateParseOptions },+    )+    compileTemplate({+      id: mockId,+      filename: next.filename,+      source: next.template!.content,+      ast: next.template!.ast,+      compilerOptions: templateParseOptions,+    })+    expect(next.template!.ast!.transformed).toBe(true)+    expect(next.shouldForceReload(prevImports)).toBe(true)+  })+})packages/compiler-sfc/src/compileScript.tsindex a60aba17a..f46b5eb7a 100644@@ -266,7 +266,11 @@ export function compileScript(       !sfc.template.src &&       !sfc.template.lang     ) {-      isUsedInTemplate = isImportUsed(local, sfc)+      isUsedInTemplate = isImportUsed(+        local,+        sfc,+        options.templateOptions?.compilerOptions,+      )     }      ctx.userImports[local] = {@@ -769,7 +773,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?.compilerOptions,+    )     if (vModelIds.size) {       const toDemote = new Set<string>()       for (const id of vModelIds) {packages/compiler-sfc/src/parse.tsindex b45ea7ab7..0d903ca73 100644@@ -137,7 +137,8 @@ export function parse(     customBlocks: [],     cssVars: [],     slotted: false,-    shouldForceReload: prevImports => hmrShouldReload(prevImports, descriptor),+    shouldForceReload: prevImports =>+      hmrShouldReload(prevImports, descriptor, templateParseOptions),   }    const errors: (CompilerError | SyntaxError)[] = []@@ -435,6 +436,7 @@ function isEmpty(node: ElementNode) { export function hmrShouldReload(   prevImports: Record<string, ImportBinding>,   next: SFCDescriptor,+  templateParseOptions?: ParserOptions, ): boolean {   if (     !next.scriptSetup ||@@ -448,7 +450,10 @@ export function hmrShouldReload(   for (const key in prevImports) {     // if an import was previous unused, but now is used, we need to force     // reload so that the script now includes that import.-    if (!prevImports[key].isUsedInTemplate && isImportUsed(key, next)) {+    if (+      !prevImports[key].isUsedInTemplate &&+      isImportUsed(key, next, templateParseOptions)+    ) {       return true     }   }packages/compiler-sfc/src/script/importUsageCheck.tsindex 9c087b466..50df90f30 100644@@ -1,10 +1,15 @@ import type { SFCDescriptor } from '../parse' import {+  type ElementNode,   type ExpressionNode,   NodeTypes,+  type ParserOptions,+  type RootNode,   type SimpleExpressionNode,   type TemplateChildNode,+  createRoot,   isSimpleIdentifier,+  parse,   parserOptions,   walkIdentifiers, } from '@vue/compiler-dom'@@ -16,8 +21,12 @@ import { camelize, capitalize, isBuiltInDirective } from '@vue/shared'  * 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,+  parseOptions?: ParserOptions,+): boolean {+  return resolveTemplateUsedIdentifiers(sfc, parseOptions).has(local) }  const templateAnalysisCache = createCache<{@@ -27,17 +36,48 @@ const templateAnalysisCache = createCache<{  export function resolveTemplateVModelIdentifiers(   sfc: SFCDescriptor,+  parseOptions?: ParserOptions,+): Set<string> {+  return resolveTemplateAnalysisResult(sfc, false, parseOptions).vModelIds+}++function resolveTemplateUsedIdentifiers(+  sfc: SFCDescriptor,+  parseOptions?: ParserOptions, ): Set<string> {-  return resolveTemplateAnalysisResult(sfc, false).vModelIds+  return resolveTemplateAnalysisResult(sfc, true, parseOptions).usedIds! } -function resolveTemplateUsedIdentifiers(sfc: SFCDescriptor): Set<string> {-  return resolveTemplateAnalysisResult(sfc).usedIds!+/**+ * The descriptor's template AST may be shared with `compileTemplate`, which+ * transforms it in place (e.g. expressions get prefixed and v-for nodes are+ * replaced). A transformed AST cannot be analyzed, so parse a fresh one.+ */+function resolveAnalyzableAST(+  ast: RootNode,+  parseOptions?: ParserOptions,+): RootNode {+  if (!ast.transformed) {+    return ast+  }+  const newAST = parse(ast.source, {+    ...parseOptions,+    prefixIdentifiers: true,+    parseMode: 'sfc',+    // errors in the template source have already been reported when the+    // descriptor was parsed; this re-parse is only used for usage analysis.+    onError: () => {},+  })+  const template = newAST.children.find(+    node => node.type === NodeTypes.ELEMENT && node.tag === 'template',+  ) as ElementNode+  return createRoot(template.children, ast.source) }  function resolveTemplateAnalysisResult(   sfc: SFCDescriptor,   collectUsedIds = true,+  parseOptions?: ParserOptions, ): {   usedIds?: Set<string>   vModelIds: Set<string>@@ -53,7 +93,7 @@ function resolveTemplateAnalysisResult(   const ids = collectUsedIds ? new Set<string>() : undefined   const vModelIds = new Set<string>() -  ast!.children.forEach(walk)+  resolveAnalyzableAST(ast!, parseOptions).children.forEach(walk)    function walk(node: TemplateChildNode) {     switch (node.type) { 
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)+}