@razdolbai/merls 0.1.0

package/test/document-symbol.test.ts

@@ -0,0 +1,131 @@
+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";
+  method?: string;
+  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);
+  }
+}
+
+export async function runDocumentSymbolTest(): Promise<void> {
+  const serverPath = path.resolve(__dirname, "../src/server.js");
+  const fixturePath = path.resolve(
+    process.cwd(),
+    "test/fixtures/valid/merlin32-main-6502.asm"
+  );
+  const uri = `file://${fixturePath.replace(/\\/g, "/")}`;
+  const text = fs.readFileSync(fixturePath, "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 {
+    const initialize = await sendRequest("initialize", {
+      capabilities: {},
+      processId: process.pid,
+      rootUri: null
+    });
+    assert.equal(initialize.id, 1);
+
+    sendNotification("initialized", {});
+    sendNotification("textDocument/didOpen", {
+      textDocument: {
+        uri,
+        languageId: "asm",
+        version: 1,
+        text
+      }
+    });
+
+    const response = await sendRequest("textDocument/documentSymbol", {
+      textDocument: { uri }
+    });
+
+    const symbols = response.result as Array<{ name: string; kind: number }>;
+    assert.equal(Array.isArray(symbols), true);
+    assert.equal(symbols.some((symbol) => symbol.name === "TEXT" && symbol.kind === 13), true);
+    assert.equal(symbols.some((symbol) => symbol.name === "TEST_START" && symbol.kind === 6), true);
+    assert.equal(symbols.some((symbol) => symbol.name === "dum0" && symbol.kind === 8), true);
+  } finally {
+    child.kill();
+  }
+}

package/test/expression.test.ts

@@ -0,0 +1,111 @@
+import assert from "node:assert/strict";
+
+import { lexSource } from "../src/asm/lexer";
+import {
+  type Expression,
+  parseExpression,
+  parseOperand
+} from "../src/asm/expression";
+
+function summarizeExpression(expression: Expression): unknown {
+  switch (expression.kind) {
+    case "binary":
+      return {
+        kind: expression.kind,
+        operator: expression.operator,
+        left: summarizeExpression(expression.left),
+        right: summarizeExpression(expression.right)
+      };
+    case "modifier":
+      return {
+        kind: expression.kind,
+        operator: expression.operator,
+        expression: summarizeExpression(expression.expression)
+      };
+    default:
+      return {
+        kind: expression.kind,
+        value: expression.value
+      };
+  }
+}
+
+function operandTokens(sourceLine: string) {
+  const line = lexSource(sourceLine).lines[0];
+  assert.ok(line, "expected a lexed line");
+  return line.tokens.slice(1);
+}
+
+export function runExpressionTest(): void {
+  const arithmeticTokens = lexSource("_tmp+dum1+1").lines[0]?.tokens ?? [];
+  const arithmetic = parseExpression(arithmeticTokens);
+  assert.equal(arithmetic.nextTokenIndex, arithmeticTokens.length);
+  assert.deepEqual(summarizeExpression(arithmetic.expression), {
+    kind: "binary",
+    operator: "+",
+    left: {
+      kind: "binary",
+      operator: "+",
+      left: { kind: "identifier", value: "_tmp" },
+      right: { kind: "identifier", value: "dum1" }
+    },
+    right: { kind: "numericLiteral", value: "1" }
+  });
+
+  const numericForms = ["$10", "%1010", "42"];
+  for (const numericForm of numericForms) {
+    const tokens = lexSource(numericForm).lines[0]?.tokens ?? [];
+    const parsed = parseExpression(tokens);
+    assert.deepEqual(summarizeExpression(parsed.expression), {
+      kind: "numericLiteral",
+      value: numericForm
+    });
+  }
+
+  const modifierTokens = lexSource("<value+1").lines[0]?.tokens ?? [];
+  const modifier = parseExpression(modifierTokens);
+  assert.deepEqual(summarizeExpression(modifier.expression), {
+    kind: "binary",
+    operator: "+",
+    left: {
+      kind: "modifier",
+      operator: "<",
+      expression: { kind: "identifier", value: "value" }
+    },
+    right: { kind: "numericLiteral", value: "1" }
+  });
+
+  const immediateOperand = parseOperand(operandTokens("        ldx #_LFT"));
+  assert.equal(immediateOperand.operand.immediate, true);
+  assert.equal(immediateOperand.operand.indirect, false);
+  assert.equal(immediateOperand.operand.indexRegister, null);
+  assert.deepEqual(summarizeExpression(immediateOperand.operand.expression), {
+    kind: "identifier",
+    value: "_LFT"
+  });
+
+  const indexedOperand = parseOperand(
+    operandTokens("        sta TSTADDR+_num1+dum0,x")
+  );
+  assert.equal(indexedOperand.operand.immediate, false);
+  assert.equal(indexedOperand.operand.indirect, false);
+  assert.equal(indexedOperand.operand.indexRegister, "x");
+
+  const indirectIndexedOperand = parseOperand(
+    operandTokens("        adc (_tmp+dum1+1,x)")
+  );
+  assert.equal(indirectIndexedOperand.operand.immediate, false);
+  assert.equal(indirectIndexedOperand.operand.indirect, true);
+  assert.equal(indirectIndexedOperand.operand.indexRegister, "x");
+  assert.deepEqual(summarizeExpression(indirectIndexedOperand.operand.expression), {
+    kind: "binary",
+    operator: "+",
+    left: {
+      kind: "binary",
+      operator: "+",
+      left: { kind: "identifier", value: "_tmp" },
+      right: { kind: "identifier", value: "dum1" }
+    },
+    right: { kind: "numericLiteral", value: "1" }
+  });
+}

package/test/fixture-corpus.test.ts

@@ -0,0 +1,33 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+
+const validFixturePaths = [
+  "test/fixtures/valid/merlin32-linkscript.asm",
+  "test/fixtures/valid/merlin32-main-6502.asm"
+];
+
+const invalidFixturePaths = [
+  "test/fixtures/invalid/65816-bank-ops.asm",
+  "test/fixtures/invalid/65816-long-addressing.asm"
+];
+
+export function runFixtureCorpusTest(): void {
+  for (const fixturePath of validFixturePaths) {
+    const absolutePath = path.resolve(process.cwd(), fixturePath);
+    assert.equal(fs.existsSync(absolutePath), true, `${fixturePath} should exist`);
+
+    const content = fs.readFileSync(absolutePath, "utf8");
+    assert.match(content, /Source: apple2accumulator\/merlin32/);
+    assert.ok(content.trim().length > 0, `${fixturePath} should not be empty`);
+  }
+
+  for (const fixturePath of invalidFixturePaths) {
+    const absolutePath = path.resolve(process.cwd(), fixturePath);
+    assert.equal(fs.existsSync(absolutePath), true, `${fixturePath} should exist`);
+
+    const content = fs.readFileSync(absolutePath, "utf8");
+    assert.match(content, /Source: apple2accumulator\/merlin32/);
+    assert.match(content, /65816-only/);
+  }
+}

package/test/fixtures/invalid/65816-bank-ops.asm

@@ -0,0 +1,17 @@
+; Source: apple2accumulator/merlin32
+; Upstream file: Test/main.s
+; 65816-only fixture: block move, MX flags, and PEA forms are intentionally unsupported.
+
+        xc
+        xc
+        org $018200
+
+bank02  equ $020000
+bank03  equ $030000
+
+        mx %00
+start   nop
+        pea ^start
+        pea start
+        mvn bank02,bank03
+        mvp bank03,bank02

package/test/fixtures/invalid/65816-long-addressing.asm

@@ -0,0 +1,26 @@
+; Source: apple2accumulator/merlin32
+; Upstream file: Test/main.s
+; 65816-only fixture: long-addressing and bank-byte modifiers are intentionally unsupported.
+
+        xc
+        xc
+        org $018200
+
+dp      equ $A5
+long    equ $020304
+
+        lda dp
+        lda <dp
+        lda >dp
+        lda ^dp
+        lda |dp
+
+        lda #long
+        lda #<long
+        lda #>long
+        lda #^long
+
+        lda long
+        lda <long
+        lda >long
+        lda ^long

package/test/fixtures/valid/merlin32-linkscript.asm

@@ -0,0 +1,16 @@
+; Source: apple2accumulator/merlin32
+; Upstream file: Test/linkscript.s
+; Transcribed for a 6502-only positive fixture corpus.
+
+*  linkscript.s
+*  Merlin32 Test
+*
+*  Created by Lane Roathe on 8/21/19.
+
+    typ $06
+
+    dsk Merlin32Test
+    org $800
+
+    asm "merlin32-main-6502.asm"
+    sna main

package/test/fixtures/valid/merlin32-main-6502.asm

@@ -0,0 +1,103 @@
+; Source: apple2accumulator/merlin32
+; Upstream file: Test/main.s
+; Transcribed from the 6502-safe portion and trimmed to exclude 65816-only cases.
+
+*  main.s
+*  Merlin32 Test
+*
+*  Created by Lane Roathe on 8/26/19.
+
+]XCODESTART
+
+TEXT    =   $FB39
+CROUT   =   $FD8E
+DOSWARM =   $3D0
+TSTADDR =   $1000
+
+        DUM 0
+dum0    ds  1
+dum1    ds  1
+dumSize =   *
+        DEND
+
+        DUM 0
+_ptr    ds  2
+_tmp    ds  2
+_num1   ds  dumSize
+
+        ORG $20
+_LFT    ds  1
+        DEND
+
+TEST_START
+        adc (0,x)
+        adc ($80,x)
+        adc (_tmp,x)
+        adc (_tmp+0,x)
+        adc (_tmp+$10,x)
+        adc ($10+_tmp,x)
+        adc (_tmp+dum0,x)
+        adc (_tmp+dum1,x)
+        adc (_tmp+dum1+1,x)
+        adc (_tmp+dum0+dum1,x)
+
+        adc 0
+        adc $80
+        adc _tmp
+        adc #0
+        adc $1111
+
+        sta TSTADDR+dum0
+        sta TSTADDR+_num1+dum0
+        sta TSTADDR+_num1+dum0,x
+
+        lda _num1+dum0
+        adc _num1+dum1
+        sbc _num1+dum1
+        bit _num1+dum0
+        sta _num1+dum0
+
+        lda _num1+dum0,x
+        adc _num1+dum0,x
+        sbc _num1+dum0,x
+        sta _num1+dum0,x
+
+        lda _num1+dum0,y
+        adc _num1+dum0,y
+        sbc _num1+dum0,y
+        sta _num1+dum0,y
+
+GetKey  ldx $C000
+        bpl GetKey
+]loop
+        dex
+        bne ]loop
+
+        tya
+        and #1
+        beq :err
+
+        tya
+        and #1
+        bne :good
+:err
+        lda #0
+:good
+        bne myQuit
+        nop
+        hex 2C
+        lda #1
+myQuit
+        jmp DOSWARM
+
+        org $2000
+
+        lda _LFT
+        ldx #_LFT
+        cpx #$20
+
+        org
+
+        stx $bc,y
+
+]XCODEEND

package/test/fixtures/valid/smoke-test.asm

@@ -0,0 +1,7 @@
+; Smoke test fixture for coc.nvim integration.
+; This file intentionally contains one unresolved reference to exercise diagnostics.
+
+GetKey  ldx $C000
+        bpl GetKey
+        jmp NoSuchLabel
+        END

package/test/hover.test.ts

@@ -0,0 +1,175 @@
+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
+  };
+}
+
+function positionOfInMatch(
+  text: string,
+  needle: string,
+  offset: number
+): { line: number; character: number } {
+  const base = positionOf(text, needle);
+  return {
+    line: base.line,
+    character: base.character + offset
+  };
+}
+
+export async function runHoverTest(): 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 opcodeHover = await sendRequest("textDocument/hover", {
+      textDocument: { uri: mainUri },
+      position: positionOf(text, "adc (_tmp")
+    });
+    const opcodeResult = opcodeHover.result as { contents: string | { value: string } };
+    const opcodeText =
+      typeof opcodeResult.contents === "string"
+        ? opcodeResult.contents
+        : opcodeResult.contents.value;
+    assert.equal(opcodeText.includes("adc"), true);
+
+    const directiveHover = await sendRequest("textDocument/hover", {
+      textDocument: { uri: mainUri },
+      position: positionOf(text, "DUM 0")
+    });
+    const directiveResult = directiveHover.result as { contents: string | { value: string } };
+    const directiveText =
+      typeof directiveResult.contents === "string"
+        ? directiveResult.contents
+        : directiveResult.contents.value;
+    assert.equal(directiveText.includes("dum"), true);
+
+    const symbolHover = await sendRequest("textDocument/hover", {
+      textDocument: { uri: mainUri },
+      position: positionOfInMatch(text, "bpl GetKey", 4)
+    });
+    const symbolResult = symbolHover.result as { contents: string | { value: string } };
+    const symbolText =
+      typeof symbolResult.contents === "string"
+        ? symbolResult.contents
+        : symbolResult.contents.value;
+    assert.equal(symbolText.includes("GetKey"), true);
+  } finally {
+    child.kill();
+  }
+}