pickup notifications that were being missed

Author: cowboyd

lib/capabilities.ts

@@ -1,4 +1,8 @@
-export const notification2capability = {
+export const method2capability = {
+  // notifications
+  "initialized": "*",
+  "workspace/didChangeConfiguration": "*",
+
   "textDocument/didOpen": "textDocumentSync",
   "textDocument/didChange": "textDocumentSync",
   "textDocument/willSave": "textDocumentSync.willSave",
@@ -11,14 +15,11 @@ export const notification2capability = {
   "workspace/willDeleteFiles": "workspace.fileOperations.willDelete",
   "workspace/didDeleteFiles": "workspace.fileOperations.didDelete",
 
-  "workspace/didChangeConfiguration": "*",
-
   "workspace/didChangeWorkspaceFolders":
     "workspace.workspaceFolders.changeNotifications",
   "workspace/willCreateFiles": "workspace.fileOperations.willCreate",
-} as const;
 
-export const request2capability = {
+  // requsets
   "textDocument/willSaveWaitUntil": "textDocumentSync.willSaveWaitUntil",
   "textDocument/declaration": "declarationProvider",
   "textDocument/definition": "definitionProvider",

lib/dispatch.ts

@@ -2,7 +2,7 @@ import { all, type Operation } from "effection";
 import type { LSPAgent, NotificationParams, RequestParams } from "./types.ts";
 import deepmerge from "deepmerge";
 import { get, optic } from "optics-ts";
-import { request2capability } from "./capabilities.ts";
+import { method2capability } from "./capabilities.ts";
 import { responseError } from "./json-rpc-connection.ts";
 import {
   type CompletionParams,
@@ -37,9 +37,7 @@ export function* request(options: RequestOptions): Operation<unknown> {
     handler.agents.map((agent) => agent.request(params)),
   );
 
-  let merge = handler.merge ??
-    ((responses) =>
-      responses.reduce((sum, response) => deepmerge(sum, response)));
+  let merge = handler.merge ?? defaultMerge;
 
   return merge(responses);
 }
@@ -63,7 +61,7 @@ export function* notification(options: NotificationOptions): Operation<void> {
 }
 
 export function match(agents: LSPAgent[], params: RequestParams): Match {
-  let method = params[0] as keyof typeof request2capability;
+  let method = params[0] as keyof typeof method2capability;
   switch (method) {
     case "textDocument/completion":
       return completion({ agents, params });
@@ -110,10 +108,27 @@ interface Match {
  */
 function defaultMatch(canddidates: LSPAgent[], method: string): Match {
   let capabilityPath =
-    request2capability[method as keyof typeof request2capability];
+    method2capability[method as keyof typeof method2capability];
+  if (capabilityPath === "*") {
+    return { agents: canddidates };
+  }
+  if (!capabilityPath) {
+    console.error(`nothing matches ${method}`);
+    return { agents: canddidates };
+  }
   let path = optic().path(capabilityPath);
   let agents = canddidates.filter((agent) => {
     return !!get(path)(agent.capabilities);
   });
   return { agents };
 }
+
+function defaultMerge(responses: unknown[]): unknown {
+  return responses.reduce((sum, response) => {
+    if (response === null) {
+      return sum;
+    } else {
+      return deepmerge(sum as Partial<unknown>, response as Partial<unknown>);
+    }
+  });
+}

test/lspx.test.ts

@@ -117,6 +117,28 @@ describe("lspx", function () {
     });
   });
 
+  describe("hover", () => {
+    beforeEach(function* () {
+      yield* initServer({
+        commands: [
+          "deno -A test/sim/hover.ts",
+          "deno -A test/sim/hover.ts",
+        ],
+      });
+      yield* initialize({ textDocument: { hover: {} } });
+    });
+
+    it("can handle a null response from all the servers", function* () {
+      let result = yield* request("textDocument/hover", {
+        textDocument: {
+          uri: "file:///Users/cowboyd/Code/@cowboyd/lsps/test/lspx.test.ts",
+        },
+        position: { line: 126, character: 12 },
+      });
+      expect(result).toEqual({ ok: true, value: null });
+    });
+  });
+
   describe("client/registerCapability", () => {
     it("forwards dynamic registrations requests to the client");
     it("forwards dynamic unregistrations requests to the client");

test/sim/hover.ts

@@ -0,0 +1,54 @@
+import type { Operation } from "effection";
+import { each, main } from "effection";
+import { responseError, useConnection } from "../../lib/json-rpc-connection.ts";
+import type {
+  InitializeParams,
+  InitializeResult,
+} from "vscode-languageserver-protocol";
+import { ErrorCodes } from "vscode-jsonrpc";
+import { parser } from "zod-opts";
+
+await main(function* (args) {
+  parser()
+    .name("hover simulator")
+    .parse(args);
+
+  let client = yield* useConnection({
+    read: Deno.stdin.readable,
+    write: Deno.stdout.writable,
+  });
+
+  // deno-lint-ignore no-explicit-any
+  const routes: Record<string, (...params: any[]) => Operation<any>> = {
+    *initialize(_params: InitializeParams): Operation<InitializeResult> {
+      return {
+        capabilities: {
+          hoverProvider: true,
+        },
+        serverInfo: {
+          name: "lspx hover simulator",
+          version: "1.0",
+        },
+      };
+    },
+    *["textDocument/hover"](): Operation<null> {
+      return null;
+    },
+  };
+
+  for (let respondWith of yield* each(client.requests)) {
+    yield* respondWith(function* (params) {
+      let [method] = params;
+      let operation = routes[method];
+      if (operation) {
+        return yield* operation(...[params].flat());
+      } else {
+        return yield* responseError(
+          ErrorCodes.InvalidRequest,
+          `method not handled`,
+        );
+      }
+    });
+    yield* each.next();
+  }
+});