Backtestsvuerun-20261005-155915#15126
compileScript drops template imports from returned when analysis re-runs on a transformed template AST
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 template AST has already been transformed (`ast.transformed`), the import-usage and v-model analysis re-parses the template instead of walking the mutated nodes. That mirrors the guard in compileTemplate. The deciding difference is correctness of the re-parse. - **Patch B** always re-parses with the default `@vue/compiler-dom` `parse` and no user compiler options. Projects that set custom `delimiters`, `isCustomElement`, `whitespace`, or a custom `compiler` get a re-parsed AST that differs from the original. With custom delimiters, interpolations become plain text, so template-only imports would still be dropped from `__returned__`. That is the exact symptom the issue reports, so B leaves the bug open for those configurations. - **Patch A** threads `options.templateOptions` (compiler, compilerOptions, ssr) from compileScript into the analysis. It also extracts compileTemplate's existing guard into a shared `resolveTemplateAST` helper, so both code paths re-parse identically. This removes duplication and keeps the two paths consistent. The compileTemplate refactor preserves behavior; the import-list change only follows from moving `createRoot` and `NodeTypes` out of the file. - A's test targets exactly the gap B misses. It uses custom delimiters and clears the cache to force re-analysis on a transformed AST, so it would fail before the fix. Patch B's tests are broader: v-for, components, directives, v-if, the SSR-transformed AST, v-model demotion, and `shouldForceReload`. Each would fail before the change, and that is a real point in B's favor. Costs on A's side are minor. It exports `templateAnalysisCache` for testing, and its single test is narrower. Correctness is weighted first. Because A also handles user compiler options, which B silently ignores, A is the more robust fix.
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
8m 52s
Wall-clock time in the container
Full test suite
No new failures
3,638 passed · 6 skipped · 3,644 total
Contamination audit
Clean
No sign the agent saw the real fix
Patch size
138vs 173 merged
Changed lines, ours vs merged
The issue
View on GitHubVue 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
packages/compiler-sfc/__tests__/compileScript/importUsageCheck.spec.tsindex 210fa0968..e4474ca85 100644@@ -1,4 +1,6 @@-import { assertCode, compileSFCScript as compile } from '../utils'+import { assertCode, compileSFCScript as compile, mockId } from '../utils'+import { BindingTypes } from '@vue/compiler-core'+import { compileScript, compileTemplate, parse } from '../../src' // 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 +267,106 @@ test('shorthand binding w/ kebab-case', () => { ) expect(content).toMatch('return { get fooBar() { return fooBar }') })++// the descriptor's template AST is shared with compileTemplate, which+// transforms it in place. When the analysis cache has no entry for the+// template (e.g. evicted after >500 templates), the analysis must not run on+// the already transformed AST.+describe('template AST already transformed by compileTemplate', () => {+ function compileTemplateFirst(src: string, ssr = false) {+ const { descriptor } = parse(src)+ compileTemplate({+ id: mockId,+ filename: 'test.vue',+ source: descriptor.template!.content,+ ast: descriptor.template!.ast,+ ssr,+ })+ expect(descriptor.template!.ast!.transformed).toBe(true)+ return descriptor+ }++ test('imports used in template are still returned', () => {+ const src = `+ <script setup lang="ts">+ import { fooFn, fooList, FooComp, vFooDir, fooIf, type FooType } from './x'+ const a: FooType = 1+ </script>+ <template>+ <div v-for="item in fooList" :key="item">{{ fooFn(item) }}</div>+ <FooComp v-foo-dir v-if="fooIf()" />+ </template>+ `+ const expected =+ 'return { a, get fooFn() { return fooFn }, ' ++ 'get fooList() { return fooList }, get FooComp() { return FooComp }, ' ++ 'get vFooDir() { return vFooDir }, get fooIf() { return fooIf } }'++ // client template compile first, then SSR script compile on the same+ // descriptor (as @vitejs/plugin-vue does)+ const descriptor = compileTemplateFirst(src)+ const { content } = compileScript(descriptor, { id: mockId })+ expect(content).toMatch(expected)++ // the AST was left as transformed and must still be reusable by+ // compileTemplate+ expect(descriptor.template!.ast!.transformed).toBe(true)+ })++ test('imports used in template are still returned (ssr template)', () => {+ const src = `+ <script setup lang="ts">+ import { barFn, barList } from './x'+ </script>+ <template>+ <div v-for="item in barList" :key="item">{{ barFn(item) }}</div>+ </template>+ `+ const descriptor = compileTemplateFirst(src, true)+ const { content } = compileScript(descriptor, { id: mockId })+ expect(content).toMatch(+ 'return { get barFn() { return barFn }, get barList() { return barList } }',+ )+ })++ test('v-model on const reactive binding is still demoted to let', () => {+ const src = `+ <script setup>+ import { reactive } from 'vue'+ const transformedModel = reactive({ first: 'john' })+ </script>+ <template>+ <MyComponent v-model="transformedModel" />+ </template>+ `+ const descriptor = compileTemplateFirst(src)+ const { content, bindings } = compileScript(descriptor, { id: mockId })+ expect(content).toMatch(+ `let transformedModel = reactive({ first: 'john' })`,+ )+ expect(bindings!.transformedModel).toBe(BindingTypes.SETUP_LET)+ })++ test('hmr force reload when import becomes used', () => {+ const prev = parse(`+ <script setup lang="ts">+ import { hmrFoo } from './x'+ </script>+ <template>+ <div></div>+ </template>+ `).descriptor+ const { imports } = compileScript(prev, { id: mockId })+ expect(imports!.hmrFoo.isUsedInTemplate).toBe(false)++ const next = compileTemplateFirst(`+ <script setup lang="ts">+ import { hmrFoo } from './x'+ </script>+ <template>+ <div v-for="i in 3">{{ hmrFoo(i) }}</div>+ </template>+ `)+ expect(next.shouldForceReload(imports!)).toBe(true)+ })+})packages/compiler-sfc/src/script/importUsageCheck.tsindex 9c087b466..fc30232b8 100644@@ -1,10 +1,13 @@ import type { SFCDescriptor } from '../parse' import {+ type ElementNode, type ExpressionNode, NodeTypes,+ type RootNode, type SimpleExpressionNode, type TemplateChildNode, isSimpleIdentifier,+ parse, parserOptions, walkIdentifiers, } from '@vue/compiler-dom'@@ -53,7 +56,7 @@ function resolveTemplateAnalysisResult( const ids = collectUsedIds ? new Set<string>() : undefined const vModelIds = new Set<string>() - ast!.children.forEach(walk)+ resolveRawTemplateAST(ast!).children.forEach(walk) function walk(node: TemplateChildNode) { switch (node.type) {@@ -134,6 +137,32 @@ function resolveTemplateAnalysisResult( return result } +/**+ * The template AST on the descriptor is shared with compileTemplate, which+ * transforms it in place (expressions get prefixed, v-if / v-for are replaced+ * by IF / FOR nodes). The analysis must run on a raw AST, so if it has already+ * been transformed we re-parse a fresh one, mirroring compileTemplate's guard.+ */+function resolveRawTemplateAST(ast: RootNode): RootNode | ElementNode {+ if (!ast.transformed) {+ return ast+ }+ // parse the full SFC source so that the AST shape matches the one produced+ // by the SFC parser.+ const sfcAST = parse(ast.source, {+ parseMode: 'sfc',+ prefixIdentifiers: true,+ // the same source was already parsed by `parse()` from './parse', which+ // reported any syntax errors on the descriptor. Re-reporting them here+ // would throw (default onError) on a template that is otherwise usable.+ onError: () => {},+ })+ const template = sfcAST.children.find(+ node => node.type === NodeTypes.ELEMENT && node.tag === 'template',+ ) as ElementNode+ return template+}+ function extractIdentifiers(ids: Set<string>, node: ExpressionNode) { if (node.ast) { walkIdentifiers(node.ast, n => ids.add(n.name))
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)+}