@razdolbai/merls 1.2.2 → 1.3.1

package/test/hover.test.ts

@@ -1,175 +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();
-  }
-}
+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.S"
+  );
+  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();
+  }
+}

package/test/lexer.test.ts

@@ -1,87 +1,87 @@
-import assert from "node:assert/strict";
-import fs from "node:fs";
-import path from "node:path";
-
-import {
-  type LexedLine,
-  type Token,
-  lexSource
-} from "../src/asm/lexer";
-
-function summarizeTokens(tokens: readonly Token[]): readonly (readonly [string, string])[] {
-  return tokens.map((token) => [token.kind, token.lexeme] as const);
-}
-
-function findLine(lines: readonly LexedLine[], source: string): LexedLine {
-  const line = lines.find((candidate) => candidate.text === source);
-  assert.ok(line, `expected to find line: ${source}`);
-  return line;
-}
-
-export function runLexerTest(): void {
-  const mainFixturePath = path.resolve(
-    process.cwd(),
-    "test/fixtures/valid/merlin32-main-6502.asm"
-  );
-  const linkFixturePath = path.resolve(
-    process.cwd(),
-    "test/fixtures/valid/merlin32-linkscript.asm"
-  );
-
-  const mainFixture = fs.readFileSync(mainFixturePath, "utf8");
-  const linkFixture = fs.readFileSync(linkFixturePath, "utf8");
-
-  const mainLines = lexSource(mainFixture).lines;
-  const linkLines = lexSource(linkFixture).lines;
-
-  assert.deepEqual(
-    summarizeTokens(findLine(mainLines, "; Source: apple2accumulator/merlin32").tokens),
-    [["comment", "; Source: apple2accumulator/merlin32"]]
-  );
-
-  assert.deepEqual(
-    summarizeTokens(findLine(mainLines, "TEXT    =   $FB39").tokens),
-    [
-      ["label", "TEXT"],
-      ["expressionOperator", "="],
-      ["numericLiteral", "$FB39"]
-    ]
-  );
-
-  assert.deepEqual(
-    summarizeTokens(findLine(mainLines, "        DUM 0").tokens),
-    [
-      ["directive", "DUM"],
-      ["numericLiteral", "0"]
-    ]
-  );
-
-  assert.deepEqual(
-    summarizeTokens(findLine(mainLines, "        adc ($80,x)").tokens),
-    [
-      ["mnemonic", "adc"],
-      ["expressionOperator", "("],
-      ["numericLiteral", "$80"],
-      ["expressionOperator", ","],
-      ["identifier", "x"],
-      ["expressionOperator", ")"]
-    ]
-  );
-
-  assert.deepEqual(
-    summarizeTokens(findLine(mainLines, "GetKey  ldx $C000").tokens),
-    [
-      ["label", "GetKey"],
-      ["mnemonic", "ldx"],
-      ["numericLiteral", "$C000"]
-    ]
-  );
-
-  assert.deepEqual(
-    summarizeTokens(findLine(linkLines, "    asm \"merlin32-main-6502.asm\"").tokens),
-    [
-      ["directive", "asm"],
-      ["string", "\"merlin32-main-6502.asm\""]
-    ]
-  );
-}
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+
+import {
+  type LexedLine,
+  type Token,
+  lexSource
+} from "../src/asm/lexer";
+
+function summarizeTokens(tokens: readonly Token[]): readonly (readonly [string, string])[] {
+  return tokens.map((token) => [token.kind, token.lexeme] as const);
+}
+
+function findLine(lines: readonly LexedLine[], source: string): LexedLine {
+  const line = lines.find((candidate) => candidate.text === source);
+  assert.ok(line, `expected to find line: ${source}`);
+  return line;
+}
+
+export function runLexerTest(): void {
+  const mainFixturePath = path.resolve(
+    process.cwd(),
+    "test/fixtures/valid/merlin32-main-6502.S"
+  );
+  const linkFixturePath = path.resolve(
+    process.cwd(),
+    "test/fixtures/valid/merlin32-linkscript.S"
+  );
+
+  const mainFixture = fs.readFileSync(mainFixturePath, "utf8");
+  const linkFixture = fs.readFileSync(linkFixturePath, "utf8");
+
+  const mainLines = lexSource(mainFixture).lines;
+  const linkLines = lexSource(linkFixture).lines;
+
+  assert.deepEqual(
+    summarizeTokens(findLine(mainLines, "; Source: apple2accumulator/merlin32").tokens),
+    [["comment", "; Source: apple2accumulator/merlin32"]]
+  );
+
+  assert.deepEqual(
+    summarizeTokens(findLine(mainLines, "TEXT    =   $FB39").tokens),
+    [
+      ["label", "TEXT"],
+      ["expressionOperator", "="],
+      ["numericLiteral", "$FB39"]
+    ]
+  );
+
+  assert.deepEqual(
+    summarizeTokens(findLine(mainLines, "        DUM 0").tokens),
+    [
+      ["directive", "DUM"],
+      ["numericLiteral", "0"]
+    ]
+  );
+
+  assert.deepEqual(
+    summarizeTokens(findLine(mainLines, "        adc ($80,x)").tokens),
+    [
+      ["mnemonic", "adc"],
+      ["expressionOperator", "("],
+      ["numericLiteral", "$80"],
+      ["expressionOperator", ","],
+      ["identifier", "x"],
+      ["expressionOperator", ")"]
+    ]
+  );
+
+  assert.deepEqual(
+    summarizeTokens(findLine(mainLines, "GetKey  ldx $C000").tokens),
+    [
+      ["label", "GetKey"],
+      ["mnemonic", "ldx"],
+      ["numericLiteral", "$C000"]
+    ]
+  );
+
+  assert.deepEqual(
+    summarizeTokens(findLine(linkLines, "    asm \"merlin32-main-6502.S\"").tokens),
+    [
+      ["directive", "asm"],
+      ["string", "\"merlin32-main-6502.S\""]
+    ]
+  );
+}

package/test/local-labels.test.ts

@@ -1,47 +1,47 @@
-import assert from "node:assert/strict";
-import fs from "node:fs";
-import path from "node:path";
-
-import { parseDocument } from "../src/asm/document";
-import { resolveLocalLabels } from "../src/asm/local-labels";
-
-export function runLocalLabelScopeTest(): void {
-  const fixturePath = path.resolve(
-    process.cwd(),
-    "test/fixtures/valid/merlin32-main-6502.asm"
-  );
-  const source = fs.readFileSync(fixturePath, "utf8");
-
-  const document = parseDocument(source);
-  const scope = resolveLocalLabels(document);
-
-  assert.deepEqual(scope.definitions.get("]loop@69"), {
-    name: "]loop",
-    line: 71,
-    anchor: "GetKey",
-    qualifiedName: "]loop@69"
-  });
-
-  assert.deepEqual(scope.references.get("]loop@73"), {
-    name: "]loop",
-    line: 73,
-    anchor: "GetKey",
-    qualifiedName: "]loop@69",
-    targetLine: 71
-  });
-
-  assert.deepEqual(scope.definitions.get(":err@69"), {
-    name: ":err",
-    line: 82,
-    anchor: "GetKey",
-    qualifiedName: ":err@69"
-  });
-
-  assert.deepEqual(scope.references.get(":good@81"), {
-    name: ":good",
-    line: 81,
-    anchor: "GetKey",
-    qualifiedName: ":good@69",
-    targetLine: 84
-  });
-}
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+
+import { parseDocument } from "../src/asm/document";
+import { resolveLocalLabels } from "../src/asm/local-labels";
+
+export function runLocalLabelScopeTest(): void {
+  const fixturePath = path.resolve(
+    process.cwd(),
+    "test/fixtures/valid/merlin32-main-6502.S"
+  );
+  const source = fs.readFileSync(fixturePath, "utf8");
+
+  const document = parseDocument(source);
+  const scope = resolveLocalLabels(document);
+
+  assert.deepEqual(scope.definitions.get("]loop@70"), {
+    name: "]loop",
+    line: 72,
+    anchor: "GetKey",
+    qualifiedName: "]loop@70"
+  });
+
+  assert.deepEqual(scope.references.get("]loop@74"), {
+    name: "]loop",
+    line: 74,
+    anchor: "GetKey",
+    qualifiedName: "]loop@70",
+    targetLine: 72
+  });
+
+  assert.deepEqual(scope.definitions.get(":err@70"), {
+    name: ":err",
+    line: 83,
+    anchor: "GetKey",
+    qualifiedName: ":err@70"
+  });
+
+  assert.deepEqual(scope.references.get(":good@82"), {
+    name: ":good",
+    line: 82,
+    anchor: "GetKey",
+    qualifiedName: ":good@70",
+    targetLine: 85
+  });
+}