@vue/language-service 3.0.2 → 3.0.4

package/lib/plugins/vue-destructured-props-hints.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = create;
+exports.findDestructuredProps = findDestructuredProps;
+const language_core_1 = require("@vue/language-core");
+const vscode_uri_1 = require("vscode-uri");
+function create(ts) {
+    return {
+        name: 'vue-destructured-props-hints',
+        capabilities: {
+            inlayHintProvider: {},
+        },
+        create(context) {
+            return {
+                async provideInlayHints(document) {
+                    const enabled = await context.env.getConfiguration?.('vue.inlayHints.destructuredProps') ?? false;
+                    if (!enabled) {
+                        return;
+                    }
+                    const uri = vscode_uri_1.URI.parse(document.uri);
+                    const decoded = context.decodeEmbeddedDocumentUri(uri);
+                    const sourceScript = decoded && context.language.scripts.get(decoded[0]);
+                    const virtualCode = decoded && sourceScript?.generated?.embeddedCodes.get(decoded[1]);
+                    if (!sourceScript?.generated || virtualCode?.id !== 'main') {
+                        return;
+                    }
+                    const root = sourceScript.generated.root;
+                    if (!(root instanceof language_core_1.VueVirtualCode)) {
+                        return;
+                    }
+                    const result = [];
+                    const codegen = language_core_1.tsCodegen.get(root.sfc);
+                    const scriptSetupRanges = codegen?.getScriptSetupRanges();
+                    if (!scriptSetupRanges?.defineProps?.destructured || !root.sfc.scriptSetup?.ast) {
+                        return;
+                    }
+                    for (const [prop, isShorthand] of findDestructuredProps(ts, root.sfc.scriptSetup.ast, scriptSetupRanges.defineProps.destructured.keys())) {
+                        const name = prop.text;
+                        const end = prop.getEnd();
+                        const pos = isShorthand ? end : end - name.length;
+                        const label = isShorthand ? `: props.${name}` : 'props.';
+                        result.push({
+                            label,
+                            position: document.positionAt(root.sfc.scriptSetup.startTagEnd + pos),
+                            kind: 2,
+                        });
+                    }
+                    return result;
+                },
+            };
+        },
+    };
+}
+/**
+ * Refactored from https://github.com/vuejs/core/blob/main/packages/compiler-sfc/src/script/definePropsDestructure.ts
+ */
+function findDestructuredProps(ts, ast, props) {
+    const rootScope = Object.create(null);
+    const scopeStack = [rootScope];
+    let currentScope = rootScope;
+    const excludedIds = new WeakSet();
+    const parentStack = [];
+    for (const prop of props) {
+        rootScope[prop] = true;
+    }
+    function pushScope() {
+        scopeStack.push(currentScope = Object.create(currentScope));
+    }
+    function popScope() {
+        scopeStack.pop();
+        currentScope = scopeStack[scopeStack.length - 1] || null;
+    }
+    function registerLocalBinding(id) {
+        excludedIds.add(id);
+        if (currentScope) {
+            currentScope[id.text] = false;
+        }
+    }
+    const references = [];
+    walkScope(ast, true);
+    walk(ast);
+    return references;
+    function walkScope(node, isRoot = false) {
+        ts.forEachChild(node, stmt => {
+            if (ts.isVariableStatement(stmt)) {
+                for (const decl of stmt.declarationList.declarations) {
+                    walkVariableDeclaration(decl, isRoot);
+                }
+            }
+            else if (ts.isFunctionDeclaration(stmt)
+                || ts.isClassDeclaration(stmt)) {
+                const declare = ts.getModifiers(stmt)?.find(modifier => modifier.kind === ts.SyntaxKind.DeclareKeyword);
+                if (!stmt.name || declare) {
+                    return;
+                }
+                registerLocalBinding(stmt.name);
+            }
+            else if ((ts.isForOfStatement(stmt) || ts.isForInStatement(stmt))
+                && ts.isVariableDeclarationList(stmt.initializer)) {
+                walkVariableDeclaration(stmt.initializer.declarations[0], isRoot);
+            }
+            else if (ts.isLabeledStatement(stmt)
+                && ts.isVariableDeclaration(stmt.statement)) {
+                walkVariableDeclaration(stmt.statement, isRoot);
+            }
+        });
+    }
+    function walkVariableDeclaration(decl, isRoot = false) {
+        const { initializer, name } = decl;
+        const isDefineProps = isRoot
+            && initializer
+            && ts.isCallExpression(initializer)
+            && initializer.expression.getText(ast) === 'defineProps';
+        for (const { id } of (0, language_core_1.collectIdentifiers)(ts, name)) {
+            if (isDefineProps) {
+                excludedIds.add(id);
+            }
+            else {
+                registerLocalBinding(id);
+            }
+        }
+    }
+    function walkFunctionDeclaration(node) {
+        const { name, parameters } = node;
+        if (name && ts.isIdentifier(name)) {
+            registerLocalBinding(name);
+        }
+        for (const p of parameters) {
+            for (const { id } of (0, language_core_1.collectIdentifiers)(ts, p)) {
+                registerLocalBinding(id);
+            }
+        }
+    }
+    function walk(parent) {
+        ts.forEachChild(parent, node => {
+            if (enter(node) ?? true) {
+                walk(node);
+                leave(node);
+            }
+        });
+        function enter(node) {
+            if (parent) {
+                parentStack.push(parent);
+            }
+            if (ts.isTypeLiteralNode(node)
+                || ts.isTypeReferenceNode(node)) {
+                return false;
+            }
+            if (ts.isFunctionLike(node)) {
+                pushScope();
+                walkFunctionDeclaration(node);
+                if ('body' in node) {
+                    walkScope(node.body);
+                }
+                return;
+            }
+            if (ts.isCatchClause(node)) {
+                pushScope();
+                const { variableDeclaration: p } = node;
+                if (p && ts.isIdentifier(p.name)) {
+                    registerLocalBinding(p.name);
+                }
+                walkScope(node.block);
+                return;
+            }
+            if (ts.isBlock(node)
+                && !ts.isFunctionLike(parent)
+                && !ts.isCatchClause(parent)) {
+                pushScope();
+                walkScope(node);
+                return;
+            }
+            if (ts.isIdentifier(node)
+                && isReferencedIdentifier(node, parent)
+                && !excludedIds.has(node)) {
+                const name = node.text;
+                if (currentScope[name]) {
+                    const isShorthand = ts.isShorthandPropertyAssignment(parent);
+                    references.push([node, isShorthand]);
+                }
+            }
+        }
+        function leave(node) {
+            if (parent) {
+                parentStack.pop();
+            }
+            if (ts.isFunctionLike(node)
+                || ts.isCatchClause(node)
+                || (ts.isBlock(node)
+                    && !ts.isFunctionLike(parent)
+                    && !ts.isCatchClause(parent))) {
+                popScope();
+            }
+        }
+    }
+    // TODO: more conditions
+    function isReferencedIdentifier(id, parent) {
+        if (!parent) {
+            return false;
+        }
+        if (id.text === 'arguments') {
+            return false;
+        }
+        if (ts.isExpressionWithTypeArguments(parent)
+            || ts.isInterfaceDeclaration(parent)
+            || ts.isTypeAliasDeclaration(parent)
+            || ts.isPropertySignature(parent)) {
+            return false;
+        }
+        if (ts.isPropertyAccessExpression(parent)
+            || ts.isPropertyAssignment(parent)
+            || ts.isPropertyDeclaration(parent)) {
+            if (parent.name === id) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=vue-destructured-props-hints.js.map

package/lib/plugins/vue-document-drop.d.ts

@@ -1,2 +1,2 @@
-import type { LanguageServiceContext, LanguageServicePlugin } from '@volar/language-service';
-export declare function create(ts: typeof import('typescript'), getTsPluginClient?: (context: LanguageServiceContext) => import('@vue/typescript-plugin/lib/requests').Requests | undefined): LanguageServicePlugin;
+import type { LanguageServicePlugin } from '@volar/language-service';
+export declare function create(ts: typeof import('typescript'), tsPluginClient: import('@vue/typescript-plugin/lib/requests').Requests | undefined): LanguageServicePlugin;

package/lib/plugins/vue-document-drop.js

@@ -8,41 +8,28 @@ const getUserPreferences_1 = require("volar-service-typescript/lib/configs/getUs
 const vscode_uri_1 = require("vscode-uri");
 const nameCasing_1 = require("../nameCasing");
 const vue_extract_file_1 = require("../plugins/vue-extract-file");
-function create(ts, getTsPluginClient) {
+const utils_1 = require("./utils");
+function create(ts, tsPluginClient) {
     return {
         name: 'vue-document-drop',
         capabilities: {
             documentDropEditsProvider: true,
         },
         create(context) {
-            if (!context.project.vue) {
-                return {};
-            }
-            let casing = nameCasing_1.TagNameCasing.Pascal; // TODO
-            const tsPluginClient = getTsPluginClient?.(context);
-            const vueCompilerOptions = context.project.vue.compilerOptions;
             return {
                 async provideDocumentDropEdits(document, _position, dataTransfer) {
-                    if (document.languageId !== 'html') {
-                        return;
-                    }
-                    const uri = vscode_uri_1.URI.parse(document.uri);
-                    const decoded = context.decodeEmbeddedDocumentUri(uri);
-                    const sourceScript = decoded && context.language.scripts.get(decoded[0]);
-                    if (!sourceScript?.generated) {
-                        return;
-                    }
-                    const root = sourceScript.generated.root;
-                    if (!(root instanceof language_core_1.VueVirtualCode)) {
+                    const info = (0, utils_1.getEmbeddedInfo)(context, document, 'template', 'html');
+                    if (!info) {
                         return;
                     }
+                    const { sourceScript, root } = info;
                     let importUri;
                     for (const [mimeType, item] of dataTransfer) {
                         if (mimeType === 'text/uri-list') {
                             importUri = item.value;
                         }
                     }
-                    if (!importUri || !vueCompilerOptions.extensions.some(ext => importUri.endsWith(ext))) {
+                    if (!importUri || !root.vueCompilerOptions.extensions.some(ext => importUri.endsWith(ext))) {
                         return;
                     }
                     const { sfc } = root;
@@ -50,16 +37,15 @@ function create(ts, getTsPluginClient) {
                     if (!script) {
                         return;
                     }
-                    let baseName = importUri.slice(importUri.lastIndexOf('/') + 1);
-                    baseName = baseName.slice(0, baseName.lastIndexOf('.'));
-                    const newName = (0, shared_1.capitalize)((0, shared_1.camelize)(baseName));
+                    const casing = await (0, nameCasing_1.checkCasing)(context, sourceScript.id);
+                    const baseName = path_browserify_1.posix.basename(importUri);
+                    const newName = (0, shared_1.capitalize)((0, shared_1.camelize)(baseName.slice(0, baseName.lastIndexOf('.'))));
                     const additionalEdit = {};
                     const code = [...(0, language_core_1.forEachEmbeddedCode)(root)].find(code => code.id === (sfc.scriptSetup ? 'scriptsetup_raw' : 'script_raw'));
                     const lastImportNode = (0, vue_extract_file_1.getLastImportNode)(ts, script.ast);
-                    const incomingFileName = context.project.typescript?.uriConverter.asFileName(vscode_uri_1.URI.parse(importUri))
-                        ?? vscode_uri_1.URI.parse(importUri).fsPath.replace(/\\/g, '/');
+                    const incomingFileName = vscode_uri_1.URI.parse(importUri).fsPath.replace(/\\/g, '/');
                     let importPath;
-                    const serviceScript = sourceScript.generated?.languagePlugin.typescript?.getServiceScript(root);
+                    const serviceScript = sourceScript.generated.languagePlugin.typescript?.getServiceScript(root);
                     if (tsPluginClient && serviceScript) {
                         const tsDocumentUri = context.encodeEmbeddedDocumentUri(sourceScript.id, serviceScript.code.id);
                         const tsDocument = context.documents.get(tsDocumentUri, serviceScript.code.languageId, serviceScript.code.snapshot);
@@ -105,7 +91,7 @@ function create(ts, getTsPluginClient) {
                         }
                     }
                     return {
-                        insertText: `<${casing === nameCasing_1.TagNameCasing.Kebab ? (0, shared_1.hyphenate)(newName) : newName}$0 />`,
+                        insertText: `<${casing.tag === nameCasing_1.TagNameCasing.Kebab ? (0, shared_1.hyphenate)(newName) : newName}$0 />`,
                         insertTextFormat: 2,
                         additionalEdit,
                     };

package/lib/plugins/vue-document-highlights.d.ts

@@ -1,3 +1,2 @@
 import type { LanguageServicePlugin } from '@volar/language-service';
-import type * as ts from 'typescript';
-export declare function create(getDocumentHighlights: (fileName: string, position: number) => Promise<ts.DocumentHighlights[] | null>): LanguageServicePlugin;
+export declare function create(tsPluginClient: import('@vue/typescript-plugin/lib/requests').Requests | undefined): LanguageServicePlugin;

package/lib/plugins/vue-document-highlights.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.create = create;
-const language_core_1 = require("@vue/language-core");
-const vscode_uri_1 = require("vscode-uri");
-function create(getDocumentHighlights) {
+const utils_1 = require("./utils");
+function create(tsPluginClient) {
     return {
         name: 'vue-document-highlights',
         capabilities: {
@@ -12,18 +11,12 @@ function create(getDocumentHighlights) {
         create(context) {
             return {
                 async provideDocumentHighlights(document, position) {
-                    const uri = vscode_uri_1.URI.parse(document.uri);
-                    const decoded = context.decodeEmbeddedDocumentUri(uri);
-                    const sourceScript = decoded && context.language.scripts.get(decoded[0]);
-                    const virtualCode = decoded && sourceScript?.generated?.embeddedCodes.get(decoded[1]);
-                    if (!sourceScript?.generated || virtualCode?.id !== 'main') {
+                    const info = (0, utils_1.getEmbeddedInfo)(context, document, 'main');
+                    if (!info) {
                         return;
                     }
-                    const root = sourceScript.generated.root;
-                    if (!(root instanceof language_core_1.VueVirtualCode)) {
-                        return;
-                    }
-                    const result = await getDocumentHighlights(root.fileName, document.offsetAt(position));
+                    const { root } = info;
+                    const result = await tsPluginClient?.getDocumentHighlights(root.fileName, document.offsetAt(position));
                     return result
                         ?.filter(({ fileName }) => fileName === root.fileName)
                         .flatMap(({ highlightSpans }) => highlightSpans)

package/lib/plugins/vue-extract-file.d.ts

@@ -1,7 +1,7 @@
-import type { LanguageServiceContext, LanguageServicePlugin } from '@volar/language-service';
+import type { LanguageServicePlugin } from '@volar/language-service';
 import { type Sfc } from '@vue/language-core';
 import type * as ts from 'typescript';
-export declare function create(ts: typeof import('typescript'), getTsPluginClient?: (context: LanguageServiceContext) => import('@vue/typescript-plugin/lib/requests').Requests | undefined): LanguageServicePlugin;
+export declare function create(ts: typeof import('typescript'), tsPluginClient: import('@vue/typescript-plugin/lib/requests').Requests | undefined): LanguageServicePlugin;
 export declare function getLastImportNode(ts: typeof import('typescript'), sourceFile: ts.SourceFile): ts.Node | undefined;
 export declare function createAddComponentToOptionEdit(ts: typeof import('typescript'), sfc: Sfc, ast: ts.SourceFile, componentName: string): {
     range: import("@vue/language-core").TextRange;

package/lib/plugins/vue-extract-file.js

@@ -5,8 +5,9 @@ exports.getLastImportNode = getLastImportNode;
 exports.createAddComponentToOptionEdit = createAddComponentToOptionEdit;
 const language_core_1 = require("@vue/language-core");
 const vscode_uri_1 = require("vscode-uri");
+const utils_1 = require("./utils");
 const unicodeReg = /\\u/g;
-function create(ts, getTsPluginClient) {
+function create(ts, tsPluginClient) {
     return {
         name: 'vue-extract-file',
         capabilities: {
@@ -16,7 +17,6 @@ function create(ts, getTsPluginClient) {
             },
         },
         create(context) {
-            const tsPluginClient = getTsPluginClient?.(context);
             return {
                 provideCodeActions(document, range, ctx) {
                     if (ctx.only && !ctx.only.includes('refactor')) {
@@ -27,17 +27,11 @@ function create(ts, getTsPluginClient) {
                     if (startOffset === endOffset) {
                         return;
                     }
-                    const uri = vscode_uri_1.URI.parse(document.uri);
-                    const decoded = context.decodeEmbeddedDocumentUri(uri);
-                    const sourceScript = decoded && context.language.scripts.get(decoded[0]);
-                    const virtualCode = decoded && sourceScript?.generated?.embeddedCodes.get(decoded[1]);
-                    if (!sourceScript?.generated || virtualCode?.id !== 'template') {
-                        return;
-                    }
-                    const root = sourceScript.generated.root;
-                    if (!(root instanceof language_core_1.VueVirtualCode)) {
+                    const info = (0, utils_1.getEmbeddedInfo)(context, document, 'template');
+                    if (!info) {
                         return;
                     }
+                    const { root } = info;
                     const { sfc } = root;
                     const script = sfc.scriptSetup ?? sfc.script;
                     if (!sfc.template || !script) {
@@ -62,17 +56,11 @@ function create(ts, getTsPluginClient) {
                 async resolveCodeAction(codeAction) {
                     const { uri, range, newName } = codeAction.data;
                     const [startOffset, endOffset] = range;
-                    const parsedUri = vscode_uri_1.URI.parse(uri);
-                    const decoded = context.decodeEmbeddedDocumentUri(parsedUri);
-                    const sourceScript = decoded && context.language.scripts.get(decoded[0]);
-                    const virtualCode = decoded && sourceScript?.generated?.embeddedCodes.get(decoded[1]);
-                    if (!sourceScript?.generated || virtualCode?.id !== 'template') {
-                        return codeAction;
-                    }
-                    const root = sourceScript.generated.root;
-                    if (!(root instanceof language_core_1.VueVirtualCode)) {
+                    const info = (0, utils_1.getEmbeddedInfo)(context, { uri }, 'template');
+                    if (!info) {
                         return codeAction;
                     }
+                    const { sourceScript, virtualCode, root } = info;
                     const { sfc } = root;
                     const script = sfc.scriptSetup ?? sfc.script;
                     if (!sfc.template || !script) {
@@ -83,13 +71,10 @@ function create(ts, getTsPluginClient) {
                         return codeAction;
                     }
                     const toExtract = await tsPluginClient?.collectExtractProps(root.fileName, templateCodeRange) ?? [];
-                    if (!toExtract) {
-                        return codeAction;
-                    }
                     const templateInitialIndent = await context.env.getConfiguration('vue.format.template.initialIndent') ?? true;
                     const scriptInitialIndent = await context.env.getConfiguration('vue.format.script.initialIndent')
                         ?? false;
-                    const document = context.documents.get(parsedUri, virtualCode.languageId, virtualCode.snapshot);
+                    const document = context.documents.get(vscode_uri_1.URI.parse(uri), virtualCode.languageId, virtualCode.snapshot);
                     const sfcDocument = context.documents.get(sourceScript.id, sourceScript.languageId, sourceScript.snapshot);
                     const newUri = sfcDocument.uri.slice(0, sfcDocument.uri.lastIndexOf('/') + 1) + `${newName}.vue`;
                     const lastImportNode = getLastImportNode(ts, script.ast);
@@ -184,7 +169,7 @@ function create(ts, getTsPluginClient) {
                         const props = toExtract.filter(p => !p.model);
                         const models = toExtract.filter(p => p.model);
                         if (props.length) {
-                            lines.push(`defineProps<{ \n\t${props.map(p => `${p.name}: ${p.type};`).join('\n\t')}\n}>()`);
+                            lines.push(`defineProps<{\n\t${props.map(p => `${p.name}: ${p.type};`).join('\n\t')}\n}>()`);
                         }
                         for (const model of models) {
                             lines.push(`const ${model.name} = defineModel<${model.type}>('${model.name}', { required: true })`);

package/lib/plugins/vue-global-types-error.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.create = create;
+const utils_1 = require("./utils");
 function create() {
     return {
-        name: 'vue-compiler-dom-errors',
+        name: 'vue-global-types-error',
         capabilities: {
             diagnosticProvider: {
                 interFileDependencies: false,
@@ -13,22 +14,35 @@ function create() {
         create(context) {
             return {
                 provideDiagnostics(document) {
-                    if (document.languageId !== 'vue-root-tags') {
+                    const info = (0, utils_1.getEmbeddedInfo)(context, document, 'root_tags');
+                    if (!info) {
                         return;
                     }
-                    const vueCompilerOptions = context.project.vue?.compilerOptions;
-                    if (vueCompilerOptions && vueCompilerOptions.globalTypesPath === undefined) {
-                        return [{
-                                range: {
-                                    start: document.positionAt(0),
-                                    end: document.positionAt(0),
-                                },
-                                severity: 1,
-                                code: 404,
-                                source: 'vue',
-                                message: `Write global types file failed. Please ensure that "node_modules" exists and "${vueCompilerOptions.lib}" is a direct dependency, or set "vueCompilerOptions.globalTypesPath" in "tsconfig.json" manually.`,
-                            }];
+                    const { root } = info;
+                    const { vueCompilerOptions } = root;
+                    const globalTypesPath = vueCompilerOptions.globalTypesPath(root.fileName);
+                    if (globalTypesPath) {
+                        return;
                     }
+                    return [{
+                            range: {
+                                start: document.positionAt(0),
+                                end: document.positionAt(0),
+                            },
+                            severity: 2,
+                            code: 404,
+                            source: 'vue',
+                            message: `
+Failed to write the global types file. Make sure that:
+
+1. "node_modules" directory exists.
+2. "${vueCompilerOptions.lib}" is installed as a direct dependency.
+
+Alternatively, you can manually set "vueCompilerOptions.globalTypesPath" in your "tsconfig.json".
+
+If all dependencies are installed, try running the "vue.action.restartServer" command to restart Vue and TS servers.
+						`.trim(),
+                        }];
                 },
             };
         },

package/lib/plugins/vue-inlayhints.js

@@ -3,39 +3,38 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.create = create;
 exports.findDestructuredProps = findDestructuredProps;
 const language_core_1 = require("@vue/language-core");
-const vscode_uri_1 = require("vscode-uri");
+const utils_1 = require("./utils");
 function create(ts) {
     return {
-        name: 'vue-inlay-hints',
+        name: 'vue-inlayhints',
         capabilities: {
             inlayHintProvider: {},
         },
         create(context) {
             return {
                 async provideInlayHints(document, range) {
-                    const uri = vscode_uri_1.URI.parse(document.uri);
-                    const decoded = context.decodeEmbeddedDocumentUri(uri);
-                    const sourceScript = decoded && context.language.scripts.get(decoded[0]);
-                    const virtualCode = decoded && sourceScript?.generated?.embeddedCodes.get(decoded[1]);
-                    if (!(virtualCode instanceof language_core_1.VueVirtualCode)) {
+                    const info = (0, utils_1.getEmbeddedInfo)(context, document, 'main');
+                    if (!info) {
                         return;
                     }
+                    const { root } = info;
                     const settings = {};
                     async function getSettingEnabled(key) {
                         return settings[key] ??= await context.env.getConfiguration?.(key) ?? false;
                     }
                     const result = [];
-                    const codegen = language_core_1.tsCodegen.get(virtualCode.sfc);
+                    const { sfc } = root;
+                    const codegen = language_core_1.tsCodegen.get(sfc);
                     const inlayHints = [
                         ...codegen?.getGeneratedTemplate()?.inlayHints ?? [],
                         ...codegen?.getGeneratedScript()?.inlayHints ?? [],
                     ];
                     const scriptSetupRanges = codegen?.getScriptSetupRanges();
-                    if (scriptSetupRanges?.defineProps?.destructured && virtualCode.sfc.scriptSetup?.ast) {
+                    if (scriptSetupRanges?.defineProps?.destructured && sfc.scriptSetup?.ast) {
                         const setting = 'vue.inlayHints.destructuredProps';
                         const enabled = await getSettingEnabled(setting);
                         if (enabled) {
-                            for (const [prop, isShorthand] of findDestructuredProps(ts, virtualCode.sfc.scriptSetup.ast, scriptSetupRanges.defineProps.destructured.keys())) {
+                            for (const [prop, isShorthand] of findDestructuredProps(ts, sfc.scriptSetup.ast, scriptSetupRanges.defineProps.destructured.keys())) {
                                 const name = prop.text;
                                 const end = prop.getEnd();
                                 const pos = isShorthand ? end : end - name.length;
@@ -50,9 +49,9 @@ function create(ts) {
                         }
                     }
                     const blocks = [
-                        virtualCode.sfc.template,
-                        virtualCode.sfc.script,
-                        virtualCode.sfc.scriptSetup,
+                        sfc.template,
+                        sfc.script,
+                        sfc.scriptSetup,
                     ];
                     const start = document.offsetAt(range.start);
                     const end = document.offsetAt(range.end);
@@ -149,7 +148,7 @@ function findDestructuredProps(ts, ast, props) {
             && initializer
             && ts.isCallExpression(initializer)
             && initializer.expression.getText(ast) === 'defineProps';
-        for (const { id } of (0, language_core_1.collectIdentifiers)(ts, name)) {
+        for (const { id } of (0, language_core_1.collectBindingIdentifiers)(ts, name)) {
             if (isDefineProps) {
                 excludedIds.add(id);
             }
@@ -164,7 +163,7 @@ function findDestructuredProps(ts, ast, props) {
             registerLocalBinding(name);
         }
         for (const p of parameters) {
-            for (const { id } of (0, language_core_1.collectIdentifiers)(ts, p)) {
+            for (const { id } of (0, language_core_1.collectBindingIdentifiers)(ts, p)) {
                 registerLocalBinding(id);
             }
         }

package/lib/plugins/vue-missing-props-hints.d.ts

@@ -1,2 +1,2 @@
-import type { LanguageServiceContext, LanguageServicePlugin } from '@volar/language-service';
-export declare function create(getTsPluginClient?: (context: LanguageServiceContext) => import('@vue/typescript-plugin/lib/requests').Requests | undefined): LanguageServicePlugin;
+import type { LanguageServicePlugin } from '@volar/language-service';
+export declare function create(tsPluginClient: import('@vue/typescript-plugin/lib/requests').Requests | undefined): LanguageServicePlugin;