@vue/language-core 3.0.0-beta.2 → 3.0.0-beta.3

package/lib/codegen/codeFeatures.d.ts

@@ -6,7 +6,6 @@ declare const raw: {
         semantic: true;
         navigation: true;
     };
-    none: {};
     verification: {
         verification: true;
     };
@@ -50,6 +49,11 @@ declare const raw: {
         completion: true;
         semantic: true;
     };
+    semanticWithoutHighlight: {
+        semantic: {
+            shouldHighlight: () => false;
+        };
+    };
     withoutHighlight: {
         semantic: {
             shouldHighlight: () => false;

package/lib/codegen/codeFeatures.js

@@ -8,7 +8,6 @@ const raw = {
         semantic: true,
         navigation: true,
     },
-    none: {},
     verification: {
         verification: true,
     },
@@ -46,6 +45,9 @@ const raw = {
         completion: true,
         semantic: true,
     },
+    semanticWithoutHighlight: {
+        semantic: { shouldHighlight: () => false },
+    },
     withoutHighlight: {
         semantic: { shouldHighlight: () => false },
         verification: true,

package/lib/codegen/globalTypes.js

@@ -123,7 +123,7 @@ function generateGlobalTypes({ lib, target, checkUnknownProps, checkUnknownEvent
 	type __VLS_ResolveDirectives<T> = {
 		[K in Exclude<keyof T, keyof __VLS_GlobalDirectives> & string as \`v\${Capitalize<K>}\`]: T[K];
 	};
-	type __VLS_PrettifyGlobal<T> = { [K in keyof T]: T[K]; } & {};
+	type __VLS_PrettifyGlobal<T> = { [K in keyof T as K]: T[K]; } & {};
 	type __VLS_UseTemplateRef<T> = Readonly<import('${lib}').ShallowRef<T | null>>;
 
 	function __VLS_getVForSourceType<T extends number | string | any[] | Iterable<any>>(source: T): [

package/lib/codegen/localTypes.js

@@ -16,7 +16,7 @@ type __VLS_WithDefaults<P, D> = {
 		: P[K]
 };
 `.trimStart());
-    const PrettifyLocal = defineHelper(`__VLS_PrettifyLocal`, () => `type __VLS_PrettifyLocal<T> = { [K in keyof T]: T[K]; } & {}${utils_1.endOfLine}`);
+    const PrettifyLocal = defineHelper(`__VLS_PrettifyLocal`, () => `type __VLS_PrettifyLocal<T> = { [K in keyof T as K]: T[K]; } & {}${utils_1.endOfLine}`);
     const WithSlots = defineHelper(`__VLS_WithSlots`, () => `
 type __VLS_WithSlots<T, S> = T & {
 	new(): {

package/lib/codegen/script/scriptSetup.js

@@ -135,11 +135,11 @@ function* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, sy
             setupCodeModifies.push([
                 [`(`],
                 callExp.start,
-                callExp.start
+                callExp.start,
             ], [
                 [` as typeof __VLS_dollars.$attrs)`],
                 callExp.end,
-                callExp.end
+                callExp.end,
             ]);
         }
     }
@@ -147,25 +147,25 @@ function* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, sy
         setupCodeModifies.push([
             [`(`],
             callExp.start,
-            callExp.start
+            callExp.start,
         ], [
             arg ? [
                 ` as Omit<__VLS_StyleModules, '$style'>[`,
                 (0, utils_1.generateSfcBlockSection)(scriptSetup, arg.start, arg.end, codeFeatures_1.codeFeatures.all),
-                `])`
+                `])`,
             ] : [
                 ` as __VLS_StyleModules[`,
                 ...(0, wrapWith_1.wrapWith)(exp.start, exp.end, scriptSetup.name, codeFeatures_1.codeFeatures.verification, `'$style'`),
-                `])`
+                `])`,
             ],
             callExp.end,
-            callExp.end
+            callExp.end,
         ]);
         if (arg) {
             setupCodeModifies.push([
                 [`__VLS_placeholder`],
                 arg.start,
-                arg.end
+                arg.end,
             ]);
         }
     }
@@ -174,11 +174,11 @@ function* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, sy
             setupCodeModifies.push([
                 [`(`],
                 callExp.start,
-                callExp.start
+                callExp.start,
             ], [
                 [` as typeof __VLS_dollars.$slots)`],
                 callExp.end,
-                callExp.end
+                callExp.end,
             ]);
         }
     }
@@ -188,7 +188,7 @@ function* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, sy
             ? [
                 `__VLS_TemplateRefs[`,
                 (0, utils_1.generateSfcBlockSection)(scriptSetup, arg.start, arg.end, codeFeatures_1.codeFeatures.withoutSemantic),
-                `]`
+                `]`,
             ]
             : [`unknown`];
         if (isTs) {
@@ -196,32 +196,32 @@ function* generateSetupFunction(options, ctx, scriptSetup, scriptSetupRanges, sy
                 [
                     `<`,
                     ...templateRefType,
-                    `>`
+                    `>`,
                 ],
                 exp.end,
-                exp.end
+                exp.end,
             ]);
         }
         else {
             setupCodeModifies.push([
                 [`(`],
                 callExp.start,
-                callExp.start
+                callExp.start,
             ], [
                 [
                     ` as __VLS_UseTemplateRef<`,
                     ...templateRefType,
-                    `>)`
+                    `>)`,
                 ],
                 callExp.end,
-                callExp.end
+                callExp.end,
             ]);
         }
         if (arg) {
             setupCodeModifies.push([
                 [`__VLS_placeholder`],
                 arg.start,
-                arg.end
+                arg.end,
             ]);
         }
     }
@@ -291,13 +291,13 @@ function* generateDefineWithType(scriptSetup, statement, callExp, typeArg, name,
         else if (typeArg) {
             yield [[
                     `const ${defaultName} = `,
-                    (0, utils_1.generateSfcBlockSection)(scriptSetup, callExp.start, typeArg.start, codeFeatures_1.codeFeatures.all)
+                    (0, utils_1.generateSfcBlockSection)(scriptSetup, callExp.start, typeArg.start, codeFeatures_1.codeFeatures.all),
                 ], statement.start, typeArg.start];
             yield [[
                     (0, utils_1.generateSfcBlockSection)(scriptSetup, typeArg.end, callExp.end, codeFeatures_1.codeFeatures.all),
                     utils_1.endOfLine,
                     (0, utils_1.generateSfcBlockSection)(scriptSetup, statement.start, callExp.start, codeFeatures_1.codeFeatures.all),
-                    defaultName
+                    defaultName,
                 ], typeArg.end, callExp.end];
         }
         else {
@@ -306,7 +306,7 @@ function* generateDefineWithType(scriptSetup, statement, callExp, typeArg, name,
                     (0, utils_1.generateSfcBlockSection)(scriptSetup, callExp.start, callExp.end, codeFeatures_1.codeFeatures.all),
                     utils_1.endOfLine,
                     (0, utils_1.generateSfcBlockSection)(scriptSetup, statement.start, callExp.start, codeFeatures_1.codeFeatures.all),
-                    defaultName
+                    defaultName,
                 ], statement.start, callExp.end];
         }
     }

package/lib/codegen/script/template.js

@@ -103,7 +103,6 @@ function* generateTemplateBody(options, templateCodegenCtx) {
         yield* options.templateCodegen.codes;
     }
     else {
-        yield `// no template${utils_1.newLine}`;
         if (!options.scriptSetupRanges?.defineSlots) {
             yield `type __VLS_Slots = {}${utils_1.endOfLine}`;
         }

package/lib/codegen/style/classProperty.js

@@ -10,7 +10,7 @@ function* generateClassProperty(styleIndex, classNameWithDot, offset, propertyTy
         classNameWithDot.slice(1),
         'style_' + styleIndex,
         offset + 1,
-        utils_1.combineLastMapping
+        utils_1.combineLastMapping,
     ], `'`);
     yield `: ${propertyType}`;
     yield ` }`;

package/lib/codegen/style/imports.js

@@ -6,7 +6,7 @@ const wrapWith_1 = require("../utils/wrapWith");
 function* generateStyleImports(style) {
     const features = {
         navigation: true,
-        verification: true
+        verification: true,
     };
     if (typeof style.src === 'object') {
         yield `${utils_1.newLine} & typeof import(`;
@@ -19,7 +19,7 @@ function* generateStyleImports(style) {
             text,
             style.name,
             offset,
-            features
+            features,
         ];
         yield `').default`;
     }

package/lib/codegen/style/scopedClasses.js

@@ -23,7 +23,7 @@ function* generateStyleScopedClasses(options, ctx) {
                 ctx.scopedClasses.push({
                     source: 'style_' + i,
                     className: className.text.slice(1),
-                    offset: className.offset + 1
+                    offset: className.offset + 1,
                 });
                 continue;
             }

package/lib/codegen/template/context.d.ts

@@ -114,7 +114,6 @@ export declare function createTemplateCodegenContext(options: Pick<TemplateCodeg
     };
     codeFeatures: {
         all: VueCodeInformation;
-        none: VueCodeInformation;
         verification: VueCodeInformation;
         completion: VueCodeInformation;
         additionalCompletion: VueCodeInformation;
@@ -125,6 +124,7 @@ export declare function createTemplateCodegenContext(options: Pick<TemplateCodeg
         navigationAndAdditionalCompletion: VueCodeInformation;
         navigationAndVerification: VueCodeInformation;
         withoutNavigation: VueCodeInformation;
+        semanticWithoutHighlight: VueCodeInformation;
         withoutHighlight: VueCodeInformation;
         withoutHighlightAndNavigation: VueCodeInformation;
         withoutHighlightAndCompletion: VueCodeInformation;

package/lib/codegen/template/context.js

@@ -243,7 +243,7 @@ function createTemplateCodegenContext(options) {
                             offset,
                             {
                                 ...codeFeatures_1.codeFeatures.additionalCompletion,
-                                ...codeFeatures_1.codeFeatures.withoutHighlightAndCompletionAndNavigation,
+                                ...codeFeatures_1.codeFeatures.semanticWithoutHighlight,
                             },
                         ];
                     }

package/lib/codegen/template/element.js

@@ -55,7 +55,6 @@ function* generateComponent(options, ctx, node) {
                 dynamicTagInfo = {
                     tag: prop.exp.content,
                     offsets: [prop.exp.loc.start.offset],
-                    astHolder: prop.exp.loc,
                 };
                 props = props.filter(p => p !== prop);
                 break;
@@ -67,7 +66,6 @@ function* generateComponent(options, ctx, node) {
         dynamicTagInfo = {
             tag: node.tag,
             offsets: tagOffsets,
-            astHolder: node.loc,
         };
     }
     if (matchImportName) {
@@ -93,10 +91,10 @@ function* generateComponent(options, ctx, node) {
     }
     else if (dynamicTagInfo) {
         yield `const ${componentOriginalVar} = (`;
-        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, dynamicTagInfo.tag, dynamicTagInfo.offsets[0], dynamicTagInfo.astHolder, `(`, `)`);
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, dynamicTagInfo.tag, dynamicTagInfo.offsets[0], `(`, `)`);
         if (dynamicTagInfo.offsets[1] !== undefined) {
             yield `,`;
-            yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.withoutCompletion, dynamicTagInfo.tag, dynamicTagInfo.offsets[1], dynamicTagInfo.astHolder, `(`, `)`);
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.withoutCompletion, dynamicTagInfo.tag, dynamicTagInfo.offsets[1], `(`, `)`);
         }
         yield `)${utils_1.endOfLine}`;
     }
@@ -151,7 +149,7 @@ function* generateComponent(options, ctx, node) {
                 // https://typescript.tv/errors/#ts6133
                 return String(code) !== '6133';
             },
-        }
+        },
     }), componentVNodeVar);
     yield ` = ${componentFunctionalVar}`;
     yield* generateComponentGeneric(ctx);
@@ -231,7 +229,7 @@ function* generateElement(options, ctx, node) {
 }
 function* generateFailedPropExps(options, ctx, failedPropExps) {
     for (const failedExp of failedPropExps) {
-        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, failedExp.node.loc.source, failedExp.node.loc.start.offset, failedExp.node.loc, failedExp.prefix, failedExp.suffix);
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, failedExp.node.loc.source, failedExp.node.loc.start.offset, failedExp.prefix, failedExp.suffix);
         yield utils_1.endOfLine;
     }
 }
@@ -268,7 +266,7 @@ function* generateComponentGeneric(ctx) {
             content,
             'template',
             offset,
-            ctx.codeFeatures.all
+            ctx.codeFeatures.all,
         ], `>`);
     }
 }
@@ -280,7 +278,7 @@ function* generateElementReference(options, ctx, node) {
             const [content, startOffset] = (0, utils_1.normalizeAttributeValue)(prop.value);
             // navigation support for `const foo = ref()`
             yield `/** @type {typeof __VLS_ctx`;
-            yield* (0, propertyAccess_1.generatePropertyAccess)(options, ctx, content, startOffset, ctx.codeFeatures.navigation, prop.value.loc);
+            yield* (0, propertyAccess_1.generatePropertyAccess)(options, ctx, content, startOffset, ctx.codeFeatures.navigation);
             yield `} */${utils_1.endOfLine}`;
             if (utils_1.identifierRegex.test(content) && !options.templateRefNames.has(content)) {
                 ctx.accessExternalVariable(content, startOffset);

package/lib/codegen/template/elementDirectives.js

@@ -53,7 +53,7 @@ function* generateArg(options, ctx, prop) {
         yield* (0, stringLiteralKey_1.generateStringLiteralKey)(arg.content, startOffset, ctx.codeFeatures.all);
     }
     else {
-        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, arg.content, startOffset, arg.loc, `(`, `)`);
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, arg.content, startOffset, `(`, `)`);
     }
     yield `, `;
 }

package/lib/codegen/template/elementEvents.js

@@ -45,7 +45,7 @@ function* generateElementEvents(options, ctx, node, componentOriginalVar, compon
             const propName = (0, shared_1.camelize)(propPrefix + source);
             const emitName = emitPrefix + source;
             const camelizedEmitName = (0, shared_1.camelize)(emitName);
-            yield `(): __VLS_NormalizeComponentEvent<typeof ${propsVar}, typeof ${emitsVar}, '${propName}', '${emitName}', '${camelizedEmitName}'> => (${utils_1.newLine}`;
+            yield `const ${ctx.getInternalVariable()}: __VLS_NormalizeComponentEvent<typeof ${propsVar}, typeof ${emitsVar}, '${propName}', '${emitName}', '${camelizedEmitName}'> = (${utils_1.newLine}`;
             if (prop.name === 'on') {
                 yield `{ `;
                 yield* generateEventArg(ctx, source, start, emitPrefix.slice(0, -1), ctx.codeFeatures.navigation);
@@ -86,17 +86,17 @@ function* generateEventExpression(options, ctx, prop) {
         let prefix = `(`;
         let suffix = `)`;
         let isFirstMapping = true;
-        const ast = (0, utils_1.createTsAst)(options.ts, prop.exp, prop.exp.content);
-        const _isCompoundExpression = isCompoundExpression(options.ts, ast);
-        if (_isCompoundExpression) {
-            yield `(...[$event]) => {${utils_1.newLine}`;
+        const ast = (0, utils_1.createTsAst)(options.ts, options.template.ast, prop.exp.content);
+        const isCompound = isCompoundExpression(options.ts, ast);
+        if (isCompound) {
             ctx.addLocalVariable('$event');
+            yield `(...[$event]) => {${utils_1.newLine}`;
             yield* ctx.generateConditionGuards();
             prefix = ``;
             suffix = ``;
         }
         yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', offset => {
-            if (_isCompoundExpression && isFirstMapping) {
+            if (isCompound && isFirstMapping) {
                 isFirstMapping = false;
                 ctx.inlayHints.push({
                     blockName: 'template',
@@ -112,8 +112,8 @@ function* generateEventExpression(options, ctx, prop) {
                 });
             }
             return ctx.codeFeatures.all;
-        }, prop.exp.content, prop.exp.loc.start.offset, prop.exp.loc, prefix, suffix);
-        if (_isCompoundExpression) {
+        }, prop.exp.content, prop.exp.loc.start.offset, prefix, suffix);
+        if (isCompound) {
             ctx.removeLocalVariable('$event');
             yield utils_1.endOfLine;
             yield* ctx.generateAutoImportCompletion();
@@ -128,7 +128,7 @@ function* generateModelEventExpression(options, ctx, prop) {
     if (prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
         yield `(...[$event]) => {${utils_1.newLine}`;
         yield* ctx.generateConditionGuards();
-        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.verification, prop.exp.content, prop.exp.loc.start.offset, prop.exp.loc);
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.verification, prop.exp.content, prop.exp.loc.start.offset);
         yield ` = $event${utils_1.endOfLine}`;
         yield `}`;
     }

package/lib/codegen/template/elementProps.js

@@ -82,7 +82,7 @@ function* generateElementProps(options, ctx, node, props, strictPropsCheck, enab
                 yield `...{ `;
             }
             const codes = [...(0, wrapWith_1.wrapWith)(prop.loc.start.offset, prop.loc.end.offset, ctx.codeFeatures.verification, ...(prop.arg
-                    ? (0, objectProperty_1.generateObjectProperty)(options, ctx, propName, prop.arg.loc.start.offset, codeInfo, prop.loc.name_2 ??= {}, shouldCamelize)
+                    ? (0, objectProperty_1.generateObjectProperty)(options, ctx, propName, prop.arg.loc.start.offset, codeInfo, shouldCamelize)
                     : (0, wrapWith_1.wrapWith)(prop.loc.start.offset, prop.loc.start.offset + 'v-model'.length, ctx.codeFeatures.withoutHighlightAndCompletion, propName)), `: `, ...(0, wrapWith_1.wrapWith)(prop.arg?.loc.start.offset ?? prop.loc.start.offset, prop.arg?.loc.end.offset ?? prop.loc.end.offset, ctx.codeFeatures.verification, ...generatePropExp(options, ctx, prop, prop.exp, enableCodeFeatures)))];
             if (enableCodeFeatures) {
                 yield* codes;
@@ -97,7 +97,7 @@ function* generateElementProps(options, ctx, node, props, strictPropsCheck, enab
             if (isComponent && prop.name === 'model' && prop.modifiers.length) {
                 const propertyName = prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
                     ? !prop.arg.isStatic
-                        ? `[__VLS_tryAsConstant(\`$\{${prop.arg.content}\}Modifiers\`)]`
+                        ? `[__VLS_tryAsConstant(\`\${${prop.arg.content}}Modifiers\`)]`
                         : (0, shared_1.camelize)(propName) + `Modifiers`
                     : `modelModifiers`;
                 const codes = [...(0, elementDirectives_1.generateModifiers)(options, ctx, prop, propertyName)];
@@ -120,7 +120,7 @@ function* generateElementProps(options, ctx, node, props, strictPropsCheck, enab
             if (shouldSpread) {
                 yield `...{ `;
             }
-            const codes = [...(0, wrapWith_1.wrapWith)(prop.loc.start.offset, prop.loc.end.offset, ctx.codeFeatures.verification, ...(0, objectProperty_1.generateObjectProperty)(options, ctx, prop.name, prop.loc.start.offset, codeInfo, prop.loc.name_1 ??= {}, shouldCamelize), `: `, ...(prop.value
+            const codes = [...(0, wrapWith_1.wrapWith)(prop.loc.start.offset, prop.loc.end.offset, ctx.codeFeatures.verification, ...(0, objectProperty_1.generateObjectProperty)(options, ctx, prop.name, prop.loc.start.offset, codeInfo, shouldCamelize), `: `, ...(prop.value
                     ? generateAttrValue(prop.value, ctx.codeFeatures.withoutNavigation)
                     : [`true`]))];
             if (enableCodeFeatures) {
@@ -163,7 +163,7 @@ function* generatePropExp(options, ctx, prop, exp, enableCodeFeatures = true) {
         : ctx.codeFeatures.all;
     if (exp && exp.constType !== CompilerDOM.ConstantTypes.CAN_STRINGIFY) { // style='z-index: 2' will compile to {'z-index':'2'}
         if (!isShorthand) { // vue 3.4+
-            yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', features, exp.loc.source, exp.loc.start.offset, exp.loc, `(`, `)`);
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', features, exp.loc.source, exp.loc.start.offset, `(`, `)`);
         }
         else {
             const propVariableName = (0, shared_1.camelize)(exp.loc.source);

package/lib/codegen/template/index.js

@@ -38,7 +38,7 @@ function* generateTemplate(options) {
         ['$slots', yield* generateSlots(options, ctx)],
         ['$attrs', yield* generateInheritedAttrs(options, ctx)],
         ['$refs', yield* generateTemplateRefs(options, ctx)],
-        ['$el', yield* generateRootEl(ctx)]
+        ['$el', yield* generateRootEl(ctx)],
     ];
     yield `var __VLS_dollars!: {${utils_1.newLine}`;
     for (const [name, type] of speicalTypes) {
@@ -56,7 +56,7 @@ function* generateSlots(options, ctx) {
         for (const slot of ctx.slots) {
             yield `${utils_1.newLine}& { `;
             if (slot.name && slot.offset !== undefined) {
-                yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, slot.name, slot.offset, ctx.codeFeatures.withoutHighlightAndCompletion, slot.nodeLoc);
+                yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, slot.name, slot.offset, ctx.codeFeatures.withoutHighlightAndCompletion);
             }
             else {
                 yield* (0, wrapWith_1.wrapWith)(slot.tagRange[0], slot.tagRange[1], ctx.codeFeatures.withoutHighlightAndCompletion, `default`);
@@ -81,7 +81,7 @@ function* generateInheritedAttrs(options, ctx) {
                 loc.source,
                 'template',
                 loc.start.offset,
-                ctx.codeFeatures.all
+                ctx.codeFeatures.all,
             ];
             yield `,`;
         }

package/lib/codegen/template/interpolation.d.ts

@@ -1,8 +1,5 @@
-import type * as ts from 'typescript';
 import type { Code, VueCodeInformation } from '../../types';
+import type { ScriptCodegenOptions } from '../script';
 import type { TemplateCodegenContext } from './context';
-export declare function generateInterpolation(options: {
-    ts: typeof ts;
-    destructuredPropNames: Set<string> | undefined;
-    templateRefNames: Set<string> | undefined;
-}, ctx: TemplateCodegenContext, source: string, data: VueCodeInformation | ((offset: number) => VueCodeInformation) | undefined, code: string, start: number | undefined, astHolder?: any, prefix?: string, suffix?: string): Generator<Code>;
+import type { TemplateCodegenOptions } from './index';
+export declare function generateInterpolation(options: TemplateCodegenOptions | ScriptCodegenOptions, ctx: TemplateCodegenContext, source: string, data: VueCodeInformation | ((offset: number) => VueCodeInformation) | undefined, code: string, start: number | undefined, prefix?: string, suffix?: string): Generator<Code>;

package/lib/codegen/template/interpolation.js

@@ -6,8 +6,10 @@ const shared_2 = require("../../utils/shared");
 const utils_1 = require("../utils");
 // https://github.com/vuejs/core/blob/fb0c3ca519f1fccf52049cd6b8db3a67a669afe9/packages/compiler-core/src/transforms/transformExpression.ts#L47
 const isLiteralWhitelisted = /*@__PURE__*/ (0, shared_1.makeMap)('true,false,null,this');
-function* generateInterpolation(options, ctx, source, data, code, start, astHolder = {}, prefix = '', suffix = '') {
-    for (let [section, offset, type] of forEachInterpolationSegment(options.ts, options.destructuredPropNames, options.templateRefNames, ctx, code, start, astHolder, prefix, suffix)) {
+function* generateInterpolation(options, ctx, source, data, code, start, prefix = '', suffix = '') {
+    const { ts, destructuredPropNames, templateRefNames, } = options;
+    const template = 'template' in options ? options.template : options.sfc.template;
+    for (let [section, offset, type] of forEachInterpolationSegment(ts, template, destructuredPropNames, templateRefNames, ctx, code, start, prefix, suffix)) {
         if (offset === undefined) {
             yield section;
         }
@@ -46,7 +48,7 @@ function* generateInterpolation(options, ctx, source, data, code, start, astHold
     }
 }
 ;
-function* forEachInterpolationSegment(ts, destructuredPropNames, templateRefNames, ctx, originalCode, start, astHolder, prefix, suffix) {
+function* forEachInterpolationSegment(ts, template, destructuredPropNames, templateRefNames, ctx, originalCode, start, prefix, suffix) {
     const code = prefix + originalCode + suffix;
     const offset = start !== undefined ? start - prefix.length : undefined;
     let ctxVars = [];
@@ -57,7 +59,7 @@ function* forEachInterpolationSegment(ts, destructuredPropNames, templateRefName
         });
     }
     else {
-        const ast = (0, utils_1.createTsAst)(ts, astHolder, code);
+        const ast = (0, utils_1.createTsAst)(ts, template?.ast, code);
         const varCb = (id, isShorthand) => {
             const text = (0, shared_2.getNodeText)(ts, id, ast);
             if (!shouldIdentifierSkipped(ctx, text, destructuredPropNames)) {

package/lib/codegen/template/objectProperty.d.ts

@@ -1,4 +1,4 @@
 import type { Code, VueCodeInformation } from '../../types';
 import type { TemplateCodegenContext } from './context';
 import type { TemplateCodegenOptions } from './index';
-export declare function generateObjectProperty(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, code: string, offset: number, features: VueCodeInformation, astHolder?: any, shouldCamelize?: boolean, shouldBeConstant?: boolean): Generator<Code>;
+export declare function generateObjectProperty(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, code: string, offset: number, features: VueCodeInformation, shouldCamelize?: boolean, shouldBeConstant?: boolean): Generator<Code>;

package/lib/codegen/template/objectProperty.js

@@ -7,13 +7,13 @@ const camelized_1 = require("../utils/camelized");
 const stringLiteralKey_1 = require("../utils/stringLiteralKey");
 const wrapWith_1 = require("../utils/wrapWith");
 const interpolation_1 = require("./interpolation");
-function* generateObjectProperty(options, ctx, code, offset, features, astHolder, shouldCamelize = false, shouldBeConstant = false) {
-    if (code.startsWith('[') && code.endsWith(']') && astHolder) {
+function* generateObjectProperty(options, ctx, code, offset, features, shouldCamelize = false, shouldBeConstant = false) {
+    if (code.startsWith('[') && code.endsWith(']')) {
         if (shouldBeConstant) {
-            yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', features, code.slice(1, -1), offset + 1, astHolder, `[__VLS_tryAsConstant(`, `)]`);
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', features, code.slice(1, -1), offset + 1, `[__VLS_tryAsConstant(`, `)]`);
         }
         else {
-            yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', features, code, offset, astHolder);
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', features, code, offset);
         }
     }
     else if (shouldCamelize) {

package/lib/codegen/template/propertyAccess.d.ts

@@ -1,4 +1,4 @@
 import type { Code, VueCodeInformation } from '../../types';
 import type { TemplateCodegenContext } from './context';
 import type { TemplateCodegenOptions } from './index';
-export declare function generatePropertyAccess(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, code: string, offset?: number, features?: VueCodeInformation, astHolder?: any): Generator<Code>;
+export declare function generatePropertyAccess(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, code: string, offset?: number, features?: VueCodeInformation): Generator<Code>;

package/lib/codegen/template/propertyAccess.js

@@ -4,7 +4,7 @@ exports.generatePropertyAccess = generatePropertyAccess;
 const utils_1 = require("../utils");
 const stringLiteralKey_1 = require("../utils/stringLiteralKey");
 const interpolation_1 = require("./interpolation");
-function* generatePropertyAccess(options, ctx, code, offset, features, astHolder) {
+function* generatePropertyAccess(options, ctx, code, offset, features) {
     if (!options.compilerOptions.noPropertyAccessFromIndexSignature && utils_1.identifierRegex.test(code)) {
         yield `.`;
         yield offset !== undefined && features
@@ -12,7 +12,7 @@ function* generatePropertyAccess(options, ctx, code, offset, features, astHolder
             : code;
     }
     else if (code.startsWith('[') && code.endsWith(']')) {
-        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', features, code, offset, astHolder);
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', features, code, offset);
     }
     else {
         yield `[`;

package/lib/codegen/template/slotOutlet.js

@@ -40,7 +40,7 @@ function* generateSlotOutlet(options, ctx, node) {
                 codes = [
                     `[`,
                     ...(0, elementProps_1.generatePropExp)(options, ctx, nameProp, nameProp.exp),
-                    `]`
+                    `]`,
                 ];
             }
             else {
@@ -77,7 +77,7 @@ function* generateSlotOutlet(options, ctx, node) {
             }
             const expVar = ctx.getInternalVariable();
             yield `var ${expVar} = __VLS_tryAsConstant(`;
-            yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, nameProp.exp.content, nameProp.exp.loc.start.offset, nameProp.exp);
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, nameProp.exp.content, nameProp.exp.loc.start.offset);
             yield `)${utils_1.endOfLine}`;
             ctx.dynamicSlots.push({
                 expVar: ctx.getHoistVariable(expVar),

package/lib/codegen/template/styleScopedClasses.js

@@ -130,7 +130,7 @@ function collectStyleScopedClassReferences(options, ctx, node) {
                 ctx.scopedClasses.push({
                     source: 'template',
                     className: text,
-                    offset: node.end - text.length + startOffset
+                    offset: node.end - text.length + startOffset,
                 });
             }
         }
@@ -146,7 +146,7 @@ function collectClasses(content, startOffset = 0) {
                 classes.push({
                     source: 'template',
                     className: currentClassName,
-                    offset: offset + startOffset
+                    offset: offset + startOffset,
                 });
                 offset += currentClassName.length;
                 currentClassName = '';

package/lib/codegen/template/templateChild.js

@@ -83,7 +83,7 @@ function* generateTemplateChild(options, ctx, node, enterNode = true) {
     else if (node.type === CompilerDOM.NodeTypes.INTERPOLATION) {
         // {{ ... }}
         const [content, start] = parseInterpolationNode(node, options.template.content);
-        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, content, start, node.content.loc, `(`, `)${utils_1.endOfLine}`);
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, content, start, `(`, `)${utils_1.endOfLine}`);
     }
     else if (node.type === CompilerDOM.NodeTypes.IF) {
         // v-if / v-else-if / v-else

package/lib/codegen/template/vFor.js

@@ -12,7 +12,7 @@ function* generateVFor(options, ctx, node) {
     const forBlockVars = [];
     yield `for (const [`;
     if (leftExpressionRange && leftExpressionText) {
-        const collectAst = (0, utils_1.createTsAst)(options.ts, node.parseResult, `const [${leftExpressionText}]`);
+        const collectAst = (0, utils_1.createTsAst)(options.ts, options.template.ast, `const [${leftExpressionText}]`);
         (0, utils_1.collectVars)(options.ts, collectAst, collectAst, forBlockVars);
         yield [
             leftExpressionText,
@@ -24,7 +24,7 @@ function* generateVFor(options, ctx, node) {
     yield `] of `;
     if (source.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
         yield `__VLS_getVForSourceType(`;
-        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, source.content, source.loc.start.offset, source.loc, `(`, `)`);
+        yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, source.content, source.loc.start.offset, `(`, `)`);
         yield `!)`; // #3102
     }
     else {
@@ -46,7 +46,7 @@ function* generateVFor(options, ctx, node) {
             for (const prop of argument.returns.props.properties) {
                 if (prop.value.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
                     && !prop.value.isStatic) {
-                    yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, prop.value.content, prop.value.loc.start.offset, prop.value.loc, `(`, `)`);
+                    yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, prop.value.content, prop.value.loc.start.offset, `(`, `)`);
                     yield utils_1.endOfLine;
                 }
             }

package/lib/codegen/template/vIf.js

@@ -21,7 +21,7 @@ function* generateVIf(options, ctx, node) {
         }
         let addedBlockCondition = false;
         if (branch.condition?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
-            const codes = [...(0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, branch.condition.content, branch.condition.loc.start.offset, branch.condition.loc, `(`, `)`)];
+            const codes = [...(0, interpolation_1.generateInterpolation)(options, ctx, 'template', ctx.codeFeatures.all, branch.condition.content, branch.condition.loc.start.offset, `(`, `)`)];
             yield* codes;
             ctx.blockConditions.push((0, muggle_string_1.toString)(codes));
             addedBlockCondition = true;

package/lib/codegen/template/vSlot.js

@@ -21,7 +21,7 @@ function* generateVSlot(options, ctx, node, slotDir) {
         yield `const { `;
         if (slotDir) {
             if (slotDir.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && slotDir.arg.content) {
-                yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, slotDir.arg.loc.source, slotDir.arg.loc.start.offset, slotDir.arg.isStatic ? ctx.codeFeatures.withoutHighlight : ctx.codeFeatures.all, slotDir.arg.loc, false, true);
+                yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, slotDir.arg.loc.source, slotDir.arg.loc.start.offset, slotDir.arg.isStatic ? ctx.codeFeatures.withoutHighlight : ctx.codeFeatures.all, false, true);
             }
             else {
                 yield* (0, wrapWith_1.wrapWith)(slotDir.loc.start.offset, slotDir.loc.start.offset + (slotDir.rawName?.length ?? 0), ctx.codeFeatures.withoutHighlightAndCompletion, `default`);
@@ -35,7 +35,7 @@ function* generateVSlot(options, ctx, node, slotDir) {
         yield `: ${slotVar} } = ${ctx.currentComponent.ctxVar}.slots!${utils_1.endOfLine}`;
     }
     if (slotDir?.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
-        const slotAst = (0, utils_1.createTsAst)(options.ts, slotDir, `(${slotDir.exp.content}) => {}`);
+        const slotAst = (0, utils_1.createTsAst)(options.ts, options.template.ast, `(${slotDir.exp.content}) => {}`);
         (0, utils_1.collectVars)(options.ts, slotAst, slotAst, slotBlockVars);
         yield* generateSlotParameters(options, ctx, slotAst, slotDir.exp, slotVar);
     }

package/lib/codegen/utils/index.d.ts

@@ -16,5 +16,5 @@ export declare function collectIdentifiers(ts: typeof import('typescript'), node
     initializer: ts.Expression | undefined;
 }[];
 export declare function normalizeAttributeValue(node: CompilerDOM.TextNode): [string, number];
-export declare function createTsAst(ts: typeof import('typescript'), astHolder: any, text: string): ts.SourceFile;
+export declare function createTsAst(ts: typeof import('typescript'), templateAst: CompilerDOM.RootNode | undefined, text: string): ts.SourceFile;
 export declare function generateSfcBlockSection(block: SfcBlock, start: number, end: number, features: VueCodeInformation): Code;

package/lib/codegen/utils/index.js

@@ -49,12 +49,15 @@ function normalizeAttributeValue(node) {
     }
     return [content, offset];
 }
-function createTsAst(ts, astHolder, text) {
-    if (astHolder.__volar_ast_text !== text) {
-        astHolder.__volar_ast_text = text;
-        astHolder.__volar_ast = ts.createSourceFile('/a.ts', text, 99);
+function createTsAst(ts, templateAst, text) {
+    const inlineTsAsts = templateAst?.__volar_inlineTsAsts;
+    let ast = inlineTsAsts?.get(text);
+    if (!ast) {
+        ast = ts.createSourceFile('/a.ts', text, 99);
+        inlineTsAsts?.set(text, ast);
     }
-    return astHolder.__volar_ast;
+    ast.__volar_used = true;
+    return ast;
 }
 function generateSfcBlockSection(block, start, end, features) {
     return [

package/lib/parsers/scriptSetupRanges.js

@@ -143,7 +143,7 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                 defineProps = {
                     ...parseCallExpressionAssignment(node, parent),
                     statement: getStatementRange(ts, parents, node, ast),
-                    argNode: node.arguments[0]
+                    argNode: node.arguments[0],
                 };
                 if (ts.isVariableDeclaration(parent) && ts.isObjectBindingPattern(parent.name)) {
                     defineProps.destructured = new Map();
@@ -172,13 +172,13 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
                     callExp: _getStartEnd(node),
                     exp: _getStartEnd(node.expression),
                     arg: arg ? _getStartEnd(arg) : undefined,
-                    argNode: arg
+                    argNode: arg,
                 };
             }
             else if (vueCompilerOptions.macros.defineEmits.includes(callText)) {
                 defineEmits = {
                     ...parseCallExpressionAssignment(node, parent),
-                    statement: getStatementRange(ts, parents, node, ast)
+                    statement: getStatementRange(ts, parents, node, ast),
                 };
                 if (node.typeArguments?.length && ts.isTypeLiteralNode(node.typeArguments[0])) {
                     for (const member of node.typeArguments[0].members) {
@@ -195,7 +195,7 @@ function parseScriptSetupRanges(ts, ast, vueCompilerOptions) {
             else if (vueCompilerOptions.macros.defineSlots.includes(callText)) {
                 defineSlots = {
                     ...parseCallExpressionAssignment(node, parent),
-                    statement: getStatementRange(ts, parents, node, ast)
+                    statement: getStatementRange(ts, parents, node, ast),
                 };
             }
             else if (vueCompilerOptions.macros.defineExpose.includes(callText)) {
@@ -274,20 +274,20 @@ function parseBindingRanges(ts, ast) {
         else if (ts.isFunctionDeclaration(node)) {
             if (node.name && ts.isIdentifier(node.name)) {
                 bindings.push({
-                    range: _getStartEnd(node.name)
+                    range: _getStartEnd(node.name),
                 });
             }
         }
         else if (ts.isClassDeclaration(node)) {
             if (node.name) {
                 bindings.push({
-                    range: _getStartEnd(node.name)
+                    range: _getStartEnd(node.name),
                 });
             }
         }
         else if (ts.isEnumDeclaration(node)) {
             bindings.push({
-                range: _getStartEnd(node.name)
+                range: _getStartEnd(node.name),
             });
         }
         if (ts.isImportDeclaration(node)) {
@@ -298,7 +298,7 @@ function parseBindingRanges(ts, ast) {
                     bindings.push({
                         range: _getStartEnd(name),
                         moduleName,
-                        isDefaultImport: true
+                        isDefaultImport: true,
                     });
                 }
                 if (namedBindings) {
@@ -310,7 +310,7 @@ function parseBindingRanges(ts, ast) {
                             bindings.push({
                                 range: _getStartEnd(element.name),
                                 moduleName,
-                                isDefaultImport: element.propertyName?.text === 'default'
+                                isDefaultImport: element.propertyName?.text === 'default',
                             });
                         }
                     }
@@ -318,7 +318,7 @@ function parseBindingRanges(ts, ast) {
                         bindings.push({
                             range: _getStartEnd(namedBindings.name),
                             moduleName,
-                            isNamespace: true
+                            isNamespace: true,
                         });
                     }
                 }

package/lib/plugins/file-html.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const sfcBlockReg = /\<(script|style)\b([\s\S]*?)\>([\s\S]*?)\<\/\1\>/g;
-const langReg = /\blang\s*=\s*(['\"]?)(\S*)\b\1/;
+const sfcBlockReg = /<(script|style)\b([\s\S]*?)>([\s\S]*?)<\/\1>/g;
+const langReg = /\blang\s*=\s*(['"]?)(\S*)\b\1/;
 const plugin = ({ vueCompilerOptions }) => {
     return {
         version: 2.1,
@@ -83,7 +83,7 @@ const plugin = ({ vueCompilerOptions }) => {
                 ast: {},
             };
             return sfc;
-        }
+        },
     };
 };
 exports.default = plugin;

package/lib/plugins/file-md.js

@@ -8,9 +8,9 @@ const frontmatterReg = /^---[\s\S]*?\n---(?:\r?\n|$)/;
 const codeblockReg = /(`{3,})[\s\S]+?\1/g;
 const inlineCodeblockReg = /`[^\n`]+?`/g;
 const latexBlockReg = /(\${2,})[\s\S]+?\1/g;
-const scriptSetupReg = /\\\<[\s\S]+?\>\n?/g;
-const sfcBlockReg = /\<(script|style)\b[\s\S]*?\>([\s\S]*?)\<\/\1\>/g;
-const angleBracketReg = /\<\S*\:\S*\>/g;
+const scriptSetupReg = /\\<[\s\S]+?>\n?/g;
+const sfcBlockReg = /<(script|style)\b[\s\S]*?>([\s\S]*?)<\/\1>/g;
+const angleBracketReg = /<\S*:\S*>/g;
 const linkReg = /\[[\s\S]*?\]\([\s\S]*?\)/g;
 const codeSnippetImportReg = /^\s*<<<\s*.+/gm;
 const plugin = ({ vueCompilerOptions }) => {
@@ -92,7 +92,7 @@ const plugin = ({ vueCompilerOptions }) => {
                     break;
                 }
             }
-        }
+        },
     };
 };
 exports.default = plugin;

package/lib/plugins/vue-template-inline-ts.js

@@ -85,7 +85,7 @@ const plugin = ctx => {
                         && prop.exp.constType !== CompilerDOM.ConstantTypes.CAN_STRINGIFY // style='z-index: 2' will compile to {'z-index':'2'}
                     ) {
                         if (prop.name === 'on' && prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
-                            const ast = (0, utils_1.createTsAst)(ctx.modules.typescript, prop.exp, prop.exp.content);
+                            const ast = (0, utils_1.createTsAst)(ctx.modules.typescript, sfc.template.ast, prop.exp.content);
                             if ((0, elementEvents_1.isCompoundExpression)(ctx.modules.typescript, ast)) {
                                 addFormatCodes(prop.exp.loc.source, prop.exp.loc.start.offset, formatBrackets.event);
                             }
@@ -179,7 +179,7 @@ const plugin = ctx => {
                     else {
                         addFormatCodes(content, start, [
                             firstLineEmpty ? '(' : '(0 +',
-                            lastLineEmpty ? ');' : '+ 0);'
+                            lastLineEmpty ? ');' : '+ 0);',
                         ]);
                     }
                 }

package/lib/plugins/vue-tsx.d.ts

@@ -149,7 +149,6 @@ export declare const tsCodegen: WeakMap<Sfc, {
         };
         codeFeatures: {
             all: import("../types").VueCodeInformation;
-            none: import("../types").VueCodeInformation;
             verification: import("../types").VueCodeInformation;
             completion: import("../types").VueCodeInformation;
             additionalCompletion: import("../types").VueCodeInformation;
@@ -160,6 +159,7 @@ export declare const tsCodegen: WeakMap<Sfc, {
             navigationAndAdditionalCompletion: import("../types").VueCodeInformation;
             navigationAndVerification: import("../types").VueCodeInformation;
             withoutNavigation: import("../types").VueCodeInformation;
+            semanticWithoutHighlight: import("../types").VueCodeInformation;
             withoutHighlight: import("../types").VueCodeInformation;
             withoutHighlightAndNavigation: import("../types").VueCodeInformation;
             withoutHighlightAndCompletion: import("../types").VueCodeInformation;

package/lib/utils/parseSfc.js

@@ -81,7 +81,7 @@ function createBlock(node, source) {
             start = {
                 line: start.line,
                 column: start.column + offset,
-                offset: start.offset + offset
+                offset: start.offset + offset,
             };
         }
         end = Object.assign({}, start);
@@ -89,14 +89,14 @@ function createBlock(node, source) {
     const loc = {
         source: content,
         start,
-        end
+        end,
     };
     const attrs = {};
     const block = {
         type,
         content,
         loc,
-        attrs
+        attrs,
     };
     node.props.forEach(p => {
         if (p.type === CompilerDOM.NodeTypes.ATTRIBUTE) {

package/lib/utils/ts.js

@@ -21,7 +21,7 @@ function createParsedCommandLineByJson(ts, parseConfigHost, rootDir, json, confi
             const rawOptions = obj?.vueCompilerOptions ?? {};
             resolver.addConfig(rawOptions, path_browserify_1.posix.dirname(configFile.fileName));
         }
-        catch (err) { }
+        catch { }
     }
     const resolvedVueOptions = resolver.build();
     if (skipGlobalTypesSetup) {
@@ -58,7 +58,7 @@ function createParsedCommandLine(ts, parseConfigHost, tsConfigPath, skipGlobalTy
                 const rawOptions = obj?.vueCompilerOptions ?? {};
                 resolver.addConfig(rawOptions, path_browserify_1.posix.dirname(configFile.fileName));
             }
-            catch (err) { }
+            catch { }
         }
         const resolvedVueOptions = resolver.build();
         if (skipGlobalTypesSetup) {
@@ -82,7 +82,7 @@ function createParsedCommandLine(ts, parseConfigHost, tsConfigPath, skipGlobalTy
             vueOptions: resolvedVueOptions,
         };
     }
-    catch (err) {
+    catch {
         // console.warn('Failed to resolve tsconfig path:', tsConfigPath, err);
         return {
             fileNames: [],
@@ -105,7 +105,7 @@ function proxyParseConfigHostForExtendConfigPaths(parseConfigHost) {
                 };
             }
             return target[key];
-        }
+        },
     });
     return {
         host,
@@ -176,7 +176,7 @@ class CompilerOptionsResolver {
             },
             fallthroughComponentNames: [
                 ...defaults.fallthroughComponentNames,
-                ...this.options.fallthroughComponentNames ?? []
+                ...this.options.fallthroughComponentNames ?? [],
             ].map(shared_2.hyphenateTag),
             // https://github.com/vuejs/vue-next/blob/master/packages/compiler-dom/src/transforms/vModel.ts#L49-L51
             // https://vuejs.org/guide/essentials/forms.html#form-input-bindings
@@ -205,7 +205,7 @@ function resolvePath(scriptPath, root) {
             // console.warn('failed to resolve path:', scriptPath, 'require.resolve is not supported in web');
         }
     }
-    catch (error) {
+    catch {
         // console.warn(error);
     }
 }
@@ -261,13 +261,13 @@ function getDefaultCompilerOptions(target = 99, lib = 'vue', strictTemplates = f
         plugins: [],
         experimentalModelPropName: {
             '': {
-                input: true
+                input: true,
             },
             value: {
                 input: { type: 'text' },
                 textarea: true,
-                select: true
-            }
+                select: true,
+            },
         },
     };
 }

package/lib/virtualFile/computedSfc.js

@@ -120,12 +120,29 @@ function computedSfc(ts, plugins, fileName, getSnapshot, getParseResult) {
     };
     function computedTemplateAst(base) {
         let cache;
+        let inlineTsAsts;
+        function updateInlineTsAsts(newAst, oldAst) {
+            const newTsAsts = newAst.__volar_inlineTsAsts ??= new Map();
+            const oldTsAsts = oldAst?.__volar_inlineTsAsts ?? inlineTsAsts;
+            if (oldTsAsts) {
+                for (const [text, ast] of oldTsAsts) {
+                    if (!ast.__volar_used) {
+                        oldTsAsts.delete(text);
+                    }
+                    else {
+                        newTsAsts.set(text, ast);
+                        ast.__volar_used = false;
+                    }
+                }
+            }
+            inlineTsAsts = new Map(newTsAsts);
+        }
         return (0, alien_signals_1.computed)(() => {
             if (cache?.template === base.content) {
                 return {
                     errors: [],
                     warnings: [],
-                    ast: cache?.result.ast,
+                    ast: cache.result.ast,
                 };
             }
             // incremental update
@@ -142,6 +159,7 @@ function computedSfc(ts, plugins, fileName, getSnapshot, getParseResult) {
                         newText,
                     });
                     if (newResult) {
+                        updateInlineTsAsts(newResult.ast, cache.result.ast);
                         cache.template = base.content;
                         cache.snapshot = getUntrackedSnapshot();
                         cache.result = newResult;
@@ -169,6 +187,9 @@ function computedSfc(ts, plugins, fileName, getSnapshot, getParseResult) {
                 let result;
                 try {
                     result = plugin.compileSFCTemplate?.(base.lang, base.content, options);
+                    if (result) {
+                        updateInlineTsAsts(result.ast, cache?.result.ast);
+                    }
                 }
                 catch (e) {
                     const err = e;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-core",
-	"version": "3.0.0-beta.2",
+	"version": "3.0.0-beta.3",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -35,5 +35,5 @@
 			"optional": true
 		}
 	},
-	"gitHead": "ea40288f6fceebb65346732b6de5859c300cf1ee"
+	"gitHead": "17e3beabc13e9eb59a82fb1a9f0252fd6685e444"
 }