@vue/language-core 3.3.4 → 3.3.6

package/lib/codegen/template/elementEvents.js

@@ -40,14 +40,15 @@ exports.generateModelEventExpression = generateModelEventExpression;
 exports.isCompoundExpression = isCompoundExpression;
 const CompilerDOM = __importStar(require("@vue/compiler-dom"));
 const shared_1 = require("@vue/shared");
+const utils_1 = require("../../parsers/utils");
 const codeFeatures_1 = require("../codeFeatures");
 const names_1 = require("../names");
-const utils_1 = require("../utils");
+const utils_2 = require("../utils");
 const boundary_1 = require("../utils/boundary");
 const camelized_1 = require("../utils/camelized");
 const interpolation_1 = require("./interpolation");
 function* generateElementEvents(options, ctx, node, componentOriginalVar, getCtxVar, getPropsVar) {
-    const definitions = [];
+    const definitions = {};
     for (const prop of node.props) {
         if (prop.type === CompilerDOM.NodeTypes.DIRECTIVE
             && (prop.name === 'on'
@@ -71,49 +72,51 @@ function* generateElementEvents(options, ctx, node, componentOriginalVar, getCtx
             }
             const propName = (0, shared_1.camelize)(propPrefix + source);
             const emitName = emitPrefix + source;
-            definitions.push({
-                prop,
-                source,
-                offset,
-                emitPrefix,
+            const key = [
+                prop.name,
+                propName,
+                ...prop.modifiers.map(modifier => modifier.content),
+            ].join('+');
+            definitions[key] ??= {
                 propPrefix,
+                emitPrefix,
                 propName,
                 emitName,
+                items: [],
+            };
+            definitions[key].items.push({
+                prop,
+                source,
+                offset,
             });
         }
     }
-    if (!definitions.length) {
+    if (!Object.keys(definitions).length) {
         return;
     }
     const emitsVar = ctx.getInternalVariable();
-    yield `let ${emitsVar}!: ${names_1.names.ResolveEmits}<typeof ${componentOriginalVar}, typeof ${getCtxVar()}.emit>${utils_1.endOfLine}`;
-    yield `const ${ctx.getInternalVariable()}: `;
-    for (let i = 0; i < definitions.length; i++) {
-        const { propName, emitName } = definitions[i];
-        if (i > 0) {
-            yield ` & `;
-        }
-        yield `${names_1.names.NormalizeComponentEvent}<typeof ${getPropsVar()}, typeof ${emitsVar}, '${propName}', '${emitName}', '${(0, shared_1.camelize)(emitName)}'>`;
-    }
-    yield ` = {${utils_1.newLine}`;
-    for (const { prop, source, offset, emitPrefix, propPrefix, propName } of definitions) {
-        if (prop.name === 'on') {
-            yield `...{ `;
-            yield* generateEventArg(options, source, offset, emitPrefix.slice(0, -1), codeFeatures_1.codeFeatures.navigation);
-            yield `: {} as any } as typeof ${emitsVar},${utils_1.newLine}`;
-        }
-        if (prop.name === 'on') {
-            yield* generateEventArg(options, source, offset, propPrefix.slice(0, -1));
-            yield `: `;
-            yield* generateEventExpression(options, ctx, prop);
-        }
-        else {
-            yield `'${propName}': `;
-            yield* generateModelEventExpression(options, ctx, prop);
+    yield `let ${emitsVar}!: ${names_1.names.ResolveEmits}<typeof ${componentOriginalVar}, typeof ${getCtxVar()}.emit>${utils_2.endOfLine}`;
+    for (const { propPrefix, emitPrefix, propName, emitName, items } of Object.values(definitions)) {
+        yield `const ${ctx.getInternalVariable()}: ${names_1.names.ResolveEvent}<typeof ${getPropsVar()}, typeof ${emitsVar}, '${propName}', '${emitName}', '${(0, shared_1.camelize)(emitName)}'> = {${utils_2.newLine}`;
+        for (const { prop, source, offset } of items) {
+            if (prop.name === 'on') {
+                yield `/** @type {typeof ${emitsVar}.`;
+                yield* generateEventArg(options, source, offset, emitPrefix.slice(0, -1), codeFeatures_1.codeFeatures.navigation);
+                yield `} */${utils_2.newLine}`;
+            }
+            if (prop.name === 'on') {
+                yield* generateEventArg(options, source, offset, propPrefix.slice(0, -1));
+                yield `: `;
+                yield* generateEventExpression(options, ctx, prop);
+            }
+            else {
+                yield `'${propName}': `;
+                yield* generateModelEventExpression(options, ctx, prop);
+            }
+            yield `,${utils_2.newLine}`;
         }
-        yield `,${utils_1.newLine}`;
+        yield `}${utils_2.endOfLine}`;
     }
-    yield `}${utils_1.endOfLine}`;
 }
 function* generateEventArg(options, name, start, directive = 'on', features) {
     features ??= {
@@ -126,33 +129,36 @@ function* generateEventArg(options, name, start, directive = 'on', features) {
     if (directive.length) {
         name = (0, shared_1.capitalize)(name);
     }
-    if (utils_1.identifierRegex.test((0, shared_1.camelize)(name))) {
-        const token = yield* (0, boundary_1.startBoundary)('template', start, features);
+    if (utils_2.identifierRE.test((0, shared_1.camelize)(name))) {
+        const boundary = yield* boundary_1.Boundary.start('template', start, features);
         yield directive;
-        yield* (0, camelized_1.generateCamelized)(name, 'template', start, { __combineToken: token });
+        yield* (0, camelized_1.generateCamelized)(name, 'template', start, boundary.features);
     }
     else {
-        const token = yield* (0, boundary_1.startBoundary)('template', start, features);
+        const boundary = yield* boundary_1.Boundary.start('template', start, features);
         yield `'`;
         yield directive;
-        yield* (0, camelized_1.generateCamelized)(name, 'template', start, { __combineToken: token });
+        yield* (0, camelized_1.generateCamelized)(name, 'template', start, boundary.features);
         yield `'`;
-        yield (0, boundary_1.endBoundary)(token, start + name.length);
+        yield boundary.end(start + name.length);
     }
 }
 function* generateEventExpression(options, ctx, prop) {
     if (prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
-        const ast = (0, utils_1.getTypeScriptAST)(options.typescript, options.template, prop.exp.content);
+        const ast = (0, utils_2.getTypeScriptAST)(options.typescript, options.template, prop.exp.content);
         const isCompound = isCompoundExpression(options.typescript, ast);
         const interpolation = (0, interpolation_1.generateInterpolation)(options, ctx, options.template, codeFeatures_1.codeFeatures.all, prop.exp.content, prop.exp.loc.start.offset, isCompound ? `` : `(`, isCompound ? `` : `)`);
         if (isCompound) {
-            yield `(...[$event]) => {${utils_1.newLine}`;
-            const endScope = ctx.startScope();
-            ctx.declare('$event');
+            yield `(...[$event]) => {${utils_2.newLine}`;
+            const scope = ctx.scope();
+            scope.declare('$event');
             yield* ctx.generateConditionGuards();
+            if (isSingleExpression(options.typescript, ast)) {
+                yield `return `;
+            }
             yield* interpolation;
-            yield utils_1.endOfLine;
-            yield* endScope();
+            yield utils_2.endOfLine;
+            yield* scope.end();
             yield `}`;
             ctx.inlayHints.push({
                 blockName: 'template',
@@ -177,10 +183,10 @@ function* generateEventExpression(options, ctx, prop) {
 }
 function* generateModelEventExpression(options, ctx, prop) {
     if (prop.exp?.type === CompilerDOM.NodeTypes.SIMPLE_EXPRESSION) {
-        yield `(...[$event]) => {${utils_1.newLine}`;
+        yield `(...[$event]) => {${utils_2.newLine}`;
         yield* ctx.generateConditionGuards();
         yield* (0, interpolation_1.generateInterpolation)(options, ctx, options.template, codeFeatures_1.codeFeatures.verification, prop.exp.content, prop.exp.loc.start.offset);
-        yield ` = $event${utils_1.endOfLine}`;
+        yield ` = $event${utils_2.endOfLine}`;
         yield `}`;
     }
     else {
@@ -188,35 +194,32 @@ function* generateModelEventExpression(options, ctx, prop) {
     }
 }
 function isCompoundExpression(ts, ast) {
-    let result = true;
     if (ast.statements.length === 0) {
-        result = false;
-    }
-    else 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 (isPropertyAccessOrId(ts, child_2)) {
-                        result = false;
-                    }
-                });
-            }
-            else if (ts.isFunctionDeclaration(child_1)) {
-                result = false;
+        return false;
+    }
+    if (ast.statements.length === 1 && ast.text[ast.endOfFileToken.pos - 1] !== ';') {
+        const statement = ast.statements[0];
+        if (ts.isExpressionStatement(statement)) {
+            const node = (0, utils_1.getUnwrappedExpression)(ts, statement.expression);
+            if (ts.isArrowFunction(node)
+                || ts.isIdentifier(node)
+                || ts.isElementAccessExpression(node)
+                || ts.isPropertyAccessExpression(node)) {
+                return false;
             }
-        });
+        }
+        else if (ts.isFunctionDeclaration(statement)) {
+            return false;
+        }
     }
-    return result;
+    return true;
 }
-function isPropertyAccessOrId(ts, node) {
-    if (ts.isIdentifier(node)) {
-        return true;
-    }
-    if (ts.isPropertyAccessExpression(node)) {
-        return isPropertyAccessOrId(ts, node.expression);
+function isSingleExpression(ts, ast) {
+    if (ast.statements.length === 1 && ast.text[ast.endOfFileToken.pos - 1] !== ';') {
+        const statement = ast.statements[0];
+        if (ts.isExpressionStatement(statement)) {
+            return true;
+        }
     }
     return false;
 }

package/lib/codegen/template/elementProps.js

@@ -114,21 +114,21 @@ function* generateElementProps(options, ctx, node, props, checkUnknownProps, fai
             if (shouldSpread) {
                 yield `...{ `;
             }
-            const token = yield* (0, boundary_1.startBoundary)('template', prop.loc.start.offset, codeFeatures_1.codeFeatures.verification);
+            const boundary = yield* boundary_1.Boundary.start('template', prop.loc.start.offset, codeFeatures_1.codeFeatures.verification);
             if (prop.arg) {
                 yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, propName, prop.arg.loc.start.offset, features, shouldCamelize);
             }
             else {
-                const token2 = yield* (0, boundary_1.startBoundary)('template', prop.loc.start.offset, codeFeatures_1.codeFeatures.withoutHighlightAndCompletion);
+                const boundary2 = yield* boundary_1.Boundary.start('template', prop.loc.start.offset, codeFeatures_1.codeFeatures.withoutHighlightAndCompletion);
                 yield propName;
-                yield (0, boundary_1.endBoundary)(token2, prop.loc.start.offset + 'v-model'.length);
+                yield boundary2.end(prop.loc.start.offset + 'v-model'.length);
             }
             yield `: `;
             const argLoc = prop.arg?.loc ?? prop.loc;
-            const token3 = yield* (0, boundary_1.startBoundary)('template', argLoc.start.offset, codeFeatures_1.codeFeatures.verification);
+            const boundary3 = yield* boundary_1.Boundary.start('template', argLoc.start.offset, codeFeatures_1.codeFeatures.verification);
             yield* generatePropExp(options, ctx, prop, prop.exp);
-            yield (0, boundary_1.endBoundary)(token3, argLoc.end.offset);
-            yield (0, boundary_1.endBoundary)(token, prop.loc.end.offset);
+            yield boundary3.end(argLoc.end.offset);
+            yield boundary.end(prop.loc.end.offset);
             if (shouldSpread) {
                 yield ` }`;
             }
@@ -153,7 +153,7 @@ function* generateElementProps(options, ctx, node, props, checkUnknownProps, fai
             if (shouldSpread) {
                 yield `...{ `;
             }
-            const token = yield* (0, boundary_1.startBoundary)('template', prop.loc.start.offset, codeFeatures_1.codeFeatures.verification);
+            const boundary = yield* boundary_1.Boundary.start('template', prop.loc.start.offset, codeFeatures_1.codeFeatures.verification);
             const prefix = options.template.content.slice(prop.loc.start.offset, prop.loc.start.offset + 1);
             if (prefix === '.' || prefix === '#') {
                 // Pug shorthand syntax
@@ -174,7 +174,7 @@ function* generateElementProps(options, ctx, node, props, checkUnknownProps, fai
             else {
                 yield `true`;
             }
-            yield (0, boundary_1.endBoundary)(token, prop.loc.end.offset);
+            yield boundary.end(prop.loc.end.offset);
             if (shouldSpread) {
                 yield ` }`;
             }
@@ -187,10 +187,10 @@ function* generateElementProps(options, ctx, node, props, checkUnknownProps, fai
                 failedPropExps?.push({ node: prop.exp, prefix: `(`, suffix: `)` });
             }
             else {
-                const token = yield* (0, boundary_1.startBoundary)('template', prop.exp.loc.start.offset, codeFeatures_1.codeFeatures.verification);
+                const boundary = yield* boundary_1.Boundary.start('template', prop.exp.loc.start.offset, codeFeatures_1.codeFeatures.verification);
                 yield `...`;
                 yield* generatePropExp(options, ctx, prop, prop.exp);
-                yield (0, boundary_1.endBoundary)(token, prop.exp.loc.end.offset);
+                yield boundary.end(prop.exp.loc.end.offset);
                 yield `,${utils_1.newLine}`;
             }
         }
@@ -205,7 +205,7 @@ function* generatePropExp(options, ctx, prop, exp) {
     }
     else {
         const propVariableName = (0, shared_1.camelize)(exp.loc.source);
-        if (utils_1.identifierRegex.test(propVariableName)) {
+        if (utils_1.identifierRE.test(propVariableName)) {
             const codes = (0, camelized_1.generateCamelized)(exp.loc.source, 'template', exp.loc.start.offset, {
                 ...codeFeatures_1.codeFeatures.withoutHighlightAndCompletion,
                 __shorthandExpression: 'html',
@@ -218,7 +218,7 @@ function* generatePropExp(options, ctx, prop, exp) {
                 yield `.value`;
             }
             else {
-                ctx.recordComponentAccess('template', propVariableName, exp.loc.start.offset);
+                ctx.accessVariable('template', propVariableName, exp.loc.start.offset);
                 yield names_1.names.ctx;
                 yield `.`;
                 yield* codes;

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

@@ -14,8 +14,7 @@ export interface TemplateCodegenOptions {
 }
 export { generate as generateTemplate };
 declare function generate(options: TemplateCodegenOptions): {
-    generatedTypes: Set<string>;
-    currentInfo: {
+    getCommentInfo: () => {
         ignoreError?: boolean;
         expectError?: {
             token: number;
@@ -26,41 +25,70 @@ declare function generate(options: TemplateCodegenOptions): {
             offset: number;
         };
     };
+    enter: (node: import("@vue/compiler-dom").RootNode | import("@vue/compiler-dom").TemplateChildNode | import("@vue/compiler-dom").SimpleExpressionNode) => boolean;
+    exit: () => Generator<Code>;
     resolveCodeFeatures: (features: import("../../types").VueCodeInformation) => import("../../types").VueCodeInformation;
-    inVFor: boolean;
+    getInternalVariable: () => string;
+    scopes: {
+        add(value: string): /*elided*/ any;
+        declare(...variables: string[]): void;
+        end(): Generator<Code, any, any>;
+        clear(): void;
+        delete(value: string): boolean;
+        forEach(callbackfn: (value: string, value2: string, set: Set<string>) => void, thisArg?: any): void;
+        has(value: string): boolean;
+        readonly size: number;
+        [Symbol.iterator](): SetIterator<string>;
+        entries(): SetIterator<[string, string]>;
+        keys(): SetIterator<string>;
+        values(): SetIterator<string>;
+        readonly [Symbol.toStringTag]: string;
+    }[];
+    scope: () => {
+        add(value: string): any;
+        declare(...variables: string[]): void;
+        end(): Generator<Code, any, any>;
+        clear(): void;
+        delete(value: string): boolean;
+        forEach(callbackfn: (value: string, value2: string, set: Set<string>) => void, thisArg?: any): void;
+        has(value: string): boolean;
+        readonly size: number;
+        [Symbol.iterator](): SetIterator<string>;
+        entries(): SetIterator<[string, string]>;
+        keys(): SetIterator<string>;
+        values(): SetIterator<string>;
+        readonly [Symbol.toStringTag]: string;
+    };
+    contextAccesses: Map<string, Map<string, Set<number>>>;
+    accessVariable: (source: string, name: string, offset?: number) => void;
+    generateAutoImport: () => Generator<Code>;
+    conditions: string[];
+    generateConditionGuards: () => Generator<string, void, unknown>;
+    hoistVars: Map<string, string>;
+    getHoistVariable: (originalVar: string) => string;
+    generateHoistVariables: () => Generator<string, void, unknown>;
+    templateRefs: Map<string, {
+        typeExp: string;
+        offset: number;
+    }[]>;
+    addTemplateRef: (name: string, typeExp: string, offset: number) => void;
+    components: (() => string)[];
+    dollarVars: Set<string>;
+    inlayHints: import("../inlayHints").InlayHintInfo[];
+    generatedTypes: Set<string>;
+    inheritedAttrVars: Set<string>;
+    singleRootElTypes: Set<string>;
+    singleRootNodes: Set<import("@vue/compiler-dom").ElementNode | null>;
     slots: {
         name: string;
         offset?: number;
         tagRange: [number, number];
-        nodeLoc: any;
         propsVar: string;
     }[];
     dynamicSlots: {
         expVar: string;
         propsVar: string;
     }[];
-    dollarVars: Set<string>;
-    componentAccessMap: Map<string, Map<string, Set<number>>>;
-    blockConditions: string[];
-    inlayHints: import("../inlayHints").InlayHintInfo[];
-    inheritedAttrVars: Set<string>;
-    templateRefs: Map<string, {
-        typeExp: string;
-        offset: number;
-    }[]>;
-    singleRootElTypes: Set<string>;
-    singleRootNodes: Set<import("@vue/compiler-dom").ElementNode | null>;
-    addTemplateRef(name: string, typeExp: string, offset: number): void;
-    recordComponentAccess(source: string, name: string, offset?: number): void;
-    scopes: Set<string>[];
-    components: (() => string)[];
-    declare(...varNames: string[]): void;
-    startScope(): () => Generator<Code, any, any>;
-    getInternalVariable(): string;
-    getHoistVariable(originalVar: string): string;
-    generateHoistVariables(): Generator<string, void, unknown>;
-    generateConditionGuards(): Generator<string, void, unknown>;
-    enter(node: import("@vue/compiler-dom").RootNode | import("@vue/compiler-dom").TemplateChildNode | import("@vue/compiler-dom").SimpleExpressionNode): boolean;
-    exit(): Generator<Code>;
+    inVFor: boolean;
     codes: Code[];
 };

package/lib/codegen/template/index.js

@@ -21,14 +21,14 @@ function generate(options) {
     return { ...ctx, codes };
 }
 function* generateWorker(options, ctx) {
-    const endScope = ctx.startScope();
-    ctx.declare(...options.setupConsts);
+    const scope = ctx.scope();
+    scope.declare(...options.setupConsts);
     const { slotsAssignName, propsAssignName, vueCompilerOptions, template, } = options;
     if (slotsAssignName) {
-        ctx.declare(slotsAssignName);
+        scope.declare(slotsAssignName);
     }
     if (propsAssignName) {
-        ctx.declare(propsAssignName);
+        scope.declare(propsAssignName);
     }
     if (vueCompilerOptions.inferTemplateDollarSlots) {
         ctx.dollarVars.add('$slots');
@@ -73,7 +73,7 @@ function* generateWorker(options, ctx) {
         }
         yield `} & { [K in keyof import('${vueCompilerOptions.lib}').ComponentPublicInstance]: unknown }${utils_1.endOfLine}`;
     }
-    yield* endScope();
+    yield* scope.end();
 }
 function* generateSlotsType(options, ctx) {
     if (options.hasDefineSlots) {
@@ -94,9 +94,9 @@ function* generateSlotsType(options, ctx) {
             yield* (0, objectProperty_1.generateObjectProperty)(options, ctx, slot.name, slot.offset, codeFeatures_1.codeFeatures.navigation);
         }
         else {
-            const token = yield* (0, boundary_1.startBoundary)('template', slot.tagRange[0], codeFeatures_1.codeFeatures.navigation);
+            const boundary = yield* boundary_1.Boundary.start('template', slot.tagRange[0], codeFeatures_1.codeFeatures.navigation);
             yield `default`;
-            yield (0, boundary_1.endBoundary)(token, slot.tagRange[1]);
+            yield boundary.end(slot.tagRange[1]);
         }
         yield `?: (props: typeof ${slot.propsVar}) => any }`;
     }

package/lib/codegen/template/interpolation.js

@@ -45,12 +45,12 @@ function* generateInterpolation({ typescript, setupRefs }, ctx, block, data, cod
         }
         else {
             // #1205, #1264
-            const token = yield* (0, boundary_1.startBoundary)(block.name, start + offset, codeFeatures_1.codeFeatures.verification);
+            const boundary = yield* boundary_1.Boundary.start(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 + offset);
+                ctx.accessVariable(block.name, name, start + offset);
                 yield names_1.names.ctx;
             }
             yield `.`;
@@ -62,7 +62,7 @@ function* generateInterpolation({ typescript, setupRefs }, ctx, block, data, cod
                     ? { ...data, __shorthandExpression: 'js' }
                     : data,
             ];
-            yield (0, boundary_1.endBoundary)(token, start + offset + name.length);
+            yield boundary.end(start + offset + name.length);
         }
         prevEnd = offset + name.length;
     }
@@ -79,22 +79,22 @@ function* generateInterpolation({ typescript, setupRefs }, ctx, block, data, cod
     }
 }
 function* forEachIdentifiers(ts, ctx, block, code, prefix, suffix) {
-    if (utils_1.identifierRegex.test(code) && !shouldIdentifierSkipped(ctx, code)) {
+    if (utils_1.identifierRE.test(code) && !shouldIdentifierSkipped(ctx, code)) {
         yield [code, 0, false];
         return;
     }
-    const endScope = ctx.startScope();
+    const scope = ctx.scope();
     const ast = (0, utils_1.getTypeScriptAST)(ts, block, prefix + code + suffix);
-    for (const [id, isShorthand] of forEachDeclarations(ts, ast, ast, ctx)) {
+    for (const [id, isShorthand] of forEachDeclarations(ts, ast, ast, ctx, scope)) {
         const text = (0, shared_2.getNodeText)(ts, id, ast);
         if (shouldIdentifierSkipped(ctx, text)) {
             continue;
         }
         yield [text, (0, shared_2.getStartEnd)(ts, id, ast).start - prefix.length, isShorthand];
     }
-    endScope();
+    scope.end();
 }
-function* forEachDeclarations(ts, node, ast, ctx) {
+function* forEachDeclarations(ts, node, ast, ctx, scope) {
     if (ts.isIdentifier(node)) {
         yield [node, false];
     }
@@ -102,16 +102,16 @@ function* forEachDeclarations(ts, node, ast, ctx) {
         yield [node.name, true];
     }
     else if (ts.isPropertyAccessExpression(node)) {
-        yield* forEachDeclarations(ts, node.expression, ast, ctx);
+        yield* forEachDeclarations(ts, node.expression, ast, ctx, scope);
     }
     else if (ts.isVariableDeclaration(node)) {
-        ctx.declare(...(0, collectBindings_1.collectBindingNames)(ts, node.name, ast));
-        yield* forEachDeclarationsInBinding(ts, node, ast, ctx);
+        scope.declare(...(0, collectBindings_1.collectBindingNames)(ts, node.name, ast));
+        yield* forEachDeclarationsInBinding(ts, node, ast, ctx, scope);
     }
     else if (ts.isArrayBindingPattern(node) || ts.isObjectBindingPattern(node)) {
         for (const element of node.elements) {
             if (ts.isBindingElement(element)) {
-                yield* forEachDeclarationsInBinding(ts, element, ast, ctx);
+                yield* forEachDeclarationsInBinding(ts, element, ast, ctx, scope);
             }
         }
     }
@@ -123,18 +123,18 @@ function* forEachDeclarations(ts, node, ast, ctx) {
             if (ts.isPropertyAssignment(prop)) {
                 // fix https://github.com/vuejs/language-tools/issues/1176
                 if (ts.isComputedPropertyName(prop.name)) {
-                    yield* forEachDeclarations(ts, prop.name.expression, ast, ctx);
+                    yield* forEachDeclarations(ts, prop.name.expression, ast, ctx, scope);
                 }
-                yield* forEachDeclarations(ts, prop.initializer, ast, ctx);
+                yield* forEachDeclarations(ts, prop.initializer, ast, ctx, scope);
             }
             // fix https://github.com/vuejs/language-tools/issues/1156
             else if (ts.isShorthandPropertyAssignment(prop)) {
-                yield* forEachDeclarations(ts, prop, ast, ctx);
+                yield* forEachDeclarations(ts, prop, ast, ctx, scope);
             }
             // fix https://github.com/vuejs/language-tools/issues/1148#issuecomment-1094378126
             else if (ts.isSpreadAssignment(prop)) {
                 // TODO: cannot report "Spread types may only be created from object types.ts(2698)"
-                yield* forEachDeclarations(ts, prop.expression, ast, ctx);
+                yield* forEachDeclarations(ts, prop.expression, ast, ctx, scope);
             }
             // fix https://github.com/vuejs/language-tools/issues/4604
             else if (ts.isFunctionLike(prop) && prop.body) {
@@ -147,39 +147,39 @@ function* forEachDeclarations(ts, node, ast, ctx) {
         yield* forEachDeclarationsInTypeNode(ts, node);
     }
     else if (ts.isBlock(node)) {
-        const endScope = ctx.startScope();
+        const scope = ctx.scope();
         for (const child of (0, utils_1.forEachNode)(ts, node)) {
-            yield* forEachDeclarations(ts, child, ast, ctx);
+            yield* forEachDeclarations(ts, child, ast, ctx, scope);
         }
-        endScope();
+        scope.end();
     }
     else {
         for (const child of (0, utils_1.forEachNode)(ts, node)) {
-            yield* forEachDeclarations(ts, child, ast, ctx);
+            yield* forEachDeclarations(ts, child, ast, ctx, scope);
         }
     }
 }
-function* forEachDeclarationsInBinding(ts, node, ast, ctx) {
+function* forEachDeclarationsInBinding(ts, node, ast, ctx, scope) {
     if ('type' in node && node.type) {
         yield* forEachDeclarationsInTypeNode(ts, node.type);
     }
     if (!ts.isIdentifier(node.name)) {
-        yield* forEachDeclarations(ts, node.name, ast, ctx);
+        yield* forEachDeclarations(ts, node.name, ast, ctx, scope);
     }
     if (node.initializer) {
-        yield* forEachDeclarations(ts, node.initializer, ast, ctx);
+        yield* forEachDeclarations(ts, node.initializer, ast, ctx, scope);
     }
 }
 function* forEachDeclarationsInFunction(ts, node, ast, ctx) {
-    const endScope = ctx.startScope();
+    const scope = ctx.scope();
     for (const param of node.parameters) {
-        ctx.declare(...(0, collectBindings_1.collectBindingNames)(ts, param.name, ast));
-        yield* forEachDeclarationsInBinding(ts, param, ast, ctx);
+        scope.declare(...(0, collectBindings_1.collectBindingNames)(ts, param.name, ast));
+        yield* forEachDeclarationsInBinding(ts, param, ast, ctx, scope);
     }
     if (node.body) {
-        yield* forEachDeclarations(ts, node.body, ast, ctx);
+        yield* forEachDeclarations(ts, node.body, ast, ctx, scope);
     }
-    endScope();
+    scope.end();
 }
 function* forEachDeclarationsInTypeNode(ts, node) {
     if (ts.isTypeQueryNode(node)) {

package/lib/codegen/template/objectProperty.js

@@ -18,19 +18,19 @@ function* generateObjectProperty(options, ctx, code, offset, features, shouldCam
         }
     }
     else if (shouldCamelize) {
-        if (utils_1.identifierRegex.test((0, shared_1.camelize)(code))) {
+        if (utils_1.identifierRE.test((0, shared_1.camelize)(code))) {
             yield* (0, camelized_1.generateCamelized)(code, 'template', offset, features);
         }
         else {
-            const token = yield* (0, boundary_1.startBoundary)('template', offset, features);
+            const boundary = yield* boundary_1.Boundary.start('template', offset, features);
             yield `'`;
-            yield* (0, camelized_1.generateCamelized)(code, 'template', offset, { __combineToken: token });
+            yield* (0, camelized_1.generateCamelized)(code, 'template', offset, boundary.features);
             yield `'`;
-            yield (0, boundary_1.endBoundary)(token, offset + code.length);
+            yield boundary.end(offset + code.length);
         }
     }
     else {
-        if (utils_1.identifierRegex.test(code)) {
+        if (utils_1.identifierRE.test(code)) {
             yield [code, 'template', offset, features];
         }
         else {

package/lib/codegen/template/propertyAccess.js

@@ -8,7 +8,7 @@ function* generatePropertyAccess(options, ctx, code, offset, features) {
     if (code.startsWith('[') && code.endsWith(']')) {
         yield* (0, interpolation_1.generateInterpolation)(options, ctx, options.template, features, code, offset);
     }
-    else if (utils_1.identifierRegex.test(code)) {
+    else if (utils_1.identifierRE.test(code)) {
         yield `.`;
         yield [code, 'template', offset, features];
     }