@razdolbai/merls 0.1.0

package/test/cli-contract.test.ts

@@ -0,0 +1,94 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+import { spawn } from "node:child_process";
+
+type JsonRpcMessage = {
+  id?: number;
+  jsonrpc: "2.0";
+  result?: {
+    capabilities?: object;
+  };
+};
+
+function encodeMessage(message: object): string {
+  const body = JSON.stringify(message);
+  return `Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`;
+}
+
+export async function runCliContractTest(): Promise<void> {
+  const packageJsonPath = path.resolve(process.cwd(), "package.json");
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8")) as {
+    bin?: Record<string, string>;
+  };
+
+  assert.equal(packageJson.bin?.merls, "dist/src/cli.js");
+
+  const cliPath = path.resolve(__dirname, "../src/cli.js");
+  const child = spawn(process.execPath, [cliPath, "--stdio"], {
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+
+  const response = new Promise<JsonRpcMessage>((resolve, reject) => {
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+
+    child.stdout.on("data", (chunk: string) => {
+      stdout += chunk;
+
+      const separator = stdout.indexOf("\r\n\r\n");
+      if (separator === -1) {
+        return;
+      }
+
+      const header = stdout.slice(0, separator);
+      const match = /Content-Length: (\d+)/i.exec(header);
+      if (!match) {
+        reject(new Error(`Missing Content-Length header in response: ${stdout}`));
+        return;
+      }
+
+      const length = Number(match[1]);
+      const body = stdout.slice(separator + 4);
+      if (Buffer.byteLength(body, "utf8") < length) {
+        return;
+      }
+
+      resolve(JSON.parse(body.slice(0, length)) as JsonRpcMessage);
+    });
+
+    child.stderr.on("data", (chunk: string) => {
+      stderr += chunk;
+    });
+
+    child.once("error", reject);
+    child.once("exit", (code) => {
+      reject(new Error(`CLI exited before initialize response. code=${code}, stderr=${stderr}`));
+    });
+  });
+
+  child.stdin.write(
+    encodeMessage({
+      id: 1,
+      jsonrpc: "2.0",
+      method: "initialize",
+      params: {
+        capabilities: {},
+        processId: process.pid,
+        rootUri: null
+      }
+    })
+  );
+
+  try {
+    const message = await response;
+    assert.equal(message.id, 1);
+    assert.equal(message.jsonrpc, "2.0");
+    assert.equal(typeof message.result?.capabilities, "object");
+  } finally {
+    child.kill();
+  }
+}

package/test/coc-config.test.ts

@@ -0,0 +1,28 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+
+type CocSettings = {
+  languageserver?: {
+    merls?: {
+      command?: string;
+      args?: string[];
+      filetypes?: string[];
+      rootPatterns?: string[];
+    };
+  };
+};
+
+export function runCocConfigTest(): void {
+  const settingsPath = path.resolve(process.cwd(), "examples/coc-settings.json");
+  const settings = JSON.parse(fs.readFileSync(settingsPath, "utf8")) as CocSettings;
+  const serverConfig = settings.languageserver?.merls;
+
+  assert.equal(serverConfig?.command, "node");
+  assert.deepEqual(serverConfig?.args, [
+    "C:/Users/alexe/Projects/merls/dist/src/cli.js",
+    "--stdio"
+  ]);
+  assert.deepEqual(serverConfig?.filetypes, ["asm"]);
+  assert.deepEqual(serverConfig?.rootPatterns, [".git", "package.json"]);
+}

package/test/completion.test.ts

@@ -0,0 +1,151 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+import { spawn } from "node:child_process";
+
+type JsonRpcMessage = {
+  id?: number;
+  jsonrpc: "2.0";
+  result?: unknown;
+};
+
+function encodeMessage(message: object): string {
+  const body = JSON.stringify(message);
+  return `Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`;
+}
+
+function decodeMessages(streamBuffer: string): { messages: JsonRpcMessage[]; rest: string } {
+  const messages: JsonRpcMessage[] = [];
+  let buffer = streamBuffer;
+
+  for (;;) {
+    const separator = buffer.indexOf("\r\n\r\n");
+    if (separator === -1) {
+      return { messages, rest: buffer };
+    }
+
+    const header = buffer.slice(0, separator);
+    const match = /Content-Length: (\d+)/i.exec(header);
+    if (!match) {
+      throw new Error(`Missing Content-Length header: ${header}`);
+    }
+
+    const length = Number(match[1]);
+    const body = buffer.slice(separator + 4);
+    if (Buffer.byteLength(body, "utf8") < length) {
+      return { messages, rest: buffer };
+    }
+
+    messages.push(JSON.parse(body.slice(0, length)) as JsonRpcMessage);
+    buffer = body.slice(length);
+  }
+}
+
+function positionOf(text: string, needle: string): { line: number; character: number } {
+  const index = text.indexOf(needle);
+  assert.notEqual(index, -1, `expected to find ${needle}`);
+  const prefix = text.slice(0, index);
+  const lines = prefix.split("\n");
+  return {
+    line: lines.length - 1,
+    character: lines.at(-1)?.length ?? 0
+  };
+}
+
+export async function runCompletionTest(): Promise<void> {
+  const serverPath = path.resolve(__dirname, "../src/server.js");
+  const mainPath = path.resolve(
+    process.cwd(),
+    "test/fixtures/valid/merlin32-main-6502.asm"
+  );
+  const mainUri = `file://${mainPath.replace(/\\/g, "/")}`;
+  const text = `${fs.readFileSync(mainPath, "utf8")}\n        ld\n        du\n        bpl G`;
+  const child = spawn(process.execPath, [serverPath], {
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+
+  let stdout = "";
+  let nextId = 1;
+  const pending = new Map<number, (message: JsonRpcMessage) => void>();
+
+  child.stdout.setEncoding("utf8");
+  child.stdout.on("data", (chunk: string) => {
+    stdout += chunk;
+    const decoded = decodeMessages(stdout);
+    stdout = decoded.rest;
+
+    for (const message of decoded.messages) {
+      if (message.id !== undefined) {
+        pending.get(message.id)?.(message);
+        pending.delete(message.id);
+      }
+    }
+  });
+
+  function sendRequest(method: string, params: object): Promise<JsonRpcMessage> {
+    const id = nextId++;
+    child.stdin.write(
+      encodeMessage({
+        id,
+        jsonrpc: "2.0",
+        method,
+        params
+      })
+    );
+
+    return new Promise((resolve) => {
+      pending.set(id, resolve);
+    });
+  }
+
+  function sendNotification(method: string, params: object): void {
+    child.stdin.write(
+      encodeMessage({
+        jsonrpc: "2.0",
+        method,
+        params
+      })
+    );
+  }
+
+  try {
+    await sendRequest("initialize", {
+      capabilities: {},
+      processId: process.pid,
+      rootUri: `file://${path.resolve(process.cwd()).replace(/\\/g, "/")}`
+    });
+
+    sendNotification("initialized", {});
+    sendNotification("textDocument/didOpen", {
+      textDocument: {
+        uri: mainUri,
+        languageId: "asm",
+        version: 1,
+        text
+      }
+    });
+
+    const opcodeResponse = await sendRequest("textDocument/completion", {
+      textDocument: { uri: mainUri },
+      position: positionOf(text, "        ld")
+    });
+    const opcodeItems = opcodeResponse.result as Array<{ label: string }>;
+    assert.equal(opcodeItems.some((item) => item.label === "lda"), true);
+
+    const directiveResponse = await sendRequest("textDocument/completion", {
+      textDocument: { uri: mainUri },
+      position: positionOf(text, "        du")
+    });
+    const directiveItems = directiveResponse.result as Array<{ label: string }>;
+    assert.equal(directiveItems.some((item) => item.label === "dum"), true);
+
+    const symbolResponse = await sendRequest("textDocument/completion", {
+      textDocument: { uri: mainUri },
+      position: positionOf(text, "        bpl G")
+    });
+    const symbolItems = symbolResponse.result as Array<{ label: string }>;
+    assert.equal(symbolItems.some((item) => item.label === "GetKey"), true);
+  } finally {
+    child.kill();
+  }
+}

package/test/definition-references.test.ts

@@ -0,0 +1,152 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+import { spawn } from "node:child_process";
+
+type JsonRpcMessage = {
+  id?: number;
+  jsonrpc: "2.0";
+  result?: unknown;
+};
+
+function encodeMessage(message: object): string {
+  const body = JSON.stringify(message);
+  return `Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`;
+}
+
+function decodeMessages(streamBuffer: string): { messages: JsonRpcMessage[]; rest: string } {
+  const messages: JsonRpcMessage[] = [];
+  let buffer = streamBuffer;
+
+  for (;;) {
+    const separator = buffer.indexOf("\r\n\r\n");
+    if (separator === -1) {
+      return { messages, rest: buffer };
+    }
+
+    const header = buffer.slice(0, separator);
+    const match = /Content-Length: (\d+)/i.exec(header);
+    if (!match) {
+      throw new Error(`Missing Content-Length header: ${header}`);
+    }
+
+    const length = Number(match[1]);
+    const body = buffer.slice(separator + 4);
+    if (Buffer.byteLength(body, "utf8") < length) {
+      return { messages, rest: buffer };
+    }
+
+    messages.push(JSON.parse(body.slice(0, length)) as JsonRpcMessage);
+    buffer = body.slice(length);
+  }
+}
+
+function positionOf(text: string, needle: string): { line: number; character: number } {
+  const index = text.indexOf(needle);
+  assert.notEqual(index, -1, `expected to find ${needle}`);
+  const prefix = text.slice(0, index);
+  const lines = prefix.split("\n");
+  return {
+    line: lines.length - 1,
+    character: lines.at(-1)?.length ?? 0
+  };
+}
+
+export async function runDefinitionReferencesTest(): Promise<void> {
+  const serverPath = path.resolve(__dirname, "../src/server.js");
+  const mainPath = path.resolve(
+    process.cwd(),
+    "test/fixtures/valid/merlin32-main-6502.asm"
+  );
+  const mainUri = `file://${mainPath.replace(/\\/g, "/")}`;
+  const text = fs.readFileSync(mainPath, "utf8");
+  const child = spawn(process.execPath, [serverPath], {
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+
+  let stdout = "";
+  let nextId = 1;
+  const pending = new Map<number, (message: JsonRpcMessage) => void>();
+
+  child.stdout.setEncoding("utf8");
+  child.stdout.on("data", (chunk: string) => {
+    stdout += chunk;
+    const decoded = decodeMessages(stdout);
+    stdout = decoded.rest;
+
+    for (const message of decoded.messages) {
+      if (message.id !== undefined) {
+        pending.get(message.id)?.(message);
+        pending.delete(message.id);
+      }
+    }
+  });
+
+  function sendRequest(method: string, params: object): Promise<JsonRpcMessage> {
+    const id = nextId++;
+    child.stdin.write(
+      encodeMessage({
+        id,
+        jsonrpc: "2.0",
+        method,
+        params
+      })
+    );
+
+    return new Promise((resolve) => {
+      pending.set(id, resolve);
+    });
+  }
+
+  function sendNotification(method: string, params: object): void {
+    child.stdin.write(
+      encodeMessage({
+        jsonrpc: "2.0",
+        method,
+        params
+      })
+    );
+  }
+
+  try {
+    await sendRequest("initialize", {
+      capabilities: {},
+      processId: process.pid,
+      rootUri: `file://${path.resolve(process.cwd()).replace(/\\/g, "/")}`
+    });
+
+    sendNotification("initialized", {});
+    sendNotification("textDocument/didOpen", {
+      textDocument: {
+        uri: mainUri,
+        languageId: "asm",
+        version: 1,
+        text
+      }
+    });
+
+    const definitionResponse = await sendRequest("textDocument/definition", {
+      textDocument: { uri: mainUri },
+      position: positionOf(text, "bpl GetKey")
+    });
+
+    const definition = definitionResponse.result as { uri: string; range: { start: { line: number } } };
+    assert.equal(definition.uri, mainUri);
+    assert.equal(definition.range.start.line, 69);
+
+    const referencesResponse = await sendRequest("textDocument/references", {
+      textDocument: { uri: mainUri },
+      position: positionOf(text, "GetKey  ldx"),
+      context: {
+        includeDeclaration: true
+      }
+    });
+
+    const references = referencesResponse.result as Array<{ uri: string; range: { start: { line: number } } }>;
+    assert.equal(Array.isArray(references), true);
+    assert.equal(references.some((reference) => reference.uri === mainUri && reference.range.start.line === 69), true);
+    assert.equal(references.some((reference) => reference.uri === mainUri && reference.range.start.line === 70), true);
+  } finally {
+    child.kill();
+  }
+}

package/test/diagnostics.test.ts

@@ -0,0 +1,129 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+
+import { parseDocument } from "../src/asm/document";
+import {
+  collectWorkspaceDiagnostics,
+  type Diagnostic
+} from "../src/asm/diagnostics";
+
+export function runDiagnosticsTest(): void {
+  const duplicateSource = [
+    "dup     equ 1",
+    "        lda missing",
+    "dup     equ 2",
+    "        adc (",
+    "        dsk ../build/WORLD",
+    "        typ BIN",
+    "        typ BLAH",
+    "        end BLAH"
+  ].join("\n");
+
+  const bankOpsPath = path.resolve(
+    process.cwd(),
+    "test/fixtures/invalid/65816-bank-ops.asm"
+  );
+  const longPath = path.resolve(
+    process.cwd(),
+    "test/fixtures/invalid/65816-long-addressing.asm"
+  );
+
+  const diagnostics = collectWorkspaceDiagnostics([
+    {
+      filePath: "<memory>",
+      document: parseDocument(duplicateSource)
+    },
+    {
+      filePath: bankOpsPath,
+      document: parseDocument(fs.readFileSync(bankOpsPath, "utf8"))
+    },
+    {
+      filePath: longPath,
+      document: parseDocument(fs.readFileSync(longPath, "utf8"))
+    }
+  ]);
+
+  assert.equal(
+    diagnostics.some(
+      (diagnostic: Diagnostic) =>
+        diagnostic.filePath === "<memory>" &&
+        diagnostic.code === "duplicate-symbol" &&
+        diagnostic.line === 2
+    ),
+    true
+  );
+
+  assert.equal(
+    diagnostics.some(
+      (diagnostic: Diagnostic) =>
+        diagnostic.filePath === "<memory>" &&
+        diagnostic.code === "unresolved-reference" &&
+        diagnostic.line === 1 &&
+        diagnostic.message.includes("missing")
+    ),
+    true
+  );
+
+  assert.equal(
+    diagnostics.some(
+      (diagnostic: Diagnostic) =>
+        diagnostic.filePath === "<memory>" &&
+        diagnostic.code === "unresolved-reference" &&
+        (diagnostic.line === 4 || diagnostic.line === 5)
+    ),
+    false
+  );
+
+  assert.equal(
+    diagnostics.some(
+      (diagnostic: Diagnostic) =>
+        diagnostic.filePath === "<memory>" &&
+        diagnostic.code === "unresolved-reference" &&
+        diagnostic.line === 6 &&
+        diagnostic.message.includes("BLAH")
+    ),
+    true
+  );
+
+  assert.equal(
+    diagnostics.some(
+      (diagnostic: Diagnostic) =>
+        diagnostic.filePath === "<memory>" &&
+        diagnostic.code === "malformed-line" &&
+        diagnostic.line === 3
+    ),
+    true
+  );
+
+  assert.equal(
+    diagnostics.some(
+      (diagnostic: Diagnostic) =>
+        diagnostic.filePath === "<memory>" &&
+        diagnostic.code === "malformed-line" &&
+        diagnostic.line === 7 &&
+        diagnostic.message === "unexpected operand for end"
+    ),
+    true
+  );
+
+  assert.equal(
+    diagnostics.some(
+      (diagnostic: Diagnostic) =>
+        diagnostic.filePath === bankOpsPath &&
+        diagnostic.code === "unsupported-65816" &&
+        diagnostic.message.includes("mvn")
+    ),
+    true
+  );
+
+  assert.equal(
+    diagnostics.some(
+      (diagnostic: Diagnostic) =>
+        diagnostic.filePath === longPath &&
+        diagnostic.code === "unsupported-65816" &&
+        diagnostic.message.includes("^")
+    ),
+    true
+  );
+}

package/test/document-model.test.ts

@@ -0,0 +1,29 @@
+import assert from "node:assert/strict";
+
+import { parseDocument } from "../src/asm/document";
+
+export function runDocumentModelTest(): void {
+  const source = [
+    "TEXT    =   $FB39",
+    "        adc (",
+    "        lda #1",
+    "",
+    "; trailing note"
+  ].join("\n");
+
+  const document = parseDocument(source);
+
+  assert.equal(document.lines.length, 5);
+  assert.equal(document.errors.length, 1);
+  assert.deepEqual(document.errors[0], {
+    line: 1,
+    text: "        adc (",
+    message: "expected expression token"
+  });
+
+  assert.equal(document.lines[0]?.node.shape, "equate");
+  assert.equal(document.lines[1]?.node.shape, "malformed");
+  assert.equal(document.lines[2]?.node.shape, "instruction");
+  assert.equal(document.lines[3]?.node.shape, "empty");
+  assert.equal(document.lines[4]?.node.shape, "commentOnly");
+}