@vue/language-core 3.1.4 → 3.1.6

package/lib/codegen/template/index.js

@@ -2,108 +2,116 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateTemplate = generate;
 const codeFeatures_1 = require("../codeFeatures");
+const names = require("../names");
 const utils_1 = require("../utils");
-const wrapWith_1 = require("../utils/wrapWith");
+const boundary_1 = require("../utils/boundary");
 const context_1 = require("./context");
 const objectProperty_1 = require("./objectProperty");
-const styleScopedClasses_1 = require("./styleScopedClasses");
 const templateChild_1 = require("./templateChild");
 function generate(options) {
-    const context = (0, context_1.createTemplateCodegenContext)(options, options.template.ast);
-    const codegen = generateTemplate(options, context);
+    const ctx = (0, context_1.createTemplateCodegenContext)();
+    const codeGenerator = generateWorker(options, ctx);
     const codes = [];
-    for (const code of codegen) {
+    for (const code of codeGenerator) {
         if (typeof code === 'object') {
-            code[3] = context.resolveCodeFeatures(code[3]);
+            code[3] = ctx.resolveCodeFeatures(code[3]);
         }
         codes.push(code);
     }
-    return {
-        ...context,
-        codes,
-    };
+    return { ...ctx, codes };
 }
-function* generateTemplate(options, ctx) {
-    if (options.slotsAssignName) {
-        ctx.addLocalVariable(options.slotsAssignName);
+function* generateWorker(options, ctx) {
+    const endScope = ctx.startScope();
+    ctx.declare(...options.setupConsts);
+    const { slotsAssignName, propsAssignName, vueCompilerOptions, template, } = options;
+    if (slotsAssignName) {
+        ctx.declare(slotsAssignName);
     }
-    if (options.propsAssignName) {
-        ctx.addLocalVariable(options.propsAssignName);
+    if (propsAssignName) {
+        ctx.declare(propsAssignName);
     }
-    if (options.vueCompilerOptions.inferTemplateDollarSlots) {
+    if (vueCompilerOptions.inferTemplateDollarSlots) {
         ctx.dollarVars.add('$slots');
     }
-    if (options.vueCompilerOptions.inferTemplateDollarAttrs) {
+    if (vueCompilerOptions.inferTemplateDollarAttrs) {
         ctx.dollarVars.add('$attrs');
     }
-    if (options.vueCompilerOptions.inferTemplateDollarRefs) {
+    if (vueCompilerOptions.inferTemplateDollarRefs) {
         ctx.dollarVars.add('$refs');
     }
-    if (options.vueCompilerOptions.inferTemplateDollarEl) {
+    if (vueCompilerOptions.inferTemplateDollarEl) {
         ctx.dollarVars.add('$el');
     }
-    if (options.template.ast) {
-        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, options.template.ast);
+    if (template.ast) {
+        yield* (0, templateChild_1.generateTemplateChild)(options, ctx, template.ast);
     }
-    yield* (0, styleScopedClasses_1.generateStyleScopedClassReferences)(ctx);
     yield* ctx.generateHoistVariables();
-    const dollarTypes = [
-        ['$slots', yield* generateSlots(options, ctx)],
-        ['$attrs', yield* generateInheritedAttrs(options, ctx)],
-        ['$refs', yield* generateTemplateRefs(options, ctx)],
-        ['$el', yield* generateRootEl(ctx)],
-    ].filter(([name]) => ctx.dollarVars.has(name));
-    if (dollarTypes.length) {
-        yield `var __VLS_dollars!: {${utils_1.newLine}`;
-        for (const [name, type] of dollarTypes) {
-            yield `${name}: ${type}${utils_1.endOfLine}`;
+    yield* generateSlotsType(options, ctx);
+    yield* generateInheritedAttrsType(ctx);
+    yield* generateTemplateRefsType(options, ctx);
+    yield* generateRootElType(ctx);
+    if (ctx.dollarVars.size) {
+        yield `var ${names.dollars}!: {${utils_1.newLine}`;
+        if (ctx.dollarVars.has('$slots')) {
+            const type = ctx.generatedTypes.has(names.Slots) ? names.Slots : `{}`;
+            yield `$slots: ${type}${utils_1.endOfLine}`;
         }
-        yield `} & { [K in keyof import('${options.vueCompilerOptions.lib}').ComponentPublicInstance]: unknown }${utils_1.endOfLine}`;
+        if (ctx.dollarVars.has('$attrs')) {
+            yield `$attrs: import('${vueCompilerOptions.lib}').ComponentPublicInstance['$attrs']`;
+            if (ctx.generatedTypes.has(names.InheritedAttrs)) {
+                yield ` & ${names.InheritedAttrs}`;
+            }
+            yield utils_1.endOfLine;
+        }
+        if (ctx.dollarVars.has('$refs')) {
+            const type = ctx.generatedTypes.has(names.TemplateRefs) ? names.TemplateRefs : `{}`;
+            yield `$refs: ${type}${utils_1.endOfLine}`;
+        }
+        if (ctx.dollarVars.has('$el')) {
+            const type = ctx.generatedTypes.has(names.RootEl) ? names.RootEl : `any`;
+            yield `$el: ${type}${utils_1.endOfLine}`;
+        }
+        yield `} & { [K in keyof import('${vueCompilerOptions.lib}').ComponentPublicInstance]: unknown }${utils_1.endOfLine}`;
     }
+    yield* endScope();
 }
-function* generateSlots(options, ctx) {
-    if (!options.hasDefineSlots) {
-        yield `type __VLS_Slots = {}`;
-        for (const { expVar, propsVar } of ctx.dynamicSlots) {
-            yield `${utils_1.newLine}& { [K in NonNullable<typeof ${expVar}>]?: (props: typeof ${propsVar}) => any }`;
+function* generateSlotsType(options, ctx) {
+    if (options.hasDefineSlots || (!ctx.slots.length && !ctx.dynamicSlots.length)) {
+        return;
+    }
+    ctx.generatedTypes.add(names.Slots);
+    yield `type ${names.Slots} = {}`;
+    for (const { expVar, propsVar } of ctx.dynamicSlots) {
+        yield `${utils_1.newLine}& { [K in NonNullable<typeof ${expVar}>]?: (props: typeof ${propsVar}) => any }`;
+    }
+    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, codeFeatures_1.codeFeatures.navigation);
         }
-        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, codeFeatures_1.codeFeatures.navigation);
-            }
-            else {
-                yield* (0, wrapWith_1.wrapWith)(slot.tagRange[0], slot.tagRange[1], codeFeatures_1.codeFeatures.navigation, `default`);
-            }
-            yield `?: (props: typeof ${slot.propsVar}) => any }`;
+        else {
+            const token = yield* (0, boundary_1.startBoundary)('template', slot.tagRange[0], codeFeatures_1.codeFeatures.navigation);
+            yield `default`;
+            yield (0, boundary_1.endBoundary)(token, slot.tagRange[1]);
         }
-        yield utils_1.endOfLine;
+        yield `?: (props: typeof ${slot.propsVar}) => any }`;
     }
-    return `__VLS_Slots`;
-}
-function* generateInheritedAttrs(options, ctx) {
-    yield `type __VLS_InheritedAttrs = ${ctx.inheritedAttrVars.size
-        ? `Partial<${[...ctx.inheritedAttrVars].map(name => `typeof ${name}`).join(` & `)}>`
-        : `{}`}`;
     yield utils_1.endOfLine;
-    if (ctx.bindingAttrLocs.length) {
-        yield `[`;
-        for (const loc of ctx.bindingAttrLocs) {
-            yield `__VLS_dollars.`;
-            yield [
-                loc.source,
-                'template',
-                loc.start.offset,
-                codeFeatures_1.codeFeatures.all,
-            ];
-            yield `,`;
-        }
-        yield `]${utils_1.endOfLine}`;
+}
+function* generateInheritedAttrsType(ctx) {
+    if (!ctx.inheritedAttrVars.size) {
+        return;
     }
-    return `import('${options.vueCompilerOptions.lib}').ComponentPublicInstance['$attrs'] & __VLS_InheritedAttrs`;
+    ctx.generatedTypes.add(names.InheritedAttrs);
+    yield `type ${names.InheritedAttrs} = Partial<${[...ctx.inheritedAttrVars].map(name => `typeof ${name}`).join(` & `)}>`;
+    yield utils_1.endOfLine;
 }
-function* generateTemplateRefs(options, ctx) {
-    yield `type __VLS_TemplateRefs = {}`;
+function* generateTemplateRefsType(options, ctx) {
+    if (!ctx.templateRefs.size) {
+        return;
+    }
+    ctx.generatedTypes.add(names.TemplateRefs);
+    yield `type ${names.TemplateRefs} = {}`;
     for (const [name, refs] of ctx.templateRefs) {
         yield `${utils_1.newLine}& `;
         if (refs.length >= 2) {
@@ -123,19 +131,16 @@ function* generateTemplateRefs(options, ctx) {
         }
     }
     yield utils_1.endOfLine;
-    return `__VLS_TemplateRefs`;
 }
-function* generateRootEl(ctx) {
-    yield `type __VLS_RootEl = `;
-    if (ctx.singleRootElTypes.length && !ctx.singleRootNodes.has(null)) {
-        for (const type of ctx.singleRootElTypes) {
-            yield `${utils_1.newLine}| ${type}`;
-        }
+function* generateRootElType(ctx) {
+    if (!ctx.singleRootElTypes.size || ctx.singleRootNodes.has(null)) {
+        return;
     }
-    else {
-        yield `any`;
+    ctx.generatedTypes.add(names.RootEl);
+    yield `type ${names.RootEl} = `;
+    for (const type of ctx.singleRootElTypes) {
+        yield `${utils_1.newLine}| ${type}`;
     }
     yield utils_1.endOfLine;
-    return `__VLS_RootEl`;
 }
 //# sourceMappingURL=index.js.map

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

@@ -1,5 +1,5 @@
-import type { Code, VueCodeInformation } from '../../types';
-import type { ScriptCodegenOptions } from '../script';
+import type { Code, SfcBlock, VueCodeInformation } from '../../types';
+import type { StyleCodegenOptions } from '../style';
 import type { TemplateCodegenContext } from './context';
 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>;
+export declare function generateInterpolation(options: Pick<TemplateCodegenOptions | StyleCodegenOptions, 'ts' | 'setupRefs'>, ctx: TemplateCodegenContext, block: SfcBlock, data: VueCodeInformation, code: string, start: number, prefix?: string, suffix?: string): Generator<Code>;

package/lib/codegen/template/interpolation.js

@@ -5,246 +5,199 @@ 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 = require("../names");
 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, prefix = '', suffix = '') {
-    const { ts, destructuredPropNames, templateRefNames, } = options;
-    for (let [section, offset, type] of forEachInterpolationSegment(ts, ctx.inlineTsAsts, destructuredPropNames, templateRefNames, ctx, code, start, prefix, suffix)) {
-        if (offset === undefined) {
-            yield section;
+function* generateInterpolation(options, ctx, block, data, code, start, prefix = '', suffix = '') {
+    for (const segment of forEachInterpolationSegment(options, ctx, block, code, start, prefix, suffix)) {
+        if (typeof segment === 'string') {
+            yield segment;
+            continue;
         }
-        else {
-            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 === 'startText' || type === 'endText');
-            if (!shouldSkip) {
-                if (start !== undefined
-                    && data) {
-                    yield [
-                        section,
-                        source,
-                        start + offset,
-                        type === 'errorMappingOnly'
-                            ? codeFeatures_1.codeFeatures.verification
-                            : typeof data === 'function'
-                                ? data(start + offset)
-                                : data,
-                    ];
-                }
-                else {
-                    yield section;
-                }
-            }
-            yield addSuffix;
+        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
+                    : data,
+            ];
+        }
+        yield addSuffix;
     }
 }
-function* forEachInterpolationSegment(ts, inlineTsAsts, destructuredPropNames, templateRefNames, ctx, originalCode, start, prefix, suffix) {
+function* forEachInterpolationSegment({ ts, setupRefs }, ctx, block, originalCode, start, prefix, suffix) {
     const code = prefix + originalCode + suffix;
-    const offset = start !== undefined ? start - prefix.length : undefined;
-    let ctxVars = [];
-    if (utils_1.identifierRegex.test(originalCode) && !shouldIdentifierSkipped(ctx, originalCode, destructuredPropNames)) {
-        ctxVars.push({
-            text: originalCode,
-            offset: prefix.length,
-        });
-    }
-    else {
-        const ast = (0, utils_1.createTsAst)(ts, inlineTsAsts, code);
-        const varCb = (id, isShorthand) => {
-            const text = (0, shared_2.getNodeText)(ts, id, ast);
-            if (!shouldIdentifierSkipped(ctx, text, destructuredPropNames)) {
-                ctxVars.push({
-                    text,
-                    offset: (0, shared_2.getStartEnd)(ts, id, ast).start,
-                    isShorthand,
-                });
-            }
-        };
-        ts.forEachChild(ast, node => walkIdentifiers(ts, node, ast, varCb, ctx, [], true));
-    }
-    ctxVars = ctxVars.sort((a, b) => a.offset - b.offset);
-    if (ctxVars.length) {
-        for (let i = 0; i < ctxVars.length; i++) {
-            const lastVar = ctxVars[i - 1];
-            const curVar = ctxVars[i];
-            const lastVarEnd = lastVar ? lastVar.offset + lastVar.text.length : 0;
-            if (curVar.isShorthand) {
-                yield [code.slice(lastVarEnd, curVar.offset + curVar.text.length), lastVarEnd];
-                yield [': ', undefined];
+    let prevEnd = 0;
+    for (const [name, offset, isShorthand] of forEachIdentifiers(ts, ctx, block, originalCode, code, prefix)) {
+        if (isShorthand) {
+            yield [code.slice(prevEnd, offset + name.length), prevEnd];
+            yield `: `;
+        }
+        else {
+            yield [code.slice(prevEnd, offset), prevEnd, prevEnd > 0 ? undefined : 'startEnd'];
+        }
+        if (setupRefs.has(name)) {
+            yield [name, offset];
+            yield `.value`;
+        }
+        else {
+            yield ['', offset, 'errorMappingOnly']; // #1205, #1264
+            if (ctx.dollarVars.has(name)) {
+                yield names.dollars;
             }
             else {
-                yield [code.slice(lastVarEnd, curVar.offset), lastVarEnd, i ? undefined : 'startText'];
+                ctx.recordComponentAccess(block.name, name, start - prefix.length + offset);
+                yield names.ctx;
             }
-            yield* generateVar(templateRefNames, ctx, code, offset, curVar);
-        }
-        const lastVar = ctxVars.at(-1);
-        if (lastVar.offset + lastVar.text.length < code.length) {
-            yield [code.slice(lastVar.offset + lastVar.text.length), lastVar.offset + lastVar.text.length, 'endText'];
+            yield `.`;
+            yield [name, offset];
         }
+        prevEnd = offset + name.length;
     }
-    else {
-        yield [code, 0];
+    if (prevEnd < code.length) {
+        yield [code.slice(prevEnd), prevEnd, 'startEnd'];
     }
 }
-function* generateVar(templateRefNames, ctx, code, offset, curVar) {
-    // fix https://github.com/vuejs/language-tools/issues/1205
-    // fix https://github.com/vuejs/language-tools/issues/1264
-    yield ['', curVar.offset, 'errorMappingOnly'];
-    const isTemplateRef = templateRefNames?.has(curVar.text) ?? false;
-    if (isTemplateRef) {
-        yield [`__VLS_unref(`, undefined];
-        yield [code.slice(curVar.offset, curVar.offset + curVar.text.length), curVar.offset];
-        yield [`)`, undefined];
-    }
-    else {
-        if (offset !== undefined) {
-            ctx.accessExternalVariable(curVar.text, offset + curVar.offset);
-        }
-        else {
-            ctx.accessExternalVariable(curVar.text);
-        }
-        if (ctx.dollarVars.has(curVar.text)) {
-            yield [`__VLS_dollars.`, undefined];
-        }
-        else {
-            yield [`__VLS_ctx.`, undefined];
+function* forEachIdentifiers(ts, ctx, block, originalCode, code, prefix) {
+    if (utils_1.identifierRegex.test(originalCode) && !shouldIdentifierSkipped(ctx, originalCode)) {
+        yield [originalCode, prefix.length, false];
+        return;
+    }
+    const endScope = ctx.startScope();
+    const ast = (0, utils_1.getTypeScriptAST)(ts, block, code);
+    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 [code.slice(curVar.offset, curVar.offset + curVar.text.length), curVar.offset];
+        yield [text, (0, shared_2.getStartEnd)(ts, id, ast).start, isShorthand];
     }
+    endScope();
 }
-function walkIdentifiers(ts, node, ast, cb, ctx, blockVars, isRoot = false) {
+function* forEachDeclarations(ts, node, ast, ctx) {
     if (ts.isIdentifier(node)) {
-        cb(node, false);
+        yield [node, false];
     }
     else if (ts.isShorthandPropertyAssignment(node)) {
-        cb(node.name, true);
+        yield [node.name, true];
     }
     else if (ts.isPropertyAccessExpression(node)) {
-        walkIdentifiers(ts, node.expression, ast, cb, ctx, blockVars);
+        yield* forEachDeclarations(ts, node.expression, ast, ctx);
     }
     else if (ts.isVariableDeclaration(node)) {
-        const bindingNames = (0, collectBindings_1.collectBindingNames)(ts, node.name, ast);
-        for (const name of bindingNames) {
-            ctx.addLocalVariable(name);
-            blockVars.push(name);
-        }
-        walkIdentifiersInBinding(ts, node, ast, cb, ctx, blockVars);
+        ctx.declare(...(0, collectBindings_1.collectBindingNames)(ts, node.name, ast));
+        yield* forEachDeclarationsInBinding(ts, node, ast, ctx);
     }
     else if (ts.isArrayBindingPattern(node) || ts.isObjectBindingPattern(node)) {
         for (const element of node.elements) {
             if (ts.isBindingElement(element)) {
-                walkIdentifiersInBinding(ts, element, ast, cb, ctx, blockVars);
+                yield* forEachDeclarationsInBinding(ts, element, ast, ctx);
             }
         }
     }
     else if (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) {
-        walkIdentifiersInFunction(ts, node, ast, cb, ctx);
+        yield* forEachDeclarationsInFunction(ts, node, ast, ctx);
     }
     else if (ts.isObjectLiteralExpression(node)) {
         for (const prop of node.properties) {
             if (ts.isPropertyAssignment(prop)) {
                 // fix https://github.com/vuejs/language-tools/issues/1176
                 if (ts.isComputedPropertyName(prop.name)) {
-                    walkIdentifiers(ts, prop.name.expression, ast, cb, ctx, blockVars);
+                    yield* forEachDeclarations(ts, prop.name.expression, ast, ctx);
                 }
-                walkIdentifiers(ts, prop.initializer, ast, cb, ctx, blockVars);
+                yield* forEachDeclarations(ts, prop.initializer, ast, ctx);
             }
             // fix https://github.com/vuejs/language-tools/issues/1156
             else if (ts.isShorthandPropertyAssignment(prop)) {
-                walkIdentifiers(ts, prop, ast, cb, ctx, blockVars);
+                yield* forEachDeclarations(ts, prop, ast, ctx);
             }
             // 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)"
-                walkIdentifiers(ts, prop.expression, ast, cb, ctx, blockVars);
+                yield* forEachDeclarations(ts, prop.expression, ast, ctx);
             }
             // fix https://github.com/vuejs/language-tools/issues/4604
             else if (ts.isFunctionLike(prop) && prop.body) {
-                walkIdentifiersInFunction(ts, prop, ast, cb, ctx);
+                yield* forEachDeclarationsInFunction(ts, prop, ast, ctx);
             }
         }
     }
     // fix https://github.com/vuejs/language-tools/issues/1422
     else if (ts.isTypeNode(node)) {
-        walkIdentifiersInTypeNode(ts, node, cb);
+        yield* forEachDeclarationsInTypeNode(ts, node);
     }
-    else {
-        const _blockVars = blockVars;
-        if (ts.isBlock(node)) {
-            blockVars = [];
-        }
-        ts.forEachChild(node, node => walkIdentifiers(ts, node, ast, cb, ctx, blockVars));
-        if (ts.isBlock(node)) {
-            for (const varName of blockVars) {
-                ctx.removeLocalVariable(varName);
-            }
+    else if (ts.isBlock(node)) {
+        const endScope = ctx.startScope();
+        for (const child of (0, utils_1.forEachNode)(ts, node)) {
+            yield* forEachDeclarations(ts, child, ast, ctx);
         }
-        blockVars = _blockVars;
+        endScope();
     }
-    if (isRoot) {
-        for (const varName of blockVars) {
-            ctx.removeLocalVariable(varName);
+    else {
+        for (const child of (0, utils_1.forEachNode)(ts, node)) {
+            yield* forEachDeclarations(ts, child, ast, ctx);
         }
     }
 }
-function walkIdentifiersInBinding(ts, node, ast, cb, ctx, blockVars) {
+function* forEachDeclarationsInBinding(ts, node, ast, ctx) {
     if ('type' in node && node.type) {
-        walkIdentifiersInTypeNode(ts, node.type, cb);
+        yield* forEachDeclarationsInTypeNode(ts, node.type);
     }
     if (!ts.isIdentifier(node.name)) {
-        walkIdentifiers(ts, node.name, ast, cb, ctx, blockVars);
+        yield* forEachDeclarations(ts, node.name, ast, ctx);
     }
     if (node.initializer) {
-        walkIdentifiers(ts, node.initializer, ast, cb, ctx, blockVars);
+        yield* forEachDeclarations(ts, node.initializer, ast, ctx);
     }
 }
-function walkIdentifiersInFunction(ts, node, ast, cb, ctx) {
-    const functionArgs = [];
+function* forEachDeclarationsInFunction(ts, node, ast, ctx) {
+    const endScope = ctx.startScope();
     for (const param of node.parameters) {
-        functionArgs.push(...(0, collectBindings_1.collectBindingNames)(ts, param.name, ast));
-        walkIdentifiersInBinding(ts, param, ast, cb, ctx, functionArgs);
-    }
-    for (const varName of functionArgs) {
-        ctx.addLocalVariable(varName);
+        ctx.declare(...(0, collectBindings_1.collectBindingNames)(ts, param.name, ast));
+        yield* forEachDeclarationsInBinding(ts, param, ast, ctx);
     }
     if (node.body) {
-        walkIdentifiers(ts, node.body, ast, cb, ctx, [], true);
-    }
-    for (const varName of functionArgs) {
-        ctx.removeLocalVariable(varName);
+        yield* forEachDeclarations(ts, node.body, ast, ctx);
     }
+    endScope();
 }
-function walkIdentifiersInTypeNode(ts, node, cb) {
+function* forEachDeclarationsInTypeNode(ts, node) {
     if (ts.isTypeQueryNode(node)) {
         let id = node.exprName;
         while (!ts.isIdentifier(id)) {
             id = id.left;
         }
-        cb(id, false);
+        yield [id, false];
     }
     else {
-        ts.forEachChild(node, node => walkIdentifiersInTypeNode(ts, node, cb));
+        for (const child of (0, utils_1.forEachNode)(ts, node)) {
+            yield* forEachDeclarationsInTypeNode(ts, child);
+        }
     }
 }
-function shouldIdentifierSkipped(ctx, text, destructuredPropNames) {
-    return ctx.hasLocalVariable(text)
+function shouldIdentifierSkipped(ctx, text) {
+    return ctx.scopes.some(scope => scope.has(text))
         // https://github.com/vuejs/core/blob/245230e135152900189f13a4281302de45fdcfaa/packages/compiler-core/src/transforms/transformExpression.ts#L342-L352
         || (0, shared_1.isGloballyAllowed)(text)
         || isLiteralWhitelisted(text)
         || text === 'require'
-        || text.startsWith('__VLS_')
-        || destructuredPropNames?.has(text);
+        || text.startsWith('__VLS_');
 }
 //# sourceMappingURL=interpolation.js.map

package/lib/codegen/template/objectProperty.js

@@ -3,17 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateObjectProperty = generateObjectProperty;
 const shared_1 = require("@vue/shared");
 const utils_1 = require("../utils");
+const boundary_1 = require("../utils/boundary");
 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, 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, `[__VLS_tryAsConstant(`, `)]`);
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, options.template, features, code.slice(1, -1), offset + 1, `[__VLS_tryAsConstant(`, `)]`);
         }
         else {
-            yield* (0, interpolation_1.generateInterpolation)(options, ctx, 'template', features, code, offset);
+            yield* (0, interpolation_1.generateInterpolation)(options, ctx, options.template, features, code, offset);
         }
     }
     else if (shouldCamelize) {
@@ -21,7 +21,11 @@ function* generateObjectProperty(options, ctx, code, offset, features, shouldCam
             yield* (0, camelized_1.generateCamelized)(code, 'template', offset, features);
         }
         else {
-            yield* (0, wrapWith_1.wrapWith)(offset, offset + code.length, features, `'`, ...(0, camelized_1.generateCamelized)(code, 'template', offset, utils_1.combineLastMapping), `'`);
+            const token = yield* (0, boundary_1.startBoundary)('template', offset, features);
+            yield `'`;
+            yield* (0, camelized_1.generateCamelized)(code, 'template', offset, { __combineToken: token });
+            yield `'`;
+            yield (0, boundary_1.endBoundary)(token, offset + code.length);
         }
     }
     else {

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): Generator<Code>;
+export declare function generatePropertyAccess(options: TemplateCodegenOptions, ctx: TemplateCodegenContext, code: string, offset: number, features: VueCodeInformation): Generator<Code>;

package/lib/codegen/template/propertyAccess.js

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