@razdolbai/merls 0.1.0

package/dist/test/server-initialize.test.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runInitializeHandshakeTest = runInitializeHandshakeTest;
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = __importDefault(require("node:path"));
+function encodeMessage(message) {
+    const body = JSON.stringify(message);
+    return `Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`;
+}
+async function runInitializeHandshakeTest() {
+    const serverPath = node_path_1.default.resolve(__dirname, "../src/server.js");
+    const child = (0, node_child_process_1.spawn)(process.execPath, [serverPath], {
+        stdio: ["pipe", "pipe", "pipe"]
+    });
+    const response = new Promise((resolve, reject) => {
+        let stdout = "";
+        let stderr = "";
+        child.stdout.setEncoding("utf8");
+        child.stderr.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            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)));
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        child.once("error", reject);
+        child.once("exit", (code) => {
+            reject(new Error(`Server exited before initialize response. code=${code}, stderr=${stderr}`));
+        });
+    });
+    child.stdin.write(encodeMessage({
+        id: 1,
+        jsonrpc: "2.0",
+        method: "initialize",
+        params: {
+            capabilities: {},
+            clientInfo: {
+                name: "merls-test"
+            },
+            processId: process.pid,
+            rootUri: null
+        }
+    }));
+    try {
+        const message = await response;
+        strict_1.default.equal(message.id, 1);
+        strict_1.default.equal(message.jsonrpc, "2.0");
+        strict_1.default.equal(typeof message.result?.capabilities, "object");
+        strict_1.default.equal(message.result?.capabilities?.textDocumentSync?.openClose, true);
+        strict_1.default.equal(message.result?.capabilities?.textDocumentSync?.change, 1);
+        strict_1.default.equal(message.result?.capabilities?.definitionProvider, true);
+        strict_1.default.equal(message.result?.capabilities?.referencesProvider, true);
+    }
+    finally {
+        child.kill();
+    }
+}

package/dist/test/symbols.test.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSymbolsTest = runSymbolsTest;
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const document_1 = require("../src/asm/document");
+const symbols_1 = require("../src/asm/symbols");
+function runSymbolsTest() {
+    const fixturePath = node_path_1.default.resolve(process.cwd(), "test/fixtures/valid/merlin32-main-6502.asm");
+    const source = node_fs_1.default.readFileSync(fixturePath, "utf8");
+    const document = (0, document_1.parseDocument)(source);
+    const symbols = (0, symbols_1.collectSymbols)(document);
+    strict_1.default.deepEqual(symbols.get("TEXT"), {
+        name: "TEXT",
+        kind: "equate",
+        line: 11
+    });
+    strict_1.default.deepEqual(symbols.get("TEST_START"), {
+        name: "TEST_START",
+        kind: "label",
+        line: 31
+    });
+    strict_1.default.deepEqual(symbols.get("dum0"), {
+        name: "dum0",
+        kind: "data",
+        line: 17
+    });
+    strict_1.default.deepEqual(symbols.get("_num1"), {
+        name: "_num1",
+        kind: "data",
+        line: 25
+    });
+}

package/dist/test/syntax-shape.test.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSyntaxShapeTest = runSyntaxShapeTest;
+const strict_1 = __importDefault(require("node:assert/strict"));
+const syntax_1 = require("../src/asm/syntax");
+function runSyntaxShapeTest() {
+    strict_1.default.equal(syntax_1.tokenKindTable.get("comment")?.captureExamples[0], "; trailing note");
+    strict_1.default.equal(syntax_1.tokenKindTable.get("localLabel")?.captureExamples[0], "]loop");
+    strict_1.default.equal(syntax_1.tokenKindTable.get("modifier")?.captureExamples.includes("<value"), true);
+    strict_1.default.equal(syntax_1.tokenKindTable.has("expressionOperator"), true);
+    strict_1.default.equal(syntax_1.lineShapeTable.get("instruction")?.allowsLabel, true);
+    strict_1.default.equal(syntax_1.lineShapeTable.get("directive")?.requiresOperand, false);
+    strict_1.default.equal(syntax_1.lineShapeTable.get("equate")?.allowsExpression, true);
+    strict_1.default.equal(syntax_1.lineShapeTable.get("malformed")?.terminal, true);
+}

package/dist/test/workspace-symbol.test.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runWorkspaceSymbolTest = runWorkspaceSymbolTest;
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+function encodeMessage(message) {
+    const body = JSON.stringify(message);
+    return `Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`;
+}
+function decodeMessages(streamBuffer) {
+    const messages = [];
+    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)));
+        buffer = body.slice(length);
+    }
+}
+async function runWorkspaceSymbolTest() {
+    const serverPath = node_path_1.default.resolve(__dirname, "../src/server.js");
+    const linkPath = node_path_1.default.resolve(process.cwd(), "test/fixtures/valid/merlin32-linkscript.asm");
+    const mainPath = node_path_1.default.resolve(process.cwd(), "test/fixtures/valid/merlin32-main-6502.asm");
+    const linkUri = `file://${linkPath.replace(/\\/g, "/")}`;
+    const mainUri = `file://${mainPath.replace(/\\/g, "/")}`;
+    const child = (0, node_child_process_1.spawn)(process.execPath, [serverPath], {
+        stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let nextId = 1;
+    const pending = new Map();
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+        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, params) {
+        const id = nextId++;
+        child.stdin.write(encodeMessage({
+            id,
+            jsonrpc: "2.0",
+            method,
+            params
+        }));
+        return new Promise((resolve) => {
+            pending.set(id, resolve);
+        });
+    }
+    function sendNotification(method, params) {
+        child.stdin.write(encodeMessage({
+            jsonrpc: "2.0",
+            method,
+            params
+        }));
+    }
+    try {
+        await sendRequest("initialize", {
+            capabilities: {},
+            processId: process.pid,
+            rootUri: `file://${node_path_1.default.resolve(process.cwd()).replace(/\\/g, "/")}`
+        });
+        sendNotification("initialized", {});
+        sendNotification("textDocument/didOpen", {
+            textDocument: {
+                uri: linkUri,
+                languageId: "asm",
+                version: 1,
+                text: node_fs_1.default.readFileSync(linkPath, "utf8")
+            }
+        });
+        sendNotification("textDocument/didOpen", {
+            textDocument: {
+                uri: mainUri,
+                languageId: "asm",
+                version: 1,
+                text: node_fs_1.default.readFileSync(mainPath, "utf8")
+            }
+        });
+        const response = await sendRequest("workspace/symbol", {
+            query: "Get"
+        });
+        const symbols = response.result;
+        strict_1.default.equal(Array.isArray(symbols), true);
+        strict_1.default.equal(symbols.some((symbol) => symbol.name === "GetKey" && symbol.location.uri === mainUri), true);
+    }
+    finally {
+        child.kill();
+    }
+}

package/dist/test/workspace.test.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runWorkspaceGraphTest = runWorkspaceGraphTest;
+const strict_1 = __importDefault(require("node:assert/strict"));
+const node_path_1 = __importDefault(require("node:path"));
+const workspace_1 = require("../src/asm/workspace");
+function runWorkspaceGraphTest() {
+    const entryPath = node_path_1.default.resolve(process.cwd(), "test/fixtures/valid/merlin32-linkscript.asm");
+    const mainPath = node_path_1.default.resolve(process.cwd(), "test/fixtures/valid/merlin32-main-6502.asm");
+    const workspace = (0, workspace_1.indexWorkspace)(entryPath);
+    strict_1.default.deepEqual(workspace.loadOrder, [entryPath, mainPath]);
+    strict_1.default.deepEqual(workspace.dependencies.get(entryPath), [mainPath]);
+    strict_1.default.equal(workspace.documents.has(entryPath), true);
+    strict_1.default.equal(workspace.documents.has(mainPath), true);
+    strict_1.default.deepEqual(workspace.symbols.get("TEXT"), {
+        name: "TEXT",
+        kind: "equate",
+        line: 11,
+        filePath: mainPath
+    });
+}

package/examples/coc-settings.json

@@ -0,0 +1,18 @@
+{
+  "languageserver": {
+    "merls": {
+      "command": "node",
+      "args": [
+        "C:/Users/alexe/Projects/merls/dist/src/cli.js",
+        "--stdio"
+      ],
+      "rootPatterns": [
+        ".git",
+        "package.json"
+      ],
+      "filetypes": [
+        "asm"
+      ]
+    }
+  }
+}

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@razdolbai/merls",
+  "version": "0.1.0",
+  "description": "Language server for Merlin-style 6502 assembly.",
+  "type": "commonjs",
+  "bin": {
+    "merls": "dist/src/cli.js"
+  },
+  "main": "dist/src/server.js",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
+    "dev": "tsc -p tsconfig.json --watch",
+    "test": "npm run build && node dist/test/run-tests.js"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "vscode-languageserver": "^9.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.10",
+    "typescript": "^5.8.3"
+  }
+}

package/publish.ps1

@@ -0,0 +1,9 @@
+$ErrorActionPreference = "Stop"
+
+Write-Host "Building package..." -ForegroundColor Cyan
+npm run build
+
+Write-Host "Publishing to npm..." -ForegroundColor Cyan
+npm publish --access=public
+
+Write-Host "Publish successful!" -ForegroundColor Green

package/src/asm/diagnostics.ts

@@ -0,0 +1,294 @@
+import { type ParsedDocument } from "./document";
+import { type Expression, type Operand } from "./expression";
+import { resolveLocalLabels } from "./local-labels";
+import { directiveTable } from "./metadata";
+import { type ParsedLine } from "./parser";
+
+export type DiagnosticCode =
+  | "duplicate-symbol"
+  | "unresolved-reference"
+  | "malformed-line"
+  | "unsupported-65816";
+
+export type Diagnostic = {
+  filePath: string;
+  line: number;
+  code: DiagnosticCode;
+  message: string;
+};
+
+export type DocumentEntry = {
+  filePath: string;
+  document: ParsedDocument;
+};
+
+type SymbolRecord = {
+  name: string;
+  line: number;
+  filePath: string;
+};
+
+export function collectWorkspaceDiagnostics(
+  documents: readonly DocumentEntry[]
+): readonly Diagnostic[] {
+  const diagnostics: Diagnostic[] = [];
+  const globalSymbols = new Set<string>();
+  const symbolRecords: SymbolRecord[] = [];
+
+  for (const entry of documents) {
+    for (const symbol of collectGlobalDefinitions(entry.document, entry.filePath)) {
+      symbolRecords.push(symbol);
+      globalSymbols.add(symbol.name);
+    }
+  }
+
+  diagnostics.push(...collectDuplicateSymbolDiagnostics(symbolRecords));
+
+  for (const entry of documents) {
+    diagnostics.push(
+      ...collectMalformedDiagnostics(entry.filePath, entry.document),
+      ...collectUnsupportedDiagnostics(entry.filePath, entry.document),
+      ...collectUnresolvedDiagnostics(entry.filePath, entry.document, globalSymbols)
+    );
+  }
+
+  return diagnostics;
+}
+
+function collectDuplicateSymbolDiagnostics(
+  symbolRecords: readonly SymbolRecord[]
+): readonly Diagnostic[] {
+  const firstDefinitionByName = new Map<string, SymbolRecord>();
+  const diagnostics: Diagnostic[] = [];
+
+  for (const symbol of symbolRecords) {
+    const firstDefinition = firstDefinitionByName.get(symbol.name);
+    if (firstDefinition === undefined) {
+      firstDefinitionByName.set(symbol.name, symbol);
+      continue;
+    }
+
+    diagnostics.push({
+      filePath: symbol.filePath,
+      line: symbol.line,
+      code: "duplicate-symbol",
+      message: `Duplicate symbol ${symbol.name}; first defined at line ${firstDefinition.line}`
+    });
+  }
+
+  return diagnostics;
+}
+
+function collectMalformedDiagnostics(
+  filePath: string,
+  document: ParsedDocument
+): readonly Diagnostic[] {
+  return document.errors.map((error) => ({
+    filePath,
+    line: error.line,
+    code: "malformed-line" as const,
+    message: error.message
+  }));
+}
+
+function collectUnsupportedDiagnostics(
+  filePath: string,
+  document: ParsedDocument
+): readonly Diagnostic[] {
+  const diagnostics: Diagnostic[] = [];
+
+  for (const line of document.lines) {
+    const unsupportedDirective = getUnsupportedDirective(line.node);
+    if (unsupportedDirective !== null) {
+      diagnostics.push({
+        filePath,
+        line: line.line,
+        code: "unsupported-65816",
+        message: `Unsupported 65816 directive: ${unsupportedDirective}`
+      });
+    }
+
+    const unsupportedText = getUnsupportedTextPattern(line.node.text);
+    if (unsupportedText !== null) {
+      diagnostics.push({
+        filePath,
+        line: line.line,
+        code: "unsupported-65816",
+        message: `Unsupported 65816 syntax: ${unsupportedText}`
+      });
+    }
+  }
+
+  return diagnostics;
+}
+
+function collectUnresolvedDiagnostics(
+  filePath: string,
+  document: ParsedDocument,
+  globalSymbols: ReadonlySet<string>
+): readonly Diagnostic[] {
+  const diagnostics: Diagnostic[] = [];
+  const localScope = resolveLocalLabels(document);
+
+  for (const line of document.lines) {
+    for (const reference of findExpressionReferences(line.node)) {
+      if (reference.startsWith("]") || reference.startsWith(":")) {
+        const localKey = `${reference}@${line.line}`;
+        const localDefinitionKey = [...localScope.definitions.keys()].find((key) =>
+          key.startsWith(`${reference}@`)
+        );
+        if (!localScope.references.has(localKey) && localDefinitionKey === undefined) {
+          diagnostics.push({
+            filePath,
+            line: line.line,
+            code: "unresolved-reference",
+            message: `Unresolved local reference ${reference}`
+          });
+        }
+        continue;
+      }
+
+      if (!globalSymbols.has(reference)) {
+        diagnostics.push({
+          filePath,
+          line: line.line,
+          code: "unresolved-reference",
+          message: `Unresolved reference ${reference}`
+        });
+      }
+    }
+  }
+
+  return diagnostics;
+}
+
+function collectGlobalDefinitions(
+  document: ParsedDocument,
+  filePath: string
+): readonly SymbolRecord[] {
+  const symbols: SymbolRecord[] = [];
+
+  for (const line of document.lines) {
+    const name = getGlobalDefinitionName(line.node);
+    if (name === null) {
+      continue;
+    }
+
+    symbols.push({
+      name,
+      line: line.line,
+      filePath
+    });
+  }
+
+  return symbols;
+}
+
+function getGlobalDefinitionName(node: ParsedLine): string | null {
+  if (node.shape === "equate" && !isLocalLabel(node.label)) {
+    return node.label;
+  }
+
+  if (node.shape === "labelOnly" && !isLocalLabel(node.label)) {
+    return node.label;
+  }
+
+  if (node.shape === "instruction" && node.label !== null && !isLocalLabel(node.label)) {
+    return node.label;
+  }
+
+  if (node.shape === "directive" && node.label !== null && !isLocalLabel(node.label)) {
+    return node.label;
+  }
+
+  if (node.shape === "data" && node.label !== null && !isLocalLabel(node.label)) {
+    return node.label;
+  }
+
+  return null;
+}
+
+function findExpressionReferences(node: ParsedLine): readonly string[] {
+  if (node.shape === "instruction" && node.operand !== null) {
+    return findReferencesInOperand(node.operand);
+  }
+
+  if (node.shape === "directive" && node.operand !== null) {
+    const directive = directiveTable.get(node.directive);
+    if (directive?.kind === "include" || directive?.kind === "build") {
+      if (node.directive === "typ") {
+        const knownAliases = new Set([
+          "txt", "bin", "sys", "bas", "var", "rel",
+          "lib", "s16", "rtl", "exe", "pif", "tif",
+          "nda", "cda", "tol", "dvr", "ldf", "fst"
+        ]);
+        return findReferencesInExpression(node.operand).filter(
+          (ref) => !knownAliases.has(ref.toLowerCase())
+        );
+      }
+      return [];
+    }
+    return findReferencesInExpression(node.operand);
+  }
+
+  if (node.shape === "equate") {
+    return findReferencesInExpression(node.expression);
+  }
+
+  return [];
+}
+
+function findReferencesInOperand(operand: Operand): readonly string[] {
+  return findReferencesInExpression(operand.expression);
+}
+
+function findReferencesInExpression(expression: Expression): readonly string[] {
+  switch (expression.kind) {
+    case "identifier":
+      return [expression.value];
+    case "modifier":
+      return findReferencesInExpression(expression.expression);
+    case "binary":
+      return [
+        ...findReferencesInExpression(expression.left),
+        ...findReferencesInExpression(expression.right)
+      ];
+    default:
+      return [];
+  }
+}
+
+function getUnsupportedDirective(node: ParsedLine): string | null {
+  if (node.shape !== "directive") {
+    return null;
+  }
+
+  const directive = directiveTable.get(node.directive);
+  if (directive?.supported === false) {
+    return node.directive;
+  }
+
+  return null;
+}
+
+function getUnsupportedTextPattern(text: string): string | null {
+  const trimmed = text.trim().toLowerCase();
+
+  if (/^(pea|mvn|mvp)\b/.test(trimmed)) {
+    return trimmed.split(/\s+/, 1)[0] ?? trimmed;
+  }
+
+  if (trimmed.includes("^")) {
+    return "^";
+  }
+
+  if (trimmed.includes("|")) {
+    return "|";
+  }
+
+  return null;
+}
+
+function isLocalLabel(name: string): boolean {
+  return name.startsWith("]") || name.startsWith(":");
+}

package/src/asm/document.ts

@@ -0,0 +1,43 @@
+import { parseSourceLines, type ParsedLine } from "./parser";
+
+export type DocumentLine = {
+  line: number;
+  node: ParsedLine;
+};
+
+export type DocumentError = {
+  line: number;
+  text: string;
+  message: string;
+};
+
+export type ParsedDocument = {
+  lines: readonly DocumentLine[];
+  errors: readonly DocumentError[];
+};
+
+export function parseDocument(source: string): ParsedDocument {
+  const parsedLines = parseSourceLines(source);
+  const lines: DocumentLine[] = [];
+  const errors: DocumentError[] = [];
+
+  parsedLines.forEach((node, line) => {
+    lines.push({
+      line,
+      node
+    });
+
+    if (node.shape === "malformed") {
+      errors.push({
+        line,
+        text: node.text,
+        message: node.message
+      });
+    }
+  });
+
+  return {
+    lines,
+    errors
+  };
+}