@vue/language-core 2.0.7 → 2.0.11

package/lib/generators/template.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.eachElementNode = exports.generate = void 0;
+exports.forEachElementNode = exports.parseVForNode = exports.parseInterpolationNode = exports.isCompoundExpression = exports.createTsAst = exports.generate = void 0;
 const language_core_1 = require("@volar/language-core");
 const CompilerDOM = require("@vue/compiler-dom");
 const shared_1 = require("@vue/shared");
@@ -36,15 +36,6 @@ const presetInfos = {
     slotNameExport: (0, utils_1.disableAllFeatures)({ semantic: { shouldHighlight: () => false }, verification: true, navigation: true, /* __navigationCodeLens: true */ }),
     refAttr: (0, utils_1.disableAllFeatures)({ navigation: true }),
 };
-const formatBrackets = {
-    normal: ['`${', '}`;'],
-    // fix https://github.com/vuejs/language-tools/issues/3572
-    params: ['(', ') => {}'],
-    // fix https://github.com/vuejs/language-tools/issues/1210
-    // fix https://github.com/vuejs/language-tools/issues/2305
-    curly: ['0 +', '+ 0;'],
-    event: ['() => ', ';'],
-};
 const validTsVarReg = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
 const colonReg = /:/g;
 // @ts-ignore
@@ -64,41 +55,39 @@ const transformContext = {
 };
 function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGenerateScopedClasses, stylesScopedClasses, hasScriptSetupSlots, slotsAssignName, propsAssignName, codegenStack) {
     const processDirectiveComment = (code) => {
-        if (ignoreError && typeof code !== 'string') {
-            const data = code[3];
-            if (data.verification) {
-                code[3] = {
-                    ...data,
-                    verification: false,
-                };
+        if (typeof code !== 'string') {
+            if (ignoreError) {
+                const data = code[3];
+                if (data.verification) {
+                    code[3] = {
+                        ...data,
+                        verification: false,
+                    };
+                }
             }
-        }
-        if (expectErrorToken && typeof code !== 'string') {
-            const token = expectErrorToken;
-            const data = code[3];
-            if (data.verification) {
-                code[3] = {
-                    ...data,
-                    verification: {
-                        shouldReport: () => {
-                            token.errors++;
-                            return false;
+            if (expectErrorToken) {
+                const token = expectErrorToken;
+                const data = code[3];
+                if (data.verification && (typeof data.verification !== 'object' || !data.verification.shouldReport)) {
+                    code[3] = {
+                        ...data,
+                        verification: {
+                            shouldReport: () => {
+                                token.errors++;
+                                return false;
+                            },
                         },
-                    },
-                };
+                    };
+                }
             }
+            code[3].structure = false;
+            code[3].format = false;
         }
         return code;
     };
     const _ts = codegenStack
-        ? (code) => ['ts', processDirectiveComment(code), (0, utils_1.getStack)()]
-        : (code) => ['ts', processDirectiveComment(code), ''];
-    const _tsFormat = codegenStack
-        ? (code) => ['tsFormat', code, (0, utils_1.getStack)()]
-        : (code) => ['tsFormat', code, ''];
-    const _inlineCss = codegenStack
-        ? (code) => ['inlineCss', code, (0, utils_1.getStack)()]
-        : (code) => ['inlineCss', code, ''];
+        ? (code) => [processDirectiveComment(code), (0, utils_1.getStack)()]
+        : (code) => [processDirectiveComment(code), ''];
     const nativeTags = new Set(vueCompilerOptions.nativeTags);
     const slots = new Map();
     const slotExps = new Map();
@@ -113,7 +102,6 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
     let hasSlot = false;
     let ignoreError = false;
     let expectErrorToken;
-    let expectedErrorNode;
     let elementIndex = 0;
     if (slotsAssignName) {
         localVars.set(slotsAssignName, 1);
@@ -142,7 +130,7 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
         if (!template.ast) {
             return tagOffsetsMap;
         }
-        for (const node of eachElementNode(template.ast)) {
+        for (const node of forEachElementNode(template.ast)) {
             if (node.tag === 'slot') {
                 // ignore
             }
@@ -177,13 +165,13 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
         }
         return tagOffsetsMap;
     }
-    function* generateExpectErrorComment() {
-        if (expectErrorToken && expectedErrorNode) {
+    function* resetDirectiveComments(endStr) {
+        if (expectErrorToken) {
             const token = expectErrorToken;
             yield _ts([
                 '',
                 'template',
-                expectedErrorNode.loc.start.offset,
+                expectErrorToken.node.loc.start.offset,
                 (0, utils_1.disableAllFeatures)({
                     verification: {
                         shouldReport: () => token.errors === 0,
@@ -194,14 +182,17 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
             yield _ts([
                 '',
                 'template',
-                expectedErrorNode.loc.end.offset,
+                expectErrorToken.node.loc.end.offset,
                 (0, utils_1.disableAllFeatures)({ __combineLastMapping: true }),
             ]);
             yield _ts('\n;\n');
+            expectErrorToken = undefined;
+            yield _ts(`// @vue-expect-error ${endStr}\n`);
+        }
+        if (ignoreError) {
+            ignoreError = false;
+            yield _ts(`// @vue-ignore ${endStr}\n`);
         }
-        ignoreError = false;
-        expectErrorToken = undefined;
-        expectedErrorNode = undefined;
     }
     function* generateCanonicalComponentName(tagText, offset, info) {
         if (validTsVarReg.test(tagText)) {
@@ -303,18 +294,22 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
         }
     }
     function* generateAstNode(node, parentEl, prevNode, componentCtxVar) {
-        yield* generateExpectErrorComment();
         if (prevNode?.type === CompilerDOM.NodeTypes.COMMENT) {
             const commentText = prevNode.content.trim().split(' ')[0];
             if (commentText.match(/^@vue-skip\b[\s\S]*/)) {
+                yield _ts('// @vue-skip\n');
                 return;
             }
-            else if (commentText.match(/^@vue-ignore\b[\s\S]*/)) {
+            else if (commentText.match(/^@vue-ignore\b[\s\S]*/) && !ignoreError) {
                 ignoreError = true;
+                yield _ts('// @vue-ignore start\n');
             }
-            else if (commentText.match(/^@vue-expect-error\b[\s\S]*/)) {
-                expectErrorToken = { errors: 0 };
-                expectedErrorNode = prevNode;
+            else if (commentText.match(/^@vue-expect-error\b[\s\S]*/) && !expectErrorToken) {
+                expectErrorToken = {
+                    errors: 0,
+                    node: prevNode,
+                };
+                yield _ts('// @vue-expect-error start\n');
             }
         }
         if (node.type === CompilerDOM.NodeTypes.ROOT) {
@@ -323,7 +318,7 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
                 yield* generateAstNode(childNode, parentEl, prev, componentCtxVar);
                 prev = childNode;
             }
-            yield* generateExpectErrorComment();
+            yield* resetDirectiveComments('end of root');
         }
         else if (node.type === CompilerDOM.NodeTypes.ELEMENT) {
             const vForNode = getVForNode(node);
@@ -352,24 +347,9 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
         }
         else if (node.type === CompilerDOM.NodeTypes.INTERPOLATION) {
             // {{ ... }}
-            let content = node.content.loc.source;
-            let start = node.content.loc.start.offset;
-            let leftCharacter;
-            let rightCharacter;
-            // fix https://github.com/vuejs/language-tools/issues/1787
-            while ((leftCharacter = template.content.substring(start - 1, start)).trim() === '' && leftCharacter.length) {
-                start--;
-                content = leftCharacter + content;
-            }
-            while ((rightCharacter = template.content.substring(start + content.length, start + content.length + 1)).trim() === '' && rightCharacter.length) {
-                content = content + rightCharacter;
-            }
+            const [content, start] = parseInterpolationNode(node, template.content);
             yield* generateInterpolation(content, node.content.loc, start, presetInfos.all, '(', ');\n');
-            const lines = content.split('\n');
-            yield* generateTsFormat(content, start, lines.length <= 1 ? formatBrackets.curly : [
-                lines[0].trim() === '' ? '(' : formatBrackets.curly[0],
-                lines[lines.length - 1].trim() === '' ? ')' : formatBrackets.curly[1],
-            ]);
+            yield* resetDirectiveComments('end of INTERPOLATION');
         }
         else if (node.type === CompilerDOM.NodeTypes.IF) {
             // v-if / v-else-if / v-else
@@ -401,17 +381,16 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
                 yield _ts(` `);
                 yield* generateInterpolation(branch.condition.content, branch.condition.loc, branch.condition.loc.start.offset, presetInfos.all, '(', ')');
                 blockConditions.push((0, language_core_1.toString)([...generateInterpolation(branch.condition.content, branch.condition.loc, undefined, undefined, '(', ')')]
-                    .map(code => code[1])));
+                    .map(([code]) => code)));
                 addedBlockCondition = true;
-                yield* generateTsFormat(branch.condition.content, branch.condition.loc.start.offset, formatBrackets.normal);
             }
             yield _ts(` {\n`);
+            yield* resetDirectiveComments('end of v-if start');
             let prev;
             for (const childNode of branch.children) {
                 yield* generateAstNode(childNode, parentEl, prev, componentCtxVar);
                 prev = childNode;
             }
-            yield* generateExpectErrorComment();
             yield* generateExtraAutoImport();
             yield _ts('}\n');
             if (addedBlockCondition) {
@@ -421,19 +400,17 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
         blockConditions.length = originalBlockConditionsLength;
     }
     function* generateVFor(node, parentEl, componentCtxVar) {
-        const { source, value, key, index } = node.parseResult;
-        const leftExpressionRange = value ? { start: (value ?? key ?? index).loc.start.offset, end: (index ?? key ?? value).loc.end.offset } : undefined;
-        const leftExpressionText = leftExpressionRange ? node.loc.source.substring(leftExpressionRange.start - node.loc.start.offset, leftExpressionRange.end - node.loc.start.offset) : undefined;
+        const { source } = node.parseResult;
+        const { leftExpressionRange, leftExpressionText } = parseVForNode(node);
         const forBlockVars = [];
         yield _ts(`for (const [`);
         if (leftExpressionRange && leftExpressionText) {
-            const collectAst = createTsAst(node.parseResult, `const [${leftExpressionText}]`);
+            const collectAst = createTsAst(ts, node.parseResult, `const [${leftExpressionText}]`);
             (0, transform_1.collectVars)(ts, collectAst, collectAst, forBlockVars);
             for (const varName of forBlockVars) {
                 localVars.set(varName, (localVars.get(varName) ?? 0) + 1);
             }
             yield _ts([leftExpressionText, 'template', leftExpressionRange.start, presetInfos.all]);
-            yield* generateTsFormat(leftExpressionText, leftExpressionRange.start, formatBrackets.normal);
         }
         yield _ts(`] of __VLS_getVForSourceType`);
         if (source.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
@@ -441,15 +418,14 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
             yield* generateInterpolation(source.content, source.loc, source.loc.start.offset, presetInfos.all, '(', ')');
             yield _ts('!)'); // #3102
             yield _ts(') {\n');
+            yield* resetDirectiveComments('end of v-for start');
             let prev;
             for (const childNode of node.children) {
                 yield* generateAstNode(childNode, parentEl, prev, componentCtxVar);
                 prev = childNode;
             }
-            yield* generateExpectErrorComment();
             yield* generateExtraAutoImport();
             yield _ts('}\n');
-            yield* generateTsFormat(source.content, source.loc.start.offset, formatBrackets.normal);
         }
         for (const varName of forBlockVars) {
             localVars.set(varName, localVars.get(varName) - 1);
@@ -595,12 +571,7 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
         for (const failedExp of propsFailedExps) {
             yield* generateInterpolation(failedExp.loc.source, failedExp.loc, failedExp.loc.start.offset, presetInfos.all, '(', ')');
             yield _ts(';\n');
-            const fb = formatBrackets.normal;
-            if (fb) {
-                yield* generateTsFormat(failedExp.loc.source, failedExp.loc.start.offset, fb);
-            }
         }
-        yield* generateInlineCss(props);
         const vScope = props.find(prop => prop.type === CompilerDOM.NodeTypes.DIRECTIVE && (prop.name === 'scope' || prop.name === 'data'));
         let inScope = false;
         let originalConditionsNum = blockConditions.length;
@@ -644,10 +615,10 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
             }
             const slotBlockVars = [];
             yield _ts(`{\n`);
+            yield* resetDirectiveComments('end of element slot start');
             let hasProps = false;
             if (slotDir?.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
-                yield* generateTsFormat(slotDir.exp.content, slotDir.exp.loc.start.offset, formatBrackets.params);
-                const slotAst = createTsAst(slotDir, `(${slotDir.exp.content}) => {}`);
+                const slotAst = createTsAst(ts, slotDir, `(${slotDir.exp.content}) => {}`);
                 (0, transform_1.collectVars)(ts, slotAst, slotAst, slotBlockVars);
                 hasProps = true;
                 if (slotDir.exp.content.indexOf(':') === -1) {
@@ -695,8 +666,6 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
                 yield* generateAstNode(childNode, parentEl, prev, componentCtxVar);
                 prev = childNode;
             }
-            yield* generateExpectErrorComment();
-            yield* generateExtraAutoImport();
             slotBlockVars.forEach(varName => {
                 localVars.set(varName, localVars.get(varName) - 1);
             });
@@ -717,15 +686,16 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
                 ]);
                 yield _ts(`'/* empty slot name completion */]\n`);
             }
+            yield* generateExtraAutoImport();
             yield _ts(`}\n`);
         }
         else {
+            yield* resetDirectiveComments('end of element children start');
             let prev;
             for (const childNode of node.children) {
                 yield* generateAstNode(childNode, parentEl, prev, componentCtxVar);
                 prev = childNode;
             }
-            yield* generateExpectErrorComment();
             // fix https://github.com/vuejs/language-tools/issues/932
             if (!hasSlotElements.has(node) && node.children.length) {
                 yield _ts(`(${componentCtxVar}.slots!).`);
@@ -813,35 +783,17 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
                 // https://github.com/johnsoncodehk/vue-tsc/issues/67
                 yield* generateInterpolation(prop.exp.content, prop.exp.loc, prop.exp.loc.start.offset, presetInfos.all, '$event => {(', ')}');
                 yield _ts(';\n');
-                yield* generateTsFormat(prop.exp.content, prop.exp.loc.start.offset, formatBrackets.normal);
             }
         }
     }
     function* appendExpressionNode(prop) {
         if (prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
-            const ast = createTsAst(prop.exp, prop.exp.content);
-            let isCompoundExpression = true;
-            if (ast.statements.length === 1) {
-                ts.forEachChild(ast, child_1 => {
-                    if (ts.isExpressionStatement(child_1)) {
-                        ts.forEachChild(child_1, child_2 => {
-                            if (ts.isArrowFunction(child_2)) {
-                                isCompoundExpression = false;
-                            }
-                            else if (ts.isIdentifier(child_2)) {
-                                isCompoundExpression = false;
-                            }
-                        });
-                    }
-                    else if (ts.isFunctionDeclaration(child_1)) {
-                        isCompoundExpression = false;
-                    }
-                });
-            }
             let prefix = '(';
             let suffix = ')';
             let isFirstMapping = true;
-            if (isCompoundExpression) {
+            const ast = createTsAst(ts, prop.exp, prop.exp.content);
+            const _isCompoundExpression = isCompoundExpression(ts, ast);
+            if (_isCompoundExpression) {
                 yield _ts('$event => {\n');
                 localVars.set('$event', (localVars.get('$event') ?? 0) + 1);
                 prefix = '';
@@ -851,19 +803,18 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
                 }
             }
             yield* generateInterpolation(prop.exp.content, prop.exp.loc, prop.exp.loc.start.offset, () => {
-                if (isCompoundExpression && isFirstMapping) {
+                if (_isCompoundExpression && isFirstMapping) {
                     isFirstMapping = false;
                     return presetInfos.allWithHiddenParam;
                 }
                 return presetInfos.all;
             }, prefix, suffix);
-            if (isCompoundExpression) {
+            if (_isCompoundExpression) {
                 localVars.set('$event', localVars.get('$event') - 1);
                 yield _ts(';\n');
                 yield* generateExtraAutoImport();
                 yield _ts('}\n');
             }
-            yield* generateTsFormat(prop.exp.content, prop.exp.loc.start.offset, isCompoundExpression ? formatBrackets.event : formatBrackets.normal);
         }
         else {
             yield _ts(`() => {}`);
@@ -942,9 +893,6 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
                     const isShorthand = prop.arg?.loc.start.offset === prop.exp?.loc.start.offset; // vue 3.4+
                     if (!isShorthand) {
                         yield* generateInterpolation(prop.exp.loc.source, prop.exp.loc, prop.exp.loc.start.offset, caps_all, '(', ')');
-                        if (mode === 'normal') {
-                            yield* generateTsFormat(prop.exp.loc.source, prop.exp.loc.start.offset, formatBrackets.normal);
-                        }
                     }
                     else {
                         const propVariableName = (0, shared_1.camelize)(prop.exp.loc.source);
@@ -1033,9 +981,6 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
                 yield* generateInterpolation(prop.exp.content, prop.exp.loc, prop.exp.loc.start.offset, caps_all, '(', ')');
                 yield _ts(['', 'template', prop.exp.loc.end.offset, presetInfos.diagnosticOnly]);
                 yield _ts(', ');
-                if (mode === 'normal') {
-                    yield* generateTsFormat(prop.exp.content, prop.exp.loc.start.offset, formatBrackets.normal);
-                }
             }
             else {
                 // comment this line to avoid affecting comments in prop expressions
@@ -1043,32 +988,6 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
             }
         }
     }
-    function* generateInlineCss(props) {
-        for (const prop of props) {
-            if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
-                && prop.name === 'bind'
-                && prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
-                && prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION
-                && prop.arg.content === 'style'
-                && prop.exp.constType === CompilerDOM.ConstantTypes.CAN_STRINGIFY) {
-                const endCrt = prop.arg.loc.source[prop.arg.loc.source.length - 1]; // " | '
-                const start = prop.arg.loc.source.indexOf(endCrt) + 1;
-                const end = prop.arg.loc.source.lastIndexOf(endCrt);
-                const content = prop.arg.loc.source.substring(start, end);
-                yield _inlineCss(`x { `);
-                yield _inlineCss([
-                    content,
-                    'template',
-                    prop.arg.loc.start.offset + start,
-                    (0, utils_1.enableAllFeatures)({
-                        format: false,
-                        structure: false,
-                    }),
-                ]);
-                yield _inlineCss(` }\n`);
-            }
-        }
-    }
     function* generateDirectives(node) {
         for (const prop of node.props) {
             if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
@@ -1081,7 +1000,6 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
                 if (prop.arg?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION && !prop.arg.isStatic) {
                     yield* generateInterpolation(prop.arg.content, prop.arg.loc, prop.arg.loc.start.offset + prop.arg.loc.source.indexOf(prop.arg.content), presetInfos.all, '(', ')');
                     yield _ts(';\n');
-                    yield* generateTsFormat(prop.arg.content, prop.arg.loc.start.offset, formatBrackets.normal);
                 }
                 yield _ts(['', 'template', prop.loc.start.offset, presetInfos.diagnosticOnly]);
                 yield _ts(`__VLS_directiveFunction(__VLS_ctx.`);
@@ -1101,7 +1019,6 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
                     yield _ts(['', 'template', prop.exp.loc.start.offset, presetInfos.diagnosticOnly]);
                     yield* generateInterpolation(prop.exp.content, prop.exp.loc, prop.exp.loc.start.offset, presetInfos.all, '(', ')');
                     yield _ts(['', 'template', prop.exp.loc.end.offset, presetInfos.diagnosticOnly]);
-                    yield* generateTsFormat(prop.exp.content, prop.exp.loc.start.offset, formatBrackets.normal);
                 }
                 else {
                     yield _ts('undefined');
@@ -1277,8 +1194,13 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
         }
         yield _ts('// @ts-ignore\n'); // #2304
         yield _ts('[');
+        const visited = new Set();
         for (const _vars of tempVars) {
             for (const v of _vars) {
+                if (visited.has(v.offset)) {
+                    continue;
+                }
+                visited.add(v.offset);
                 yield _ts([
                     v.text,
                     'template',
@@ -1332,20 +1254,6 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
             offset += part.length + 1;
         }
     }
-    function* generateTsFormat(code, offset, formatWrapper) {
-        yield _tsFormat(formatWrapper[0]);
-        yield _tsFormat([
-            code,
-            'template',
-            offset,
-            (0, utils_1.mergeFeatureSettings)(presetInfos.disabledAll, {
-                format: true,
-                // autoInserts: true, // TODO: support vue-autoinsert-parentheses
-            }),
-        ]);
-        yield _tsFormat(formatWrapper[1]);
-        yield _tsFormat('\n');
-    }
     function* generateObjectProperty(code, offset, info, astHolder, shouldCamelize = false) {
         if (code.startsWith('[') && code.endsWith(']') && astHolder) {
             yield* generateInterpolation(code, astHolder, offset, info, '', '');
@@ -1373,7 +1281,7 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
     }
     function* generateInterpolation(_code, astHolder, start, data, prefix, suffix) {
         const code = prefix + _code + suffix;
-        const ast = createTsAst(astHolder, code);
+        const ast = createTsAst(ts, astHolder, code);
         const vars = [];
         for (let [section, offset, onlyError] of (0, transform_1.eachInterpolationSegment)(ts, code, ast, localVars, accessedGlobalVariables, vueCompilerOptions, vars)) {
             if (offset === undefined) {
@@ -1445,15 +1353,74 @@ function* generate(ts, compilerOptions, vueCompilerOptions, template, shouldGene
             yield _ts(['', 'template', offset + code.length, (0, utils_1.disableAllFeatures)({ __combineLastMapping: true })]);
         }
     }
-    function createTsAst(astHolder, text) {
-        if (astHolder.__volar_ast_text !== text) {
-            astHolder.__volar_ast_text = text;
-            astHolder.__volar_ast = ts.createSourceFile('/a.ts', text, 99);
-        }
-        return astHolder.__volar_ast;
-    }
 }
 exports.generate = generate;
+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);
+    }
+    return astHolder.__volar_ast;
+}
+exports.createTsAst = createTsAst;
+function isCompoundExpression(ts, ast) {
+    let result = true;
+    if (ast.statements.length === 1) {
+        ts.forEachChild(ast, child_1 => {
+            if (ts.isExpressionStatement(child_1)) {
+                ts.forEachChild(child_1, child_2 => {
+                    if (ts.isArrowFunction(child_2)) {
+                        result = false;
+                    }
+                    else if (ts.isIdentifier(child_2)) {
+                        result = false;
+                    }
+                });
+            }
+            else if (ts.isFunctionDeclaration(child_1)) {
+                result = false;
+            }
+        });
+    }
+    return result;
+}
+exports.isCompoundExpression = isCompoundExpression;
+function parseInterpolationNode(node, template) {
+    let content = node.content.loc.source;
+    let start = node.content.loc.start.offset;
+    let leftCharacter;
+    let rightCharacter;
+    // fix https://github.com/vuejs/language-tools/issues/1787
+    while ((leftCharacter = template.substring(start - 1, start)).trim() === '' && leftCharacter.length) {
+        start--;
+        content = leftCharacter + content;
+    }
+    while ((rightCharacter = template.substring(start + content.length, start + content.length + 1)).trim() === '' && rightCharacter.length) {
+        content = content + rightCharacter;
+    }
+    return [
+        content,
+        start,
+    ];
+}
+exports.parseInterpolationNode = parseInterpolationNode;
+function parseVForNode(node) {
+    const { value, key, index } = node.parseResult;
+    const leftExpressionRange = (value || key || index)
+        ? {
+            start: (value ?? key ?? index).loc.start.offset,
+            end: (index ?? key ?? value).loc.end.offset,
+        }
+        : undefined;
+    const leftExpressionText = leftExpressionRange
+        ? node.loc.source.substring(leftExpressionRange.start - node.loc.start.offset, leftExpressionRange.end - node.loc.start.offset)
+        : undefined;
+    return {
+        leftExpressionRange,
+        leftExpressionText,
+    };
+}
+exports.parseVForNode = parseVForNode;
 function getCanonicalComponentName(tagText) {
     return validTsVarReg.test(tagText)
         ? tagText
@@ -1467,21 +1434,21 @@ function getPossibleOriginalComponentNames(tagText) {
             tagText,
         ])];
 }
-function* eachElementNode(node) {
+function* forEachElementNode(node) {
     if (node.type === CompilerDOM.NodeTypes.ROOT) {
         for (const child of node.children) {
-            yield* eachElementNode(child);
+            yield* forEachElementNode(child);
         }
     }
     else if (node.type === CompilerDOM.NodeTypes.ELEMENT) {
         const patchForNode = getVForNode(node);
         if (patchForNode) {
-            yield* eachElementNode(patchForNode);
+            yield* forEachElementNode(patchForNode);
         }
         else {
             yield node;
             for (const child of node.children) {
-                yield* eachElementNode(child);
+                yield* forEachElementNode(child);
             }
         }
     }
@@ -1490,18 +1457,18 @@ function* eachElementNode(node) {
         for (let i = 0; i < node.branches.length; i++) {
             const branch = node.branches[i];
             for (const childNode of branch.children) {
-                yield* eachElementNode(childNode);
+                yield* forEachElementNode(childNode);
             }
         }
     }
     else if (node.type === CompilerDOM.NodeTypes.FOR) {
         // v-for
         for (const child of node.children) {
-            yield* eachElementNode(child);
+            yield* forEachElementNode(child);
         }
     }
 }
-exports.eachElementNode = eachElementNode;
+exports.forEachElementNode = forEachElementNode;
 function needToUnicode(str) {
     return str.indexOf('\\') >= 0 || str.indexOf('\n') >= 0;
 }

package/lib/generators/utils.d.ts

@@ -1,5 +1,4 @@
-import type { Code, CodeAndStack, VueCodeInformation } from '../types';
-export declare function withStack(code: Code): CodeAndStack;
+import type { VueCodeInformation } from '../types';
 export declare function getStack(): string;
 export declare function disableAllFeatures(override: Partial<VueCodeInformation>): VueCodeInformation;
 export declare function enableAllFeatures(override: Partial<VueCodeInformation>): VueCodeInformation;

package/lib/generators/utils.js

@@ -1,10 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeFeatureSettings = exports.enableAllFeatures = exports.disableAllFeatures = exports.getStack = exports.withStack = void 0;
-function withStack(code) {
-    return [code, getStack()];
-}
-exports.withStack = withStack;
+exports.mergeFeatureSettings = exports.enableAllFeatures = exports.disableAllFeatures = exports.getStack = void 0;
 // TODO: import from muggle-string
 function getStack() {
     const stack = new Error().stack;

package/lib/languageModule.d.ts

@@ -1,5 +1,10 @@
 import { type LanguagePlugin } from '@volar/language-core';
 import type * as ts from 'typescript';
-import type { VueCompilerOptions } from './types';
+import type { VueCompilerOptions, VueLanguagePlugin } from './types';
 import { VueGeneratedCode } from './virtualFile/vueFile';
-export declare function createVueLanguagePlugin(ts: typeof import('typescript'), getFileName: (fileId: string) => string, isValidGlobalTypesHolder: (fileName: string) => boolean, compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions, codegenStack?: boolean): LanguagePlugin<VueGeneratedCode>;
+interface _Plugin extends LanguagePlugin<VueGeneratedCode> {
+    getCanonicalFileName: (fileName: string) => string;
+    pluginContext: Parameters<VueLanguagePlugin>[0];
+}
+export declare function createVueLanguagePlugin(ts: typeof import('typescript'), getFileName: (fileId: string) => string, useCaseSensitiveFileNames: boolean, getProjectVersion: () => string, getScriptFileNames: () => string[] | Set<string>, compilerOptions: ts.CompilerOptions, vueCompilerOptions: VueCompilerOptions, codegenStack?: boolean): _Plugin;
+export {};