@adecore/lsp 0.38.0 → 0.40.0

package/src/session.ts

@@ -115,10 +115,13 @@ function matches(options: ProviderOptions, document?: Pick<DocumentItem, 'uri' |
     if (options.documentSelector == null) {
         return true;
     }
+
     if (!document) {
         return options.documentSelector.length > 0;
     }
+
     const url = new URL(document.uri);
+
     return options.documentSelector.some(
         (filter) =>
             (!filter.language || filter.language === document.languageId) &&
@@ -132,18 +135,23 @@ function offersMethod(method: string, options: ProviderOptions): boolean {
     if (method.endsWith('/resolve')) {
         return options.resolveProvider === true;
     }
+
     if (method === 'textDocument/prepareRename') {
         return options.prepareProvider === true;
     }
+
     if (method === 'textDocument/semanticTokens/full/delta') {
         return typeof options.full === 'object' && options.full.delta === true;
     }
+
     if (method === 'textDocument/semanticTokens/full') {
         return !!options.full;
     }
+
     if (method === 'textDocument/semanticTokens/range') {
         return !!options.range;
     }
+
     return true;
 }
 
@@ -166,54 +174,75 @@ export class LspSession {
         this.options = options;
         this.connection = new JsonRpcConnection(transport, options.timeoutMs);
         this.configuration = options.configuration ?? {};
+
         this.connection.onClose(() => {
             this.phase = 'closed';
+
             for (const document of [...this.documents.values()]) {
                 document.disconnect();
             }
         });
+
         this.connection.onNotification('textDocument/publishDiagnostics', (params) => {
             const diagnostics = params as PublishDiagnosticsParams;
             const document = this.documents.get(fileUriKey(diagnostics.uri));
+
             if (!document || document.isClosed || (diagnostics.version !== undefined && diagnostics.version !== document.version)) {
                 return;
             }
+
             this.emitDiagnostics({ ...diagnostics, uri: document.uri });
         });
+
         this.connection.onRequest('workspace/configuration', async (params) => {
             const { items } = params as { items: ConfigurationItem[] };
+
             return Promise.all(items.map((item) => (options.onConfiguration ? options.onConfiguration(item) : this.readConfiguration(item.section))));
         });
+
         this.connection.onRequest('workspace/workspaceFolders', () => this.workspaceFolders);
+
         this.connection.onRequest(
             'workspace/applyEdit',
             (params) => options.onApplyEdit?.(params as ApplyWorkspaceEditParams) ?? { applied: false, failureReason: 'No workspace edit handler is attached' }
         );
+
         this.connection.onRequest(
             'window/showMessageRequest',
             (params) => options.onShowMessage?.(params as Parameters<NonNullable<LspSessionOptions['onShowMessage']>>[0]) ?? null
         );
+
         this.connection.onRequest('window/workDoneProgress/create', () => null);
+
         this.connection.onRequest('client/registerCapability', (params) => {
             const { registrations } = params as { registrations: Registration[] };
+
             for (const registration of registrations) {
                 this.registrations.set(registration.id, registration);
             }
+
             this.emitCapabilities();
+
             return null;
         });
+
         this.connection.onRequest('client/unregisterCapability', (params) => {
             // The misspelled field is part of the LSP 3.17 wire protocol.
             const { unregisterations } = params as { unregisterations: { id: string; method: string }[] };
+
             for (const registration of unregisterations) {
                 this.registrations.delete(registration.id);
             }
+
             this.emitCapabilities();
+
             return null;
         });
+
         for (const method of REFRESH_REQUESTS) {
             this.connection.onRequest(method, () => {
                 this.emitCapabilities();
+
                 return null;
             });
         }
@@ -233,6 +262,7 @@ export class LspSession {
 
     get syncOptions(): TextDocumentSyncOptions {
         const sync = this.serverCapabilities.textDocumentSync;
+
         return typeof sync === 'number' ? { openClose: sync !== 0, change: sync } : (sync ?? {});
     }
 
@@ -240,10 +270,13 @@ export class LspSession {
         if (this.initialized) {
             return this.initialized;
         }
+
         if (this.phase !== 'new') {
             return Promise.reject(new LspError(`Cannot initialize a ${this.phase} session`));
         }
+
         this.phase = 'initializing';
+
         this.initialized = (async () => {
             try {
                 const result = await this.connection.request<InitializeResult>('initialize', {
@@ -254,33 +287,43 @@ export class LspSession {
                     capabilities: clientCapabilities(this.options),
                     initializationOptions: this.options.initializationOptions
                 });
+
                 if (result.capabilities.positionEncoding && result.capabilities.positionEncoding !== 'utf-16') {
                     throw new LspError(`Unsupported server position encoding: ${result.capabilities.positionEncoding}`);
                 }
+
                 this.serverCapabilities = result.capabilities;
                 this.serverInfo = result.serverInfo;
                 await this.connection.notify('initialized', {});
                 this.phase = 'ready';
+
                 if (this.options.configuration !== undefined) {
                     await this.connection.notify('workspace/didChangeConfiguration', { settings: this.configuration });
                 }
+
                 this.emitCapabilities();
+
                 return result;
             } catch (error) {
                 await this.connection.close();
+
                 throw error;
             }
         })();
+
         return this.initialized;
     }
 
     openDocument(item: DocumentItem): LspDocument {
         this.assertReady();
+
         if (this.documents.has(fileUriKey(item.uri))) {
             throw new LspError(`Document already open: ${item.uri}`);
         }
+
         const document = new LspDocument(this, item);
         this.documents.set(fileUriKey(item.uri), document);
+
         return document;
     }
 
@@ -292,17 +335,21 @@ export class LspSession {
     providerOptions(method: string, document?: Pick<DocumentItem, 'uri' | 'languageId'>): ProviderOptions | undefined {
         const name = REGISTRATION_METHODS[method] ?? method;
         const candidates: ProviderOptions[] = [];
+
         for (const registration of this.registrations.values()) {
             if (registration.method === name && matches(registration.registerOptions ?? {}, document)) {
                 candidates.push(registration.registerOptions ?? {});
             }
         }
+
         const provider = this.serverCapabilities[PROVIDERS[method]];
+
         if (provider === true) {
             candidates.push({});
         } else if (provider && typeof provider === 'object' && matches(provider as ProviderOptions, document)) {
             candidates.push(provider as ProviderOptions);
         }
+
         return candidates.find((options) => offersMethod(method, options));
     }
 
@@ -312,11 +359,13 @@ export class LspSession {
 
     request<T = unknown>(method: string, params?: unknown, options?: RequestOptions): Promise<T> {
         this.assertReady();
+
         return this.connection.request<T>(method, params, options);
     }
 
     notify(method: string, params?: unknown): Promise<void> {
         this.assertReady();
+
         return this.connection.notify(method, params);
     }
 
@@ -324,6 +373,7 @@ export class LspSession {
         if (!this.supports('workspace/executeCommand')) {
             return Promise.reject(new LspError('Server does not support commands', ErrorCodes.MethodNotFound));
         }
+
         return this.request('workspace/executeCommand', typeof command === 'string' ? { command, arguments: args } : command, options);
     }
 
@@ -331,6 +381,7 @@ export class LspSession {
         if (!this.supports('workspace/symbol')) {
             return Promise.reject(new LspError('Server does not support workspace symbols', ErrorCodes.MethodNotFound));
         }
+
         return this.request('workspace/symbol', { query }, options);
     }
 
@@ -338,6 +389,7 @@ export class LspSession {
         if (!this.supports('workspaceSymbol/resolve')) {
             return Promise.reject(new LspError('Server does not support workspace symbol resolution', ErrorCodes.MethodNotFound));
         }
+
         return this.request('workspaceSymbol/resolve', symbol, options);
     }
 
@@ -364,6 +416,7 @@ export class LspSession {
 
     onDiagnostics(listener: (params: PublishDiagnosticsParams) => void): Disposable {
         this.diagnosticListeners.add(listener);
+
         return {
             dispose: () => {
                 this.diagnosticListeners.delete(listener);
@@ -387,6 +440,7 @@ export class LspSession {
     fileOperationFilters(operation: FileOperation): FileOperationFilter[] {
         const fileOperations = (this.serverCapabilities.workspace as { fileOperations?: Record<string, ProviderOptions> } | undefined)?.fileOperations;
         const method = `workspace/${operation}Files`;
+
         return [
             ...(fileOperations?.[operation]?.filters ?? []),
             ...[...this.registrations.values()]
@@ -397,49 +451,38 @@ export class LspSession {
 
     /* What the server would change before these files move, or null when it takes none of them or has nothing to say. */
     async willRenameFiles(files: readonly RenamedFile[], options?: RequestOptions): Promise<WorkspaceEdit | null> {
-        const taken = renamesTaken(this.fileOperationFilters('willRename'), files);
-        return taken.length === 0 || this.phase !== 'ready' ? null : this.request<WorkspaceEdit | null>('workspace/willRenameFiles', { files: taken }, options);
+        return this.askBefore('willRename', renamesTaken(this.fileOperationFilters('willRename'), files), options);
     }
 
     /* Tells the server which of these files moved, those its filters take. */
     async didRenameFiles(files: readonly RenamedFile[]): Promise<void> {
-        const taken = renamesTaken(this.fileOperationFilters('didRename'), files);
-        if (taken.length > 0 && this.phase === 'ready') {
-            await this.notify('workspace/didRenameFiles', { files: taken });
-        }
+        await this.tellAfter('didRename', renamesTaken(this.fileOperationFilters('didRename'), files));
     }
 
     /* What the server would change before these files are made, or null when it takes none of them or has nothing to say. */
     async willCreateFiles(files: readonly CreatedFile[], options?: RequestOptions): Promise<WorkspaceEdit | null> {
-        const taken = createsTaken(this.fileOperationFilters('willCreate'), files);
-        return taken.length === 0 || this.phase !== 'ready' ? null : this.request<WorkspaceEdit | null>('workspace/willCreateFiles', { files: taken }, options);
+        return this.askBefore('willCreate', createsTaken(this.fileOperationFilters('willCreate'), files), options);
     }
 
     /* Tells the server which of these files were made, those its filters take. */
     async didCreateFiles(files: readonly CreatedFile[]): Promise<void> {
-        const taken = createsTaken(this.fileOperationFilters('didCreate'), files);
-        if (taken.length > 0 && this.phase === 'ready') {
-            await this.notify('workspace/didCreateFiles', { files: taken });
-        }
+        await this.tellAfter('didCreate', createsTaken(this.fileOperationFilters('didCreate'), files));
     }
 
     /* What the server would change before these files are deleted, or null when it takes none of them or has nothing to say. */
     async willDeleteFiles(files: readonly DeletedFile[], options?: RequestOptions): Promise<WorkspaceEdit | null> {
-        const taken = deletesTaken(this.fileOperationFilters('willDelete'), files);
-        return taken.length === 0 || this.phase !== 'ready' ? null : this.request<WorkspaceEdit | null>('workspace/willDeleteFiles', { files: taken }, options);
+        return this.askBefore('willDelete', deletesTaken(this.fileOperationFilters('willDelete'), files), options);
     }
 
     /* Tells the server which of these files were deleted, those its filters take. */
     async didDeleteFiles(files: readonly DeletedFile[]): Promise<void> {
-        const taken = deletesTaken(this.fileOperationFilters('didDelete'), files);
-        if (taken.length > 0 && this.phase === 'ready') {
-            await this.notify('workspace/didDeleteFiles', { files: taken });
-        }
+        await this.tellAfter('didDelete', deletesTaken(this.fileOperationFilters('didDelete'), files));
     }
 
     /* Registrations and the refresh requests of the server both land here, since each can change what a document may ask. */
     onCapabilitiesChanged(listener: () => void): Disposable {
         this.capabilityListeners.add(listener);
+
         return {
             dispose: () => {
                 this.capabilityListeners.delete(listener);
@@ -449,6 +492,7 @@ export class LspSession {
 
     shutdown(): Promise<void> {
         this.shutdownPromise ??= this.stop();
+
         return this.shutdownPromise;
     }
 
@@ -457,6 +501,7 @@ export class LspSession {
         if (this.documents.get(fileUriKey(document.uri)) !== document) {
             return;
         }
+
         this.documents.delete(fileUriKey(document.uri));
         this.emitDiagnostics({ uri: document.uri, diagnostics: [] });
     }
@@ -467,11 +512,26 @@ export class LspSession {
         }
     }
 
+    private async askBefore(
+        operation: 'willRename' | 'willCreate' | 'willDelete',
+        files: readonly object[],
+        options?: RequestOptions
+    ): Promise<WorkspaceEdit | null> {
+        return files.length === 0 || this.phase !== 'ready' ? null : this.request<WorkspaceEdit | null>(`workspace/${operation}Files`, { files }, options);
+    }
+
+    private async tellAfter(operation: 'didRename' | 'didCreate' | 'didDelete', files: readonly object[]): Promise<void> {
+        if (files.length > 0 && this.phase === 'ready') {
+            await this.notify(`workspace/${operation}Files`, { files });
+        }
+    }
+
     private async stop(): Promise<void> {
         try {
             if (this.phase === 'initializing') {
                 await this.initialized;
             }
+
             if (this.phase === 'ready') {
                 this.phase = 'closing';
                 await Promise.all([...this.documents.values()].map((document) => document.close()));
@@ -488,16 +548,21 @@ export class LspSession {
         if (!section) {
             return this.configuration;
         }
+
         if (Object.hasOwn(this.configuration, section)) {
             return this.configuration[section];
         }
+
         let result: unknown = this.configuration;
+
         for (const key of section.split('.')) {
             if (!result || typeof result !== 'object' || !Object.hasOwn(result, key)) {
                 return null;
             }
+
             result = (result as Record<string, unknown>)[key];
         }
+
         return result ?? null;
     }
 
@@ -524,6 +589,7 @@ export class LspSession {
 function clientCapabilities(options: LspSessionOptions): object {
     const dynamic = { dynamicRegistration: true };
     const symbolKind = { valueSet: Array.from({ length: 26 }, (_, index) => index + 1) };
+
     return {
         general: { positionEncodings: ['utf-16'] },
         workspace: {

package/src/test-transport.ts

@@ -10,9 +10,11 @@ export class ScriptedTransport implements LspTransport {
 
     send(message: RpcMessage): void {
         this.sent.push(message);
+
         if ('method' in message && message.method === 'initialize' && 'id' in message && this.autoInitialize) {
             queueMicrotask(() => this.emit({ jsonrpc: '2.0', id: message.id, result: { capabilities: this.autoInitialize } }));
         }
+
         if ('method' in message && message.method === 'shutdown' && 'id' in message) {
             queueMicrotask(() => this.emit({ jsonrpc: '2.0', id: message.id, result: null }));
         }
@@ -20,6 +22,7 @@ export class ScriptedTransport implements LspTransport {
 
     onMessage(listener: (message: unknown) => void) {
         this.messages.add(listener);
+
         return {
             dispose: () => {
                 this.messages.delete(listener);
@@ -29,6 +32,7 @@ export class ScriptedTransport implements LspTransport {
 
     onClose(listener: (error?: Error) => void) {
         this.closes.add(listener);
+
         return {
             dispose: () => {
                 this.closes.delete(listener);
@@ -50,7 +54,7 @@ export class ScriptedTransport implements LspTransport {
 
     /* The last request of `method` the client sent. */
     request(method: string) {
-        return [...this.sent].reverse().find((message) => 'method' in message && message.method === method && 'id' in message) as {
+        return this.sent.findLast((message) => 'method' in message && message.method === method && 'id' in message) as {
             id: number;
             params: unknown;
         };
@@ -78,6 +82,7 @@ export async function sessionWith(capabilities: ServerCapabilities = {}, options
     transport.autoInitialize = { textDocumentSync: 2, ...capabilities };
     const session = new LspSession(transport, options);
     await session.initialize();
+
     return { transport, session };
 }
 

package/src/testing.ts

@@ -39,39 +39,50 @@ export class FakeLanguageServer {
 
     constructor(transport: LspTransport, options: FakeLanguageServerOptions = {}) {
         this.connection = new JsonRpcConnection(transport, 0);
+
         transport.onMessage((message) => {
             const { method, params, id } = message as ReceivedMessage;
+
             if (typeof method === 'string') {
                 this.received.push({ method, params, id });
             }
         });
+
         this.connection.onRequest('initialize', () =>
             options.silent
                 ? new Promise<never>(() => undefined)
                 : { capabilities: options.capabilities ?? { textDocumentSync: 2 }, serverInfo: options.serverInfo }
         );
+
         this.connection.onRequest('shutdown', () => {
             this.shutdownRequested = true;
+
             return null;
         });
+
         this.connection.onNotification('exit', () => {
             this.exited = true;
         });
+
         this.connection.onNotification('textDocument/didOpen', (params) => {
             const { textDocument } = params as { textDocument: { uri: string; languageId: string; text: string; version: number } };
             this.documents.set(textDocument.uri, { languageId: textDocument.languageId, text: textDocument.text, version: textDocument.version });
         });
+
         this.connection.onNotification('textDocument/didChange', (params) => {
             const { textDocument, contentChanges } = params as { textDocument: { uri: string; version: number }; contentChanges: ContentChange[] };
             const document = this.documents.get(textDocument.uri);
+
             if (document) {
                 document.text = applyContentChanges(document.text, contentChanges);
                 document.version = textDocument.version;
             }
         });
+
         this.connection.onNotification('textDocument/didClose', (params) => {
             this.documents.delete((params as { textDocument: { uri: string } }).textDocument.uri);
         });
+
         for (const [method, handler] of Object.entries(options.handlers ?? {})) {
             this.connection.onRequest(method, handler);
         }

package/src/text-mirror.ts

@@ -1,9 +1,7 @@
 import { LspError } from './connection.ts';
+import { CR, LF, checkPosition } from './edits.ts';
 import type { ContentChange, Position } from './protocol.ts';
 
-const CR = 13;
-const LF = 10;
-
 /* Past this many lines a spread into `splice` could exceed the engine's argument limit. */
 const SPREAD_LIMIT = 10_000;
 
@@ -11,25 +9,32 @@ const SPREAD_LIMIT = 10_000;
 function splitLines(text: string): string[] {
     const lines: string[] = [];
     let start = 0;
+
     for (let i = 0; i < text.length; i++) {
         const code = text.charCodeAt(i);
+
         if (code === CR || code === LF) {
             if (code === CR && text.charCodeAt(i + 1) === LF) {
                 i++;
             }
+
             lines.push(text.slice(start, i + 1));
             start = i + 1;
         }
     }
+
     lines.push(text.slice(start));
+
     return lines;
 }
 
 function breakLength(line: string): number {
     const last = line.charCodeAt(line.length - 1);
+
     if (last === LF) {
         return line.charCodeAt(line.length - 2) === CR ? 2 : 1;
     }
+
     return last === CR ? 1 : 0;
 }
 
@@ -54,6 +59,7 @@ export class TextMirror {
 
     get text(): string {
         this.joined ??= this.lines.join('');
+
         return this.joined;
     }
 
@@ -64,6 +70,7 @@ export class TextMirror {
     /* Applies the entries in order, each in the text the one before it left. When one does not fit, it throws and the text stays as it was. */
     applyChanges(changes: readonly ContentChange[]): void {
         const applied: Splice[] = [];
+
         try {
             for (const change of changes) {
                 applied.push(
@@ -71,13 +78,16 @@ export class TextMirror {
                         ? this.applyRange(change.range.start, change.range.end, change.text)
                         : this.replace(0, this.lines.length, splitLines(change.text))
                 );
+
                 this.joined = change.range ? null : change.text;
             }
         } catch (error) {
             for (const splice of applied.reverse()) {
                 this.replace(splice.start, splice.inserted, splice.removed);
             }
+
             this.joined = null;
+
             throw error;
         }
     }
@@ -85,53 +95,64 @@ export class TextMirror {
     private applyRange(start: Position, end: Position, text: string): Splice {
         const startLine = this.lineAt(start);
         const endLine = this.lineAt(end);
+
         if (end.line < start.line || (end.line === start.line && end.character < start.character)) {
             throw new LspError('Change range is reversed');
         }
+
         const inserted = splitLines(text);
         const last = inserted.length - 1;
         let suffix = endLine.slice(end.character);
+
         // An inserted `\r` and the `\n` after the range become one break.
         if (text.charCodeAt(text.length - 1) === CR && suffix.charCodeAt(0) === LF) {
             inserted[last - 1] += '\n';
             suffix = suffix.slice(1);
         }
+
         inserted[last] += suffix;
         inserted[0] = startLine.slice(0, start.character) + inserted[0];
+
         if (inserted[last] === '' && end.line < this.lines.length - 1) {
             inserted.pop();
         }
+
         let first = start.line;
+
         // A line that ends in a lone `\r` takes a `\n` that now follows it as the rest of its break.
         if (inserted[0] === '\n' && first > 0 && this.lines[first - 1].charCodeAt(this.lines[first - 1].length - 1) === CR) {
             first--;
             inserted[0] = this.lines[first] + '\n';
         }
+
         return this.replace(first, end.line - first + 1, inserted);
     }
 
     private lineAt(position: Position): string {
-        if (!Number.isInteger(position.line) || !Number.isInteger(position.character) || position.line < 0 || position.character < 0) {
-            throw new LspError('Invalid edit position');
-        }
+        checkPosition(position);
         const line = this.lines[position.line];
+
         if (line === undefined) {
             throw new LspError('Edit line is outside the document');
         }
+
         if (position.character > line.length - breakLength(line)) {
             throw new LspError('Edit character is outside the line');
         }
+
         return line;
     }
 
     private replace(start: number, count: number, lines: string[]): Splice {
         let removed: string[];
+
         if (lines.length <= SPREAD_LIMIT) {
             removed = this.lines.splice(start, count, ...lines);
         } else {
             removed = this.lines.slice(start, start + count);
             this.lines = [...this.lines.slice(0, start), ...lines, ...this.lines.slice(start + count)];
         }
+
         return { start, removed, inserted: lines.length };
     }
 }