refactor(typescript-plugin): explicitly request parameters

packages/typescript-plugin/index.ts

@@ -2,6 +2,7 @@ import { createLanguageServicePlugin } from '@volar/typescript/lib/quickstart/cr
 import * as vue from '@vue/language-core';
 import type * as ts from 'typescript';
 import { createVueLanguageServiceProxy } from './lib/common';
+import type { Requests } from './lib/requests';
 import { collectExtractProps } from './lib/requests/collectExtractProps';
 import { getComponentDirectives } from './lib/requests/getComponentDirectives';
 import { getComponentEvents } from './lib/requests/getComponentEvents';
@@ -12,7 +13,6 @@ import { getElementAttrs } from './lib/requests/getElementAttrs';
 import { getElementNames } from './lib/requests/getElementNames';
 import { getImportPathForFile } from './lib/requests/getImportPathForFile';
 import { getPropertiesAtLocation } from './lib/requests/getPropertiesAtLocation';
-import type { RequestContext } from './lib/requests/types';
 
 const windowsPathReg = /\\/g;
 const project2Service = new WeakMap<
@@ -43,6 +43,7 @@ export = createLanguageServicePlugin(
 					language,
 					info.languageService,
 					vueOptions,
+					fileName => fileName,
 				);
 
 				// #3963
@@ -85,89 +86,131 @@ export = createLanguageServicePlugin(
 				return;
 			}
 
-			session.addProtocolHandler('_vue:projectInfo', ({ arguments: args }) => {
-				return (session as any).handlers.get('projectInfo')?.({ arguments: args });
+			session.addProtocolHandler('_vue:projectInfo', request => {
+				return (session as any).handlers.get('projectInfo')?.(request);
 			});
-			session.addProtocolHandler('_vue:documentHighlights-full', ({ arguments: args }) => {
-				return (session as any).handlers.get('documentHighlights-full')?.({ arguments: args });
+			session.addProtocolHandler('_vue:documentHighlights-full', request => {
+				return (session as any).handlers.get('documentHighlights-full')?.(request);
 			});
-			session.addProtocolHandler('_vue:encodedSemanticClassifications-full', ({ arguments: args }) => {
-				return (session as any).handlers.get('encodedSemanticClassifications-full')?.({ arguments: args });
+			session.addProtocolHandler('_vue:encodedSemanticClassifications-full', request => {
+				return (session as any).handlers.get('encodedSemanticClassifications-full')?.(request);
 			});
-			session.addProtocolHandler('_vue:quickinfo', ({ arguments: args }) => {
-				return (session as any).handlers.get('quickinfo')?.({ arguments: args });
+			session.addProtocolHandler('_vue:quickinfo', request => {
+				return (session as any).handlers.get('quickinfo')?.(request);
 			});
-			session.addProtocolHandler('_vue:collectExtractProps', ({ arguments: args }) => {
+			session.addProtocolHandler(
+				'_vue:collectExtractProps',
+				request => {
+					const [fileName, templateCodeRange]: Parameters<Requests['collectExtractProps']> = request.arguments;
+					const { language, program, sourceScript, virtualCode } = getLanguageServiceAndVirtualCode(fileName);
+					return {
+						response: collectExtractProps(ts, language, program, sourceScript, virtualCode, templateCodeRange),
+					};
+				},
+			);
+			session.addProtocolHandler('_vue:getImportPathForFile', request => {
+				const [fileName, incomingFileName, preferences]: Parameters<Requests['getImportPathForFile']> =
+					request.arguments;
+				const { languageServiceHost, program } = getLanguageService(fileName);
 				return {
-					response: collectExtractProps.apply(getRequestContext(args[0]), args),
+					response: getImportPathForFile(ts, languageServiceHost, program, fileName, incomingFileName, preferences),
 				};
 			});
-			session.addProtocolHandler('_vue:getImportPathForFile', ({ arguments: args }) => {
+			session.addProtocolHandler('_vue:getPropertiesAtLocation', request => {
+				const [fileName, position]: Parameters<Requests['getPropertiesAtLocation']> = request.arguments;
+				const { language, program, sourceScript, virtualCode } = getLanguageServiceAndVirtualCode(fileName);
 				return {
-					response: getImportPathForFile.apply(getRequestContext(args[0]), args),
+					response: getPropertiesAtLocation(ts, language, program, sourceScript, virtualCode, position),
 				};
 			});
-			session.addProtocolHandler('_vue:getPropertiesAtLocation', ({ arguments: args }) => {
+			session.addProtocolHandler('_vue:getComponentDirectives', request => {
+				const [fileName]: Parameters<Requests['getComponentDirectives']> = request.arguments;
+				const { program } = getLanguageService(fileName);
 				return {
-					response: getPropertiesAtLocation.apply(getRequestContext(args[0]), args),
+					response: getComponentDirectives(ts, program, fileName),
 				};
 			});
-			session.addProtocolHandler('_vue:getComponentDirectives', ({ arguments: args }) => {
+			session.addProtocolHandler('_vue:getComponentEvents', request => {
+				const [fileName, tag]: Parameters<Requests['getComponentEvents']> = request.arguments;
+				const { program } = getLanguageService(fileName);
 				return {
-					response: getComponentDirectives.apply(getRequestContext(args[0]), args),
+					response: getComponentEvents(ts, program, fileName, tag),
 				};
 			});
-			session.addProtocolHandler('_vue:getComponentEvents', ({ arguments: args }) => {
+			session.addProtocolHandler('_vue:getComponentNames', request => {
+				const [fileName]: Parameters<Requests['getComponentNames']> = request.arguments;
+				const { program } = getLanguageService(fileName);
 				return {
-					response: getComponentEvents.apply(getRequestContext(args[0]), args),
+					response: getComponentNames(ts, program, fileName),
 				};
 			});
-			session.addProtocolHandler('_vue:getComponentNames', ({ arguments: args }) => {
+			session.addProtocolHandler('_vue:getComponentProps', request => {
+				const [fileName, tag]: Parameters<Requests['getComponentProps']> = request.arguments;
+				const { program } = getLanguageService(fileName);
 				return {
-					response: getComponentNames.apply(getRequestContext(args[0]), args) ?? [],
+					response: getComponentProps(ts, program, fileName, tag),
 				};
 			});
-			session.addProtocolHandler('_vue:getComponentProps', ({ arguments: args }) => {
+			session.addProtocolHandler('_vue:getComponentSlots', request => {
+				const [fileName]: Parameters<Requests['getComponentSlots']> = request.arguments;
+				const { program, virtualCode } = getLanguageServiceAndVirtualCode(fileName);
 				return {
-					response: getComponentProps.apply(getRequestContext(args[0]), args),
+					response: getComponentSlots(ts, program, virtualCode),
 				};
 			});
-			session.addProtocolHandler('_vue:getComponentSlots', ({ arguments: args }) => {
+			session.addProtocolHandler('_vue:getElementAttrs', request => {
+				const [fileName, tag]: Parameters<Requests['getElementAttrs']> = request.arguments;
+				const { program } = getLanguageService(fileName);
 				return {
-					response: getComponentSlots.apply(getRequestContext(args[0]), args),
+					response: getElementAttrs(ts, program, fileName, tag),
 				};
 			});
-			session.addProtocolHandler('_vue:getElementAttrs', ({ arguments: args }) => {
+			session.addProtocolHandler('_vue:getElementNames', request => {
+				const [fileName]: Parameters<Requests['getElementNames']> = request.arguments;
+				const { program } = getLanguageService(fileName);
 				return {
-					response: getElementAttrs.apply(getRequestContext(args[0]), args),
-				};
-			});
-			session.addProtocolHandler('_vue:getElementNames', ({ arguments: args }) => {
-				return {
-					response: getElementNames.apply(getRequestContext(args[0]), args),
+					response: getElementNames(ts, program, fileName),
 				};
 			});
 
 			projectService.logger.info('Vue specific commands are successfully added.');
 		}
 
-		function getRequestContext(fileName: string): RequestContext {
-			const fileAndProject = (info.session as any).getFileAndProject({
+		function getLanguageServiceAndVirtualCode(fileName: string) {
+			const service = getLanguageService(fileName);
+			const sourceScript = service?.language.scripts.get(fileName);
+			if (!sourceScript) {
+				throw new Error('No source script found for file: ' + fileName);
+			}
+			const virtualCode = sourceScript.generated?.root;
+			if (!(virtualCode instanceof vue.VueVirtualCode)) {
+				throw new Error('No virtual code found for file: ' + fileName);
+			}
+			return {
+				...service,
+				sourceScript,
+				virtualCode,
+			};
+		}
+
+		function getLanguageService(fileName: string) {
+			const { project } = (info.session as any).getFileAndProject({
 				file: fileName,
 				projectFileName: undefined,
 			}) as {
 				file: ts.server.NormalizedPath;
 				project: ts.server.Project;
 			};
-			const service = project2Service.get(fileAndProject.project);
+			const service = project2Service.get(project);
 			if (!service) {
-				throw 'No RequestContext';
+				throw new Error('No vue service for project: ' + project.getProjectName());
 			}
+			const [language, languageServiceHost, languageService] = service;
 			return {
 				typescript: ts,
-				languageService: service[2],
-				languageServiceHost: service[1],
-				language: service[0],
+				program: languageService.getProgram()!,
+				languageServiceHost,
+				language,
 			};
 		}
 	},

packages/typescript-plugin/lib/common.ts

@@ -4,23 +4,24 @@ import type * as ts from 'typescript';
 
 const windowsPathReg = /\\/g;
 
-export function createVueLanguageServiceProxy(
+export function createVueLanguageServiceProxy<T>(
 	ts: typeof import('typescript'),
-	language: Language<string>,
+	language: Language<T>,
 	languageService: ts.LanguageService,
 	vueOptions: VueCompilerOptions,
+	asScriptId: (fileName: string) => T,
 ) {
 	const proxyCache = new Map<string | symbol, Function | undefined>();
 	const getProxyMethod = (target: ts.LanguageService, p: string | symbol): Function | undefined => {
 		switch (p) {
 			case 'getCompletionsAtPosition':
-				return getCompletionsAtPosition(ts, language, vueOptions, target[p]);
+				return getCompletionsAtPosition(ts, language, asScriptId, vueOptions, target[p]);
 			case 'getCompletionEntryDetails':
 				return getCompletionEntryDetails(language, target[p]);
 			case 'getCodeFixesAtPosition':
 				return getCodeFixesAtPosition(target[p]);
 			case 'getDefinitionAndBoundSpan':
-				return getDefinitionAndBoundSpan(ts, language, languageService, vueOptions, target[p]);
+				return getDefinitionAndBoundSpan(ts, language, asScriptId, languageService, vueOptions, target[p]);
 		}
 	};
 
@@ -43,9 +44,10 @@ export function createVueLanguageServiceProxy(
 	});
 }
 
-function getCompletionsAtPosition(
+function getCompletionsAtPosition<T>(
 	ts: typeof import('typescript'),
-	language: Language<string>,
+	language: Language<T>,
+	asScriptId: (fileName: string) => T,
 	vueOptions: VueCompilerOptions,
 	getCompletionsAtPosition: ts.LanguageService['getCompletionsAtPosition'],
 ): ts.LanguageService['getCompletionsAtPosition'] {
@@ -61,7 +63,7 @@ function getCompletionsAtPosition(
 			);
 
 			// filter global variables in template and styles
-			const sourceScript = language.scripts.get(fileName);
+			const sourceScript = language.scripts.get(asScriptId(fileName));
 			const root = sourceScript?.generated?.root;
 			if (root instanceof VueVirtualCode) {
 				const blocks = [
@@ -129,8 +131,8 @@ function getCompletionsAtPosition(
 	};
 }
 
-function getCompletionEntryDetails(
-	language: Language<string>,
+function getCompletionEntryDetails<T>(
+	language: Language<T>,
 	getCompletionEntryDetails: ts.LanguageService['getCompletionEntryDetails'],
 ): ts.LanguageService['getCompletionEntryDetails'] {
 	return (...args) => {
@@ -187,9 +189,10 @@ function getCodeFixesAtPosition(
 	};
 }
 
-function getDefinitionAndBoundSpan(
+function getDefinitionAndBoundSpan<T>(
 	ts: typeof import('typescript'),
-	language: Language<string>,
+	language: Language<T>,
+	asScriptId: (fileName: string) => T,
 	languageService: ts.LanguageService,
 	vueOptions: VueCompilerOptions,
 	getDefinitionAndBoundSpan: ts.LanguageService['getDefinitionAndBoundSpan'],
@@ -201,7 +204,7 @@ function getDefinitionAndBoundSpan(
 		}
 
 		const program = languageService.getProgram()!;
-		const sourceScript = language.scripts.get(fileName);
+		const sourceScript = language.scripts.get(asScriptId(fileName));
 		if (!sourceScript?.generated) {
 			return result;
 		}

packages/typescript-plugin/lib/requests/collectExtractProps.ts

@@ -1,5 +1,5 @@
-import { isSemanticTokensEnabled, VueVirtualCode } from '@vue/language-core';
-import type { RequestContext } from './types';
+import { isSemanticTokensEnabled, type Language, type SourceScript, type VueVirtualCode } from '@vue/language-core';
+import type * as ts from 'typescript';
 
 interface ExtractPropsInfo {
 	name: string;
@@ -8,25 +8,19 @@ interface ExtractPropsInfo {
 }
 
 export function collectExtractProps(
-	this: RequestContext,
-	fileName: string,
+	ts: typeof import('typescript'),
+	language: Language,
+	program: ts.Program,
+	sourceScript: SourceScript,
+	virtualCode: VueVirtualCode,
 	templateCodeRange: [number, number],
 ): ExtractPropsInfo[] {
-	const { typescript: ts, languageService, language } = this;
-
-	const sourceScript = language.scripts.get(fileName);
-	const root = sourceScript?.generated?.root;
-	if (!sourceScript?.generated || !(root instanceof VueVirtualCode)) {
-		return [];
-	}
-
 	const result = new Map<string, ExtractPropsInfo>();
-	const program = languageService.getProgram()!;
-	const sourceFile = program.getSourceFile(fileName)!;
+	const sourceFile = program.getSourceFile(virtualCode.fileName)!;
 	const checker = program.getTypeChecker();
-	const script = sourceScript.generated.languagePlugin.typescript?.getServiceScript(root);
-	const maps = script ? [...language.maps.forEach(script.code)].map(([, map]) => map) : [];
-	const { sfc } = root;
+	const serviceScript = sourceScript.generated!.languagePlugin.typescript?.getServiceScript(virtualCode);
+	const maps = serviceScript ? [...language.maps.forEach(serviceScript.code)].map(([, map]) => map) : [];
+	const { sfc } = virtualCode;
 
 	sourceFile.forEachChild(function visit(node) {
 		if (

packages/typescript-plugin/lib/requests/getComponentDirectives.ts

@@ -1,5 +1,4 @@
-import { VueVirtualCode } from '@vue/language-core';
-import type { RequestContext } from './types';
+import type * as ts from 'typescript';
 import { getVariableType } from './utils';
 
 const builtInDirectives = new Set([
@@ -12,18 +11,11 @@ const builtInDirectives = new Set([
 ]);
 
 export function getComponentDirectives(
-	this: RequestContext,
+	ts: typeof import('typescript'),
+	program: ts.Program,
 	fileName: string,
 ): string[] {
-	const { typescript: ts, language, languageService } = this;
-
-	const sourceScript = language.scripts.get(fileName);
-	const root = sourceScript?.generated?.root;
-	if (!sourceScript?.generated || !(root instanceof VueVirtualCode)) {
-		return [];
-	}
-
-	const directives = getVariableType(ts, languageService, root, '__VLS_directives');
+	const directives = getVariableType(ts, program, fileName, '__VLS_directives');
 	if (!directives) {
 		return [];
 	}

packages/typescript-plugin/lib/requests/getComponentEvents.ts

@@ -1,28 +1,19 @@
-import { VueVirtualCode } from '@vue/language-core';
-import type { RequestContext } from './types';
+import type * as ts from 'typescript';
 import { getComponentType, getVariableType } from './utils';
 
 export function getComponentEvents(
-	this: RequestContext,
+	ts: typeof import('typescript'),
+	program: ts.Program,
 	fileName: string,
 	tag: string,
 ): string[] {
-	const { typescript: ts, language, languageService } = this;
-
-	const sourceScript = language.scripts.get(fileName);
-	const root = sourceScript?.generated?.root;
-	if (!sourceScript?.generated || !(root instanceof VueVirtualCode)) {
-		return [];
-	}
-
-	const program = languageService.getProgram()!;
 	const checker = program.getTypeChecker();
-	const components = getVariableType(ts, languageService, root, '__VLS_components');
+	const components = getVariableType(ts, program, fileName, '__VLS_components');
 	if (!components) {
 		return [];
 	}
 
-	const componentType = getComponentType(ts, languageService, root, components, fileName, tag);
+	const componentType = getComponentType(ts, program, fileName, components, tag);
 	if (!componentType) {
 		return [];
 	}