@vue/language-core 3.3.1 → 3.3.2

package/lib/codegen/template/elementProps.js

@@ -210,7 +210,7 @@ function* generatePropExp(options, ctx, prop, exp) {
                 ...codeFeatures_1.codeFeatures.withoutHighlightAndCompletion,
                 __shorthandExpression: 'html',
             });
-            if (ctx.scopes.some(scope => scope.has(propVariableName))) {
+            if ((0, interpolation_1.shouldIdentifierSkipped)(ctx, propVariableName)) {
                 yield* codes;
             }
             else if (options.setupRefs.has(propVariableName)) {

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

@@ -4,3 +4,4 @@ export declare function generateInterpolation({ typescript, setupRefs }: {
     typescript: typeof import('typescript');
     setupRefs: Set<string>;
 }, ctx: TemplateCodegenContext, block: IRBlock, data: VueCodeInformation, code: string, start: number, prefix?: string, suffix?: string): Generator<Code>;
+export declare function shouldIdentifierSkipped(ctx: TemplateCodegenContext, text: string): boolean;

package/lib/codegen/template/interpolation.js

@@ -1,95 +1,96 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateInterpolation = generateInterpolation;
+exports.shouldIdentifierSkipped = shouldIdentifierSkipped;
 const shared_1 = require("@vue/shared");
 const collectBindings_1 = require("../../utils/collectBindings");
 const shared_2 = require("../../utils/shared");
 const codeFeatures_1 = require("../codeFeatures");
 const names_1 = require("../names");
 const utils_1 = require("../utils");
+const boundary_1 = require("../utils/boundary");
 // 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({ typescript, setupRefs }, ctx, block, data, code, start, prefix = '', suffix = '') {
-    for (const segment of forEachInterpolationSegment(typescript, setupRefs, ctx, block, code, start, prefix, suffix)) {
-        if (typeof segment === 'string') {
-            yield segment;
-            continue;
-        }
-        let [section, offset, type] = segment;
-        offset -= prefix.length;
-        let addSuffix = '';
-        const overLength = offset + section.length - code.length;
-        if (overLength > 0) {
-            addSuffix = section.slice(section.length - overLength);
-            section = section.slice(0, -overLength);
-        }
-        if (offset < 0) {
-            yield section.slice(0, -offset);
-            section = section.slice(-offset);
-            offset = 0;
-        }
-        const shouldSkip = section.length === 0 && type === 'startEnd';
-        if (!shouldSkip) {
-            yield [
-                section,
-                block.name,
-                start + offset,
-                type === 'errorMappingOnly'
-                    ? codeFeatures_1.codeFeatures.verification
-                    : type === 'shorthand'
-                        ? { ...data, __shorthandExpression: 'js' }
-                        : data,
-            ];
-        }
-        yield addSuffix;
+    if (prefix) {
+        yield prefix;
     }
-}
-function* forEachInterpolationSegment(ts, setupRefs, ctx, block, originalCode, start, prefix, suffix) {
-    const code = prefix + originalCode + suffix;
     let prevEnd = 0;
-    for (const [name, offset, isShorthand] of forEachIdentifiers(ts, ctx, block, originalCode, code, prefix)) {
+    for (const [name, offset, isShorthand] of forEachIdentifiers(typescript, ctx, block, code, prefix, suffix)) {
         if (isShorthand) {
-            yield [code.slice(prevEnd, offset + name.length), prevEnd];
+            yield [
+                code.slice(prevEnd, offset + name.length),
+                block.name,
+                start + prevEnd,
+                data,
+            ];
             yield `: `;
         }
-        else {
-            yield [code.slice(prevEnd, offset), prevEnd, prevEnd > 0 ? undefined : 'startEnd'];
+        else if (prevEnd < offset) {
+            yield [
+                code.slice(prevEnd, offset),
+                block.name,
+                start + prevEnd,
+                data,
+            ];
         }
         if (setupRefs.has(name)) {
-            yield [name, offset];
+            yield [
+                name,
+                block.name,
+                start + offset,
+                data,
+            ];
             yield `.value`;
         }
         else {
-            yield ['', offset, 'errorMappingOnly']; // #1205, #1264
+            // #1205, #1264
+            const token = yield* (0, boundary_1.startBoundary)(block.name, start + offset, codeFeatures_1.codeFeatures.verification);
             if (ctx.dollarVars.has(name)) {
                 yield names_1.names.dollars;
             }
             else {
-                ctx.recordComponentAccess(block.name, name, start - prefix.length + offset);
+                ctx.recordComponentAccess(block.name, name, start + offset);
                 yield names_1.names.ctx;
             }
             yield `.`;
-            yield [name, offset, isShorthand ? 'shorthand' : undefined];
+            yield [
+                name,
+                block.name,
+                start + offset,
+                isShorthand
+                    ? { ...data, __shorthandExpression: 'js' }
+                    : data,
+            ];
+            yield (0, boundary_1.endBoundary)(token, start + offset + name.length);
         }
         prevEnd = offset + name.length;
     }
     if (prevEnd < code.length) {
-        yield [code.slice(prevEnd), prevEnd, 'startEnd'];
+        yield [
+            code.slice(prevEnd),
+            block.name,
+            start + prevEnd,
+            data,
+        ];
+    }
+    if (suffix) {
+        yield suffix;
     }
 }
-function* forEachIdentifiers(ts, ctx, block, originalCode, code, prefix) {
-    if (utils_1.identifierRegex.test(originalCode) && !shouldIdentifierSkipped(ctx, originalCode)) {
-        yield [originalCode, prefix.length, false];
+function* forEachIdentifiers(ts, ctx, block, code, prefix, suffix) {
+    if (utils_1.identifierRegex.test(code) && !shouldIdentifierSkipped(ctx, code)) {
+        yield [code, 0, false];
         return;
     }
     const endScope = ctx.startScope();
-    const ast = (0, utils_1.getTypeScriptAST)(ts, block, code);
+    const ast = (0, utils_1.getTypeScriptAST)(ts, block, prefix + code + suffix);
     for (const [id, isShorthand] of forEachDeclarations(ts, ast, ast, ctx)) {
         const text = (0, shared_2.getNodeText)(ts, id, ast);
         if (shouldIdentifierSkipped(ctx, text)) {
             continue;
         }
-        yield [text, (0, shared_2.getStartEnd)(ts, id, ast).start, isShorthand];
+        yield [text, (0, shared_2.getStartEnd)(ts, id, ast).start - prefix.length, isShorthand];
     }
     endScope();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vue/language-core",
-	"version": "3.3.1",
+	"version": "3.3.2",
 	"license": "MIT",
 	"files": [
 		"index.d.ts",
@@ -34,5 +34,5 @@
 		"@volar/typescript": "2.4.28",
 		"@vue/compiler-sfc": "^3.5.0"
 	},
-	"gitHead": "9109bf31282c3d92ca0dd1825b0872a59b572b84"
+	"gitHead": "7a00047bb6d133bf26fa6e916e856fdca40b3c49"
 }

package/types/template-helpers.d.ts

@@ -109,7 +109,7 @@ declare global {
 	};
 	type __VLS_PrettifyGlobal<T> = (T extends any ? { [K in keyof T]: T[K] } : { [K in keyof T as K]: T[K] }) & {};
 
-	function __VLS_vFor<T>(source: T): T extends number ? [number, number][]
+	function __VLS_vFor<const T>(source: T): T extends number ? [number, number][]
 		: T extends string ? [string, number][]
 		: T extends readonly (infer U)[] ? [U, number][]
 		: T extends Iterable<infer V> ? [V, number][]