refactor(language-server): move in server code from insiders edition (#5423)

Author: johnsoncodehk

extensions/vscode/lib/splitEditors.ts

@@ -1,4 +1,4 @@
-import { ExecuteCommandRequest, type BaseLanguageClient, type ExecuteCommandParams } from '@volar/vscode';
+import { type BaseLanguageClient } from '@volar/vscode';
 import type { SFCBlock, SFCParseResult } from '@vue/compiler-sfc';
 import { executeCommand, useActiveTextEditor, useCommand } from 'reactive-vscode';
 import * as vscode from 'vscode';
@@ -20,10 +20,9 @@ export function activate(client: BaseLanguageClient) {
 		if (!astMap.has(doc) || astMap.get(doc)![0] !== doc.version) {
 			astMap.set(doc, [
 				doc.version,
-				client.sendRequest(ExecuteCommandRequest.type, {
-					command: 'vue.parseSfc',
-					arguments: [doc.getText()],
-				} satisfies ExecuteCommandParams),
+				client.sendRequest('vue/parseSfc', {
+					textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(doc),
+				}),
 			]);
 		}
 		const ast = await astMap.get(doc)![1];

packages/language-core/lib/parsers/scriptSetupRanges.ts

@@ -451,7 +451,7 @@ export function parseBindingRanges(ts: typeof import('typescript'), ast: ts.Sour
 	}
 }
 
-function findBindingVars(
+export function findBindingVars(
 	ts: typeof import('typescript'),
 	left: ts.BindingName,
 	ast: ts.SourceFile

packages/language-server/index.ts

@@ -1,10 +1,13 @@
-import type { LanguageServer } from '@volar/language-server';
+import type { LanguageServer, Position, TextDocumentIdentifier } from '@volar/language-server';
+import { type Range, TextDocument } from '@volar/language-server';
 import { createLanguageServiceEnvironment } from '@volar/language-server/lib/project/simpleProject';
 import { createConnection, createServer } from '@volar/language-server/node';
-import { createLanguage, createParsedCommandLine, createVueLanguagePlugin, getDefaultCompilerOptions } from '@vue/language-core';
-import { createLanguageService, createUriMap, createVueLanguageServicePlugins, type LanguageService } from '@vue/language-service';
+import { createLanguage, createParsedCommandLine, createVueLanguagePlugin, forEachEmbeddedCode, getDefaultCompilerOptions, isReferencesEnabled, parse } from '@vue/language-core';
+import { createLanguageService, createUriMap, createVueLanguageServicePlugins, type DocumentsAndMap, getSourceRange, type LanguageService } from '@vue/language-service';
 import * as ts from 'typescript';
 import { URI } from 'vscode-uri';
+import { analyze } from './lib/reactionsAnalyze';
+import { getLanguageService } from './lib/reactionsAnalyzeLS';
 
 const connection = createConnection();
 const server = createServer(connection);
@@ -186,3 +189,183 @@ connection.onInitialize(params => {
 connection.onInitialized(server.initialized);
 
 connection.onShutdown(server.shutdown);
+
+connection.onRequest('vue/parseSfc', (params: {
+	textDocument: TextDocumentIdentifier;
+}) => {
+	const document = server.documents.get(URI.parse(params.textDocument.uri));
+	if (document) {
+		return parse(document.getText());
+	}
+});
+
+connection.onRequest('vue/interpolationRanges', async (params: {
+	textDocument: TextDocumentIdentifier;
+}): Promise<[number, number][]> => {
+	const uri = URI.parse(params.textDocument.uri);
+	const languageService = await server.project.getLanguageService(uri);
+	if (languageService) {
+		const sourceFile = languageService.context.language.scripts.get(uri);
+		if (sourceFile?.generated) {
+			const ranges: [number, number][] = [];
+			for (const code of forEachEmbeddedCode(sourceFile.generated.root)) {
+				const codeText = code.snapshot.getText(0, code.snapshot.getLength());
+				if (
+					(
+						code.id.startsWith('template_inline_ts_')
+						&& codeText.startsWith('0 +')
+						&& codeText.endsWith('+ 0;')
+					)
+					|| (code.id.startsWith('style_') && code.id.endsWith('_inline_ts'))
+				) {
+					for (const mapping of code.mappings) {
+						for (let i = 0; i < mapping.sourceOffsets.length; i++) {
+							ranges.push([
+								mapping.sourceOffsets[i],
+								mapping.sourceOffsets[i] + mapping.lengths[i],
+							]);
+						}
+					}
+				}
+			}
+			return ranges;
+		}
+	}
+	return [];
+});
+
+const cacheDocuments = new Map<string, [TextDocument, import('typescript').IScriptSnapshot]>();
+
+connection.onRequest('vue/reactionsAnalyze', async (params: {
+	textDocument: TextDocumentIdentifier;
+	position: Position;
+	syncDocument?: {
+		content: string;
+		languageId: string;
+	};
+}): Promise<{
+	subscribers: Range[];
+	dependencies: Range[];
+} | undefined> => {
+	if (params.syncDocument) {
+		const document = TextDocument.create(params.textDocument.uri, params.syncDocument.languageId, 0, params.syncDocument.content);
+		const snapshot = ts.ScriptSnapshot.fromString(params.syncDocument.content);
+		cacheDocuments.set(params.textDocument.uri, [document, snapshot]);
+	}
+	const uri = URI.parse(params.textDocument.uri);
+	const languageService = await server.project.getLanguageService(uri);
+	const sourceScript = languageService.context.language.scripts.get(uri);
+	let document: TextDocument | undefined;
+	let snapshot: import('typescript').IScriptSnapshot | undefined;
+	if (sourceScript) {
+		document = languageService.context.documents.get(sourceScript.id, sourceScript.languageId, sourceScript.snapshot);
+		snapshot = sourceScript.snapshot;
+	}
+	else if (cacheDocuments.has(params.textDocument.uri)) {
+		const [doc, snap] = cacheDocuments.get(params.textDocument.uri)!;
+		document = doc;
+		snapshot = snap;
+	}
+	if (!document || !snapshot) {
+		return;
+	}
+	let offset = document.offsetAt(params.position);
+	if (sourceScript?.generated) {
+		const serviceScript = sourceScript.generated.languagePlugin.typescript?.getServiceScript(sourceScript.generated.root);
+		if (!serviceScript) {
+			return;
+		}
+		const map = languageService.context.language.maps.get(serviceScript.code, sourceScript);
+		let embeddedOffset: number | undefined;
+		for (const [mapped, mapping] of map.toGeneratedLocation(offset)) {
+			if (isReferencesEnabled(mapping.data)) {
+				embeddedOffset = mapped;
+				break;
+			}
+		}
+		if (embeddedOffset === undefined) {
+			return;
+		}
+		offset = embeddedOffset;
+
+		const embeddedUri = languageService.context.encodeEmbeddedDocumentUri(sourceScript.id, serviceScript.code.id);
+		document = languageService.context.documents.get(embeddedUri, serviceScript.code.languageId, serviceScript.code.snapshot);
+		snapshot = serviceScript.code.snapshot;
+	}
+	const { languageService: tsLs, fileName } = getLanguageService(ts, snapshot, document.languageId);
+	const result = analyze(ts, tsLs, fileName, offset);
+	if (!result) {
+		return;
+	}
+	const subscribers: Range[] = [];
+	const dependencies: Range[] = [];
+	if (sourceScript?.generated) {
+		const serviceScript = sourceScript.generated.languagePlugin.typescript?.getServiceScript(sourceScript.generated.root);
+		if (!serviceScript) {
+			return;
+		}
+		const docs: DocumentsAndMap = [
+			languageService.context.documents.get(sourceScript.id, sourceScript.languageId, sourceScript.snapshot),
+			document,
+			languageService.context.language.maps.get(serviceScript.code, sourceScript),
+		];
+		for (const dependency of result.dependencies) {
+			let start = document.positionAt(dependency.getStart(result.sourceFile));
+			let end = document.positionAt(dependency.getEnd());
+			if (ts.isBlock(dependency) && dependency.statements.length) {
+				const { statements } = dependency;
+				start = document.positionAt(statements[0].getStart(result.sourceFile));
+				end = document.positionAt(statements[statements.length - 1].getEnd());
+			}
+			const sourceRange = getSourceRange(docs, { start, end });
+			if (sourceRange) {
+				dependencies.push(sourceRange);
+			}
+		}
+		for (const subscriber of result.subscribers) {
+			if (!subscriber.sideEffectInfo) {
+				continue;
+			}
+			let start = document.positionAt(subscriber.sideEffectInfo.handler.getStart(result.sourceFile));
+			let end = document.positionAt(subscriber.sideEffectInfo.handler.getEnd());
+			if (ts.isBlock(subscriber.sideEffectInfo.handler) && subscriber.sideEffectInfo.handler.statements.length) {
+				const { statements } = subscriber.sideEffectInfo.handler;
+				start = document.positionAt(statements[0].getStart(result.sourceFile));
+				end = document.positionAt(statements[statements.length - 1].getEnd());
+			}
+			const sourceRange = getSourceRange(docs, { start, end });
+			if (sourceRange) {
+				subscribers.push(sourceRange);
+			}
+		}
+	}
+	else {
+		for (const dependency of result.dependencies) {
+			let start = document.positionAt(dependency.getStart(result.sourceFile));
+			let end = document.positionAt(dependency.getEnd());
+			if (ts.isBlock(dependency) && dependency.statements.length) {
+				const { statements } = dependency;
+				start = document.positionAt(statements[0].getStart(result.sourceFile));
+				end = document.positionAt(statements[statements.length - 1].getEnd());
+			}
+			dependencies.push({ start, end });
+		}
+		for (const subscriber of result.subscribers) {
+			if (!subscriber.sideEffectInfo) {
+				continue;
+			}
+			let start = document.positionAt(subscriber.sideEffectInfo.handler.getStart(result.sourceFile));
+			let end = document.positionAt(subscriber.sideEffectInfo.handler.getEnd());
+			if (ts.isBlock(subscriber.sideEffectInfo.handler) && subscriber.sideEffectInfo.handler.statements.length) {
+				const { statements } = subscriber.sideEffectInfo.handler;
+				start = document.positionAt(statements[0].getStart(result.sourceFile));
+				end = document.positionAt(statements[statements.length - 1].getEnd());
+			}
+			subscribers.push({ start, end });
+		}
+	}
+	return {
+		subscribers,
+		dependencies,
+	};
+});