saeeol 1.2.9 → 1.3.1

package/test/lib/websocket.ts

@@ -0,0 +1,46 @@
+export class FakeWebSocket {
+  static CONNECTING = 0
+  static OPEN = 1
+  static CLOSING = 2
+  static CLOSED = 3
+
+  readyState = FakeWebSocket.CONNECTING
+  closed = false
+  sent: string[] = []
+  listeners = new Map<string, Set<(event: { data?: unknown }) => void>>()
+
+  constructor(
+    readonly url: string,
+    readonly options?: { headers?: Record<string, string> },
+  ) {}
+
+  addEventListener(type: string, listener: (event: { data?: unknown }) => void) {
+    const current = this.listeners.get(type) ?? new Set<(event: { data?: unknown }) => void>()
+    current.add(listener)
+    this.listeners.set(type, current)
+  }
+
+  send(data: string) {
+    this.sent.push(data)
+  }
+
+  close() {
+    if (this.readyState === FakeWebSocket.CLOSED) return
+    this.closed = true
+    this.readyState = FakeWebSocket.CLOSED
+    this.emit("close", {})
+  }
+
+  open() {
+    this.readyState = FakeWebSocket.OPEN
+    this.emit("open", {})
+  }
+
+  message(data: unknown) {
+    this.emit("message", { data })
+  }
+
+  emit(type: string, event: { data?: unknown }) {
+    this.listeners.get(type)?.forEach((listener) => listener(event))
+  }
+}

package/test/lsp/client.test.ts

@@ -0,0 +1,482 @@
+import { beforeEach, describe, expect, test } from "bun:test"
+import path from "path"
+import { pathToFileURL } from "url"
+import { tmpdir } from "../fixture/fixture"
+import { LSPClient } from "@/lsp/client"
+import * as LSPServer from "@/lsp/server"
+import { Instance } from "../../src/project/instance"
+import * as Log from "@saeeol/core/util/log"
+
+function spawnFakeServer() {
+  const { spawn } = require("child_process")
+  const serverPath = path.join(__dirname, "../fixture/lsp/fake-lsp-server.js")
+  return {
+    process: spawn(process.execPath, [serverPath], {
+      stdio: "pipe",
+    }),
+  }
+}
+
+describe("LSPClient interop", () => {
+  beforeEach(async () => {
+    await Log.init({ print: true })
+  })
+
+  test("handles workspace/workspaceFolders request", async () => {
+    const handle = spawnFakeServer() as any
+
+    const client = await Instance.provide({
+      directory: process.cwd(),
+      fn: () =>
+        LSPClient.create({
+          serverID: "fake",
+          server: handle as unknown as LSPServer.Handle,
+          root: process.cwd(),
+          directory: process.cwd(),
+        }),
+    })
+
+    await client.connection.sendNotification("test/trigger", {
+      method: "workspace/workspaceFolders",
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 100))
+    expect(client.connection).toBeDefined()
+    await client.shutdown()
+  })
+
+  test("handles client/registerCapability request", async () => {
+    const handle = spawnFakeServer() as any
+
+    const client = await Instance.provide({
+      directory: process.cwd(),
+      fn: () =>
+        LSPClient.create({
+          serverID: "fake",
+          server: handle as unknown as LSPServer.Handle,
+          root: process.cwd(),
+          directory: process.cwd(),
+        }),
+    })
+
+    await client.connection.sendNotification("test/trigger", {
+      method: "client/registerCapability",
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 100))
+    expect(client.connection).toBeDefined()
+    await client.shutdown()
+  })
+
+  test("handles client/unregisterCapability request", async () => {
+    const handle = spawnFakeServer() as any
+
+    const client = await Instance.provide({
+      directory: process.cwd(),
+      fn: () =>
+        LSPClient.create({
+          serverID: "fake",
+          server: handle as unknown as LSPServer.Handle,
+          root: process.cwd(),
+          directory: process.cwd(),
+        }),
+    })
+
+    await client.connection.sendNotification("test/trigger", {
+      method: "client/unregisterCapability",
+    })
+
+    await new Promise((resolve) => setTimeout(resolve, 100))
+    expect(client.connection).toBeDefined()
+    await client.shutdown()
+  })
+
+  test("initialize does not overclaim unsupported diagnostics capabilities", async () => {
+    const handle = spawnFakeServer() as any
+
+    const client = await Instance.provide({
+      directory: process.cwd(),
+      fn: () =>
+        LSPClient.create({
+          serverID: "fake",
+          server: handle as unknown as LSPServer.Handle,
+          root: process.cwd(),
+          directory: process.cwd(),
+        }),
+    })
+
+    const params = await client.connection.sendRequest<any>("test/get-initialize-params", {})
+    expect(params.capabilities.workspace.diagnostics.refreshSupport).toBe(false)
+    expect(params.capabilities.textDocument.publishDiagnostics.versionSupport).toBe(false)
+
+    await client.shutdown()
+  })
+
+  test("workspace/configuration returns one result per requested item", async () => {
+    const handle = spawnFakeServer() as any
+    const initialization = {
+      alpha: {
+        beta: 1,
+      },
+      gamma: true,
+    }
+
+    const client = await Instance.provide({
+      directory: process.cwd(),
+      fn: () =>
+        LSPClient.create({
+          serverID: "fake",
+          server: {
+            ...(handle as unknown as LSPServer.Handle),
+            initialization,
+          },
+          root: process.cwd(),
+          directory: process.cwd(),
+        }),
+    })
+
+    const response = await client.connection.sendRequest<any[]>("test/request-configuration", {
+      items: [{ section: "alpha" }, { section: "alpha.beta" }, { section: "missing" }, {}],
+    })
+
+    expect(response).toEqual([{ beta: 1 }, 1, null, initialization])
+
+    await client.shutdown()
+  })
+
+  test("sends ranged didChange for incremental sync servers", async () => {
+    const handle = spawnFakeServer() as any
+    await using tmp = await tmpdir()
+    const file = path.join(tmp.path, "client.ts")
+    await Bun.write(file, "first\n")
+
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const client = await LSPClient.create({
+          serverID: "fake",
+          server: handle as unknown as LSPServer.Handle,
+          root: tmp.path,
+          directory: tmp.path,
+        })
+
+        await client.notify.open({ path: file })
+        await Bun.write(file, "second\nthird\n")
+        await client.notify.open({ path: file })
+
+        const change = await client.connection.sendRequest<{
+          textDocument: { version: number }
+          contentChanges: {
+            range?: { start: { line: number; character: number }; end: { line: number; character: number } }
+            text: string
+          }[]
+        }>("test/get-last-change", {})
+        expect(change.textDocument.version).toBe(1)
+        expect(change.contentChanges).toEqual([
+          {
+            range: {
+              start: { line: 0, character: 0 },
+              end: { line: 1, character: 0 },
+            },
+            text: "second\nthird\n",
+          },
+        ])
+
+        await client.shutdown()
+      },
+    })
+  })
+
+  test("document mode falls back to push diagnostics", async () => {
+    const handle = spawnFakeServer() as any
+    await using tmp = await tmpdir()
+    const file = path.join(tmp.path, "client.ts")
+    await Bun.write(file, "const x = 1\n")
+
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const client = await LSPClient.create({
+          serverID: "fake",
+          server: handle as unknown as LSPServer.Handle,
+          root: tmp.path,
+          directory: tmp.path,
+        })
+
+        const version = await client.notify.open({ path: file })
+        const wait = client.waitForDiagnostics({ path: file, version, mode: "document" })
+        await client.connection.sendNotification("test/publish-diagnostics", {
+          uri: pathToFileURL(file).href,
+          version,
+          diagnostics: [
+            {
+              range: {
+                start: { line: 0, character: 0 },
+                end: { line: 0, character: 5 },
+              },
+              message: "push diagnostic",
+              severity: 1,
+            },
+          ],
+        })
+        await wait
+
+        const diagnostics = client.diagnostics.get(file) ?? []
+        expect(diagnostics).toHaveLength(1)
+        expect(diagnostics[0]?.message).toBe("push diagnostic")
+
+        const count = await client.connection.sendRequest("test/get-diagnostic-request-count", {})
+        expect(count).toBe(0)
+
+        await client.shutdown()
+      },
+    })
+  })
+
+  test("document mode accepts matching push diagnostics published before waiting", async () => {
+    const handle = spawnFakeServer() as any
+    await using tmp = await tmpdir()
+    const file = path.join(tmp.path, "client.ts")
+    await Bun.write(file, "const x = 1\n")
+
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const client = await LSPClient.create({
+          serverID: "fake",
+          server: handle as unknown as LSPServer.Handle,
+          root: tmp.path,
+          directory: tmp.path,
+        })
+
+        const version = await client.notify.open({ path: file })
+        await client.connection.sendNotification("test/publish-diagnostics", {
+          uri: pathToFileURL(file).href,
+          version,
+          diagnostics: [
+            {
+              range: {
+                start: { line: 0, character: 0 },
+                end: { line: 0, character: 5 },
+              },
+              message: "push diagnostic",
+              severity: 1,
+            },
+          ],
+        })
+
+        for (let i = 0; i < 20 && (client.diagnostics.get(file)?.length ?? 0) === 0; i++) {
+          await new Promise((resolve) => setTimeout(resolve, 25))
+        }
+
+        expect(client.diagnostics.get(file)?.[0]?.message).toBe("push diagnostic")
+
+        const started = Date.now()
+        await client.waitForDiagnostics({ path: file, version, mode: "document" })
+        expect(Date.now() - started).toBeLessThan(1_000)
+
+        await client.shutdown()
+      },
+    })
+  })
+
+  test("document mode waits for pull diagnostics", async () => {
+    const handle = spawnFakeServer() as any
+    await using tmp = await tmpdir()
+    const file = path.join(tmp.path, "client.cs")
+    await Bun.write(file, "class C {}\n")
+
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const client = await LSPClient.create({
+          serverID: "fake",
+          server: handle as unknown as LSPServer.Handle,
+          root: tmp.path,
+          directory: tmp.path,
+        })
+
+        await client.connection.sendRequest("test/configure-pull-diagnostics", {
+          registerOn: "didOpen",
+          registrations: [{ identifier: "DocumentCompilerSemantic" }],
+          documentDiagnosticsByIdentifier: {
+            DocumentCompilerSemantic: [
+              {
+                range: {
+                  start: { line: 0, character: 0 },
+                  end: { line: 0, character: 5 },
+                },
+                message: "pull diagnostic",
+                severity: 1,
+              },
+            ],
+          },
+        })
+
+        const version = await client.notify.open({ path: file })
+        await client.waitForDiagnostics({ path: file, version, mode: "document" })
+
+        const diagnostics = client.diagnostics.get(file) ?? []
+        expect(diagnostics).toHaveLength(1)
+        expect(diagnostics[0]?.message).toBe("pull diagnostic")
+
+        const count = await client.connection.sendRequest("test/get-diagnostic-request-count", {})
+        expect(count).toBeGreaterThan(0)
+
+        await client.shutdown()
+      },
+    })
+  })
+
+  test("document mode does not wait for the slowest pull identifier after current-file diagnostics arrive", async () => {
+    const handle = spawnFakeServer() as any
+    await using tmp = await tmpdir()
+    const file = path.join(tmp.path, "client.cs")
+    await Bun.write(file, "class C {}\n")
+
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const client = await LSPClient.create({
+          serverID: "fake",
+          server: handle as unknown as LSPServer.Handle,
+          root: tmp.path,
+          directory: tmp.path,
+        })
+
+        await client.connection.sendRequest("test/configure-pull-diagnostics", {
+          registrations: [{ identifier: "fast" }, { identifier: "slow" }],
+          documentDiagnosticsByIdentifier: {
+            fast: [
+              {
+                range: {
+                  start: { line: 0, character: 0 },
+                  end: { line: 0, character: 5 },
+                },
+                message: "fast diagnostic",
+                severity: 1,
+              },
+            ],
+            slow: [],
+          },
+          documentDelayMsByIdentifier: {
+            slow: 2_500,
+          },
+        })
+
+        const version = await client.notify.open({ path: file })
+        await client.connection.sendRequest("test/register-configured-pull-diagnostics", {})
+        await new Promise((resolve) => setTimeout(resolve, 100))
+        const started = Date.now()
+        await client.waitForDiagnostics({ path: file, version, mode: "document" })
+
+        expect(Date.now() - started).toBeLessThan(1_000)
+        expect(client.diagnostics.get(file)?.[0]?.message).toBe("fast diagnostic")
+        expect(await client.connection.sendRequest("test/get-diagnostic-request-count", {})).toBeGreaterThan(1)
+
+        await client.shutdown()
+      },
+    })
+  })
+
+  test("full mode includes workspace pull diagnostics", async () => {
+    const handle = spawnFakeServer() as any
+    await using tmp = await tmpdir()
+    const file = path.join(tmp.path, "client.cs")
+    const related = path.join(tmp.path, "other.cs")
+    await Bun.write(file, "class C {}\n")
+    await Bun.write(related, "class D {}\n")
+
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const client = await LSPClient.create({
+          serverID: "fake",
+          server: handle as unknown as LSPServer.Handle,
+          root: tmp.path,
+          directory: tmp.path,
+        })
+
+        await client.connection.sendRequest("test/configure-pull-diagnostics", {
+          registerOn: "didOpen",
+          registrations: [
+            { identifier: "DocumentCompilerSemantic" },
+            { identifier: "WorkspaceDocumentsAndProject", workspaceDiagnostics: true },
+          ],
+          documentDiagnosticsByIdentifier: {
+            DocumentCompilerSemantic: [
+              {
+                range: {
+                  start: { line: 0, character: 0 },
+                  end: { line: 0, character: 5 },
+                },
+                message: "current file",
+                severity: 1,
+              },
+            ],
+          },
+          workspaceDiagnosticsByIdentifier: {
+            WorkspaceDocumentsAndProject: [
+              {
+                uri: pathToFileURL(related).href,
+                items: [
+                  {
+                    range: {
+                      start: { line: 0, character: 0 },
+                      end: { line: 0, character: 5 },
+                    },
+                    message: "workspace file",
+                    severity: 1,
+                  },
+                ],
+              },
+            ],
+          },
+        })
+
+        const version = await client.notify.open({ path: file })
+        await client.waitForDiagnostics({ path: file, version, mode: "full" })
+
+        expect(client.diagnostics.get(file)?.[0]?.message).toBe("current file")
+        expect(client.diagnostics.get(related)?.[0]?.message).toBe("workspace file")
+
+        await client.shutdown()
+      },
+    })
+  })
+
+  test("full mode treats an empty workspace pull response as handled", async () => {
+    const handle = spawnFakeServer() as any
+    await using tmp = await tmpdir()
+    const file = path.join(tmp.path, "client.cs")
+    await Bun.write(file, "class C {}\n")
+
+    await Instance.provide({
+      directory: tmp.path,
+      fn: async () => {
+        const client = await LSPClient.create({
+          serverID: "fake",
+          server: handle as unknown as LSPServer.Handle,
+          root: tmp.path,
+          directory: tmp.path,
+        })
+
+        await client.connection.sendRequest("test/configure-pull-diagnostics", {
+          registerOn: "didOpen",
+          registrations: [{ identifier: "WorkspaceDocumentsAndProject", workspaceDiagnostics: true }],
+          workspaceDiagnosticsByIdentifier: {
+            WorkspaceDocumentsAndProject: [],
+          },
+        })
+
+        const version = await client.notify.open({ path: file })
+        const started = Date.now()
+        await client.waitForDiagnostics({ path: file, version, mode: "full" })
+
+        expect(Date.now() - started).toBeLessThan(1_000)
+
+        await client.shutdown()
+      },
+    })
+  })
+})

package/test/lsp/index.test.ts

@@ -0,0 +1,160 @@
+import { describe, expect, spyOn, test } from "bun:test"
+import path from "path"
+import fs from "fs/promises"
+import { Effect, Layer } from "effect"
+import { LSP } from "@/lsp/lsp"
+import * as LSPServer from "@/lsp/server"
+import * as launch from "../../src/lsp/launch" 
+import { CrossSpawnSpawner } from "@saeeol/core/cross-spawn-spawner"
+import { provideTmpdirInstance, tmpdir } from "../fixture/fixture"
+import { testEffect } from "../lib/effect"
+import { Instance, type InstanceContext } from "../../src/project/instance"
+import { Flag } from "@saeeol/core/flag/flag" 
+import { TsCheck } from "../../src/overlay/ts-check" 
+const fakeCtx = {} as InstanceContext
+
+const it = testEffect(Layer.mergeAll(LSP.defaultLayer, CrossSpawnSpawner.defaultLayer))
+
+describe("lsp.spawn", () => {
+  it.live("does not spawn builtin LSP for files outside instance", () =>
+    provideTmpdirInstance(
+      (dir) =>
+        LSP.Service.use((lsp) =>
+          Effect.gen(function* () {
+            const spy = spyOn(LSPServer.Typescript, "spawn").mockResolvedValue(undefined)
+
+            try {
+              yield* lsp.touchFile(path.join(dir, "..", "outside.ts"))
+              yield* lsp.hover({
+                file: path.join(dir, "..", "hover.ts"),
+                line: 0,
+                character: 0,
+              })
+              expect(spy).toHaveBeenCalledTimes(0)
+            } finally {
+              spy.mockRestore()
+            }
+          }),
+        ),
+      { config: { lsp: true } },
+    ),
+  )
+
+  it.live("does not spawn builtin LSP for files inside instance when LSP is unset", () =>
+    provideTmpdirInstance((dir) =>
+      LSP.Service.use((lsp) =>
+        Effect.gen(function* () {
+          const spy = spyOn(LSPServer.Typescript, "spawn").mockResolvedValue(undefined)
+
+          try {
+            yield* lsp.hover({
+              file: path.join(dir, "src", "inside.ts"),
+              line: 0,
+              character: 0,
+            })
+            expect(spy).toHaveBeenCalledTimes(0)
+          } finally {
+            spy.mockRestore()
+          }
+        }),
+      ),
+    ),
+  )
+  it.live("would spawn builtin LSP for files inside instance when lsp is true", () =>
+    provideTmpdirInstance(
+      (dir) =>
+        LSP.Service.use((lsp) =>
+          Effect.gen(function* () {
+            const saved = Flag.SAEEOL_EXPERIMENTAL_LSP_TOOL
+            Flag.SAEEOL_EXPERIMENTAL_LSP_TOOL = true
+            const spy = spyOn(LSPServer.Typescript, "spawn").mockResolvedValue(undefined)
+
+            try {
+              yield* lsp.hover({
+                file: path.join(dir, "src", "inside.ts"),
+                line: 0,
+                character: 0,
+              })
+              expect(spy).toHaveBeenCalledTimes(1)
+            } finally {
+              Flag.SAEEOL_EXPERIMENTAL_LSP_TOOL = saved
+              spy.mockRestore()
+            }
+          }),
+        ),
+      { config: { lsp: true } },
+    ),
+  )
+
+  it.live("would spawn builtin LSP for files inside instance when config object is provided", () =>
+    provideTmpdirInstance(
+      (dir) =>
+        LSP.Service.use((lsp) =>
+          Effect.gen(function* () {
+            const saved = Flag.SAEEOL_EXPERIMENTAL_LSP_TOOL
+            Flag.SAEEOL_EXPERIMENTAL_LSP_TOOL = true
+            const spy = spyOn(LSPServer.Typescript, "spawn").mockResolvedValue(undefined)
+
+            try {
+              yield* lsp.hover({
+                file: path.join(dir, "src", "inside.ts"),
+                line: 0,
+                character: 0,
+              })
+              expect(spy).toHaveBeenCalledTimes(1)
+            } finally {
+              Flag.SAEEOL_EXPERIMENTAL_LSP_TOOL = saved
+              spy.mockRestore()
+            }
+          }),
+        ),
+      {
+        config: {
+          lsp: {
+            eslint: { disabled: true },
+          },
+        },
+      },
+    ),
+  )
+  test("spawns tsgo LSP when SAEEOL_EXPERIMENTAL_LSP_TOOL is enabled", async () => {
+    const saved = Flag.SAEEOL_EXPERIMENTAL_LSP_TOOL
+    Flag.SAEEOL_EXPERIMENTAL_LSP_TOOL = true
+    await using tmp = await tmpdir()
+
+    const spawnSpy = spyOn(launch, "spawn").mockImplementation(
+      () => ({ stdin: {}, stdout: {}, stderr: {}, on: () => {}, kill: () => {} }) as any,
+    )
+    const tsgoSpy = spyOn(TsCheck, "native_tsgo").mockResolvedValue("/fake/tsgo")
+
+    try {
+      await Instance.provide({
+        directory: tmp.path,
+        fn: async () => {
+          const result = await LSPServer.Typescript.spawn(tmp.path, fakeCtx)
+          expect(result).toBeDefined()
+          expect(tsgoSpy).toHaveBeenCalledWith(tmp.path)
+          expect(spawnSpy).toHaveBeenCalled()
+          const args = spawnSpy.mock.calls[0][1] as string[]
+          expect(args).toContain("--lsp")
+          expect(args).toContain("--stdio")
+        },
+      })
+    } finally {
+      Flag.SAEEOL_EXPERIMENTAL_LSP_TOOL = saved
+      spawnSpy.mockRestore()
+      tsgoSpy.mockRestore()
+    }
+  })
+
+  test("Typescript.spawn returns undefined when SAEEOL_EXPERIMENTAL_LSP_TOOL is off", async () => {
+    const saved = Flag.SAEEOL_EXPERIMENTAL_LSP_TOOL
+    Flag.SAEEOL_EXPERIMENTAL_LSP_TOOL = false
+    try {
+      const result = await LSPServer.Typescript.spawn("/tmp/any", fakeCtx)
+      expect(result).toBeUndefined()
+    } finally {
+      Flag.SAEEOL_EXPERIMENTAL_LSP_TOOL = saved
+    }
+  })
+})

package/test/lsp/launch.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, test } from "bun:test"
+import fs from "fs/promises"
+import path from "path"
+import { spawn } from "../../src/lsp/launch"
+import { tmpdir } from "../fixture/fixture"
+
+describe("lsp.launch", () => {
+  test("spawns cmd scripts with spaces on Windows", async () => {
+    if (process.platform !== "win32") return
+
+    await using tmp = await tmpdir()
+    const dir = path.join(tmp.path, "with space")
+    const file = path.join(dir, "echo cmd.cmd")
+
+    await fs.mkdir(dir, { recursive: true })
+    await Bun.write(file, "@echo off\r\nif %~1==--stdio exit /b 0\r\nexit /b 7\r\n")
+
+    const proc = spawn(file, ["--stdio"])
+
+    expect(await proc.exited).toBe(0)
+  })
+})