@razdolbai/merls 0.1.0

package/test/smoke/run-smoke.ps1

@@ -0,0 +1,177 @@
+# coc.nvim smoke test for merls language server.
+#
+# Launches Vim in headless mode with a minimal coc.nvim configuration,
+# opens an .asm fixture file, waits for the language server to start and
+# publish diagnostics, then exits with 0 on success / 1 on failure.
+#
+# Usage:  pwsh test/smoke/run-smoke.ps1
+
+$ErrorActionPreference = "Stop"
+
+$projectRoot = (Resolve-Path "$PSScriptRoot/../..").Path
+$smokeDir    = "$projectRoot/test/smoke"
+$fixture     = "$projectRoot/test/fixtures/valid/smoke-test.asm"
+$cliPath     = "$projectRoot/dist/src/cli.js"
+
+# Ensure the project is built
+if (-not (Test-Path $cliPath)) {
+    Write-Host "Building project..."
+    Push-Location $projectRoot
+    npm run build
+    Pop-Location
+}
+
+# Create an isolated temporary directory for coc.nvim config/data
+$tmpBase   = "$projectRoot/test/smoke/tmp"
+$configDir = "$tmpBase/config"
+$dataDir   = "$tmpBase/data"
+
+if (Test-Path $tmpBase) { Remove-Item -Recurse -Force $tmpBase }
+New-Item -ItemType Directory -Force -Path $configDir | Out-Null
+New-Item -ItemType Directory -Force -Path $dataDir   | Out-Null
+
+# Write the coc-settings.json into the temporary config directory
+$cocSettings = @{
+    languageserver = @{
+        merls = @{
+            command      = "node"
+            args         = @($cliPath.Replace("\", "/"), "--stdio")
+            rootPatterns = @(".git", "package.json")
+            filetypes    = @("asm")
+        }
+    }
+} | ConvertTo-Json -Depth 5
+
+Set-Content -Path "$configDir/coc-settings.json" -Value $cocSettings
+
+# Write a tiny Vim script that will:
+#   1. Open the fixture file
+#   2. Wait for coc.nvim to attach the language server
+#   3. Check CocAction('diagnosticList') for expected diagnostics
+#   4. Write results to a file and quit
+$checkScript = @"
+" Wait for coc.nvim to be ready, then run checks.
+function! s:RunChecks(timer)
+    " Check if coc.nvim is running
+    try
+        let l:services = CocAction('services')
+    catch
+        " coc.nvim not ready yet, retry
+        call timer_start(1000, function('s:RunChecks'))
+        return
+    endtry
+
+    let l:result_file = '$($tmpBase.Replace("\", "/"))/result.txt'
+    let l:lines = []
+
+    " Check that the merls service is running
+    let l:found = 0
+    for l:svc in l:services
+        if l:svc.id =~# 'merls'
+            let l:found = 1
+            let l:state = l:svc.state
+            call add(l:lines, 'SERVICE: merls ' . l:state)
+        endif
+    endfor
+
+    if !l:found
+        call add(l:lines, 'SERVICE: merls NOT FOUND')
+        call writefile(l:lines, l:result_file)
+        qall!
+        return
+    endif
+
+    " Wait a moment for diagnostics to arrive, then collect them
+    call timer_start(2000, {-> s:CollectDiagnostics(l:lines, l:result_file)})
+endfunction
+
+function! s:CollectDiagnostics(lines, result_file)
+    try
+        let l:diags = CocAction('diagnosticList')
+        call add(a:lines, 'DIAGNOSTICS_COUNT: ' . len(l:diags))
+        for l:d in l:diags
+            call add(a:lines, 'DIAG: ' . l:d.severity . ' | ' . l:d.message)
+        endfor
+    catch
+        call add(a:lines, 'DIAGNOSTICS_ERROR: ' . v:exception)
+    endtry
+
+    call writefile(a:lines, a:result_file)
+    qall!
+endfunction
+
+" Start the check timer after a 3 second delay to let coc.nvim initialize
+call timer_start(3000, function('s:RunChecks'))
+"@
+
+Set-Content -Path "$smokeDir/check.vim" -Value $checkScript
+
+# Run Vim in headless mode
+Write-Host "Starting Vim headless smoke test..."
+$env:MERLS_SMOKE_CONFIG = $configDir
+$env:MERLS_SMOKE_DATA   = $dataDir
+
+$vimArgs = @(
+    "-u", "$smokeDir/vimrc",
+    "-N",              # nocompatible
+    "--not-a-term",    # headless
+    "-S", "$smokeDir/check.vim",
+    $fixture
+)
+
+$vimProcess = Start-Process -FilePath "vim" -ArgumentList $vimArgs `
+    -PassThru -NoNewWindow -Wait -ErrorAction Stop
+
+# Read results
+$resultFile = "$tmpBase/result.txt"
+if (-not (Test-Path $resultFile)) {
+    Write-Host "FAIL: Vim exited without writing results."
+    exit 1
+}
+
+$results = Get-Content $resultFile
+Write-Host ""
+Write-Host "=== Smoke test results ==="
+$results | ForEach-Object { Write-Host "  $_" }
+Write-Host ""
+
+# Validate
+$passed = $true
+
+# Check service was found and running
+$serviceLine = $results | Where-Object { $_ -match "^SERVICE:" }
+if ($serviceLine -match "running") {
+    Write-Host "PASS: merls language server is running in coc.nvim"
+} else {
+    Write-Host "FAIL: merls language server not running. Got: $serviceLine"
+    $passed = $false
+}
+
+# Check diagnostics were received
+$diagCountLine = $results | Where-Object { $_ -match "^DIAGNOSTICS_COUNT:" }
+if ($diagCountLine) {
+    $count = [int]($diagCountLine -replace "DIAGNOSTICS_COUNT:\s*", "")
+    if ($count -gt 0) {
+        Write-Host "PASS: received $count diagnostic(s) from merls"
+    } else {
+        Write-Host "FAIL: expected at least 1 diagnostic, got 0"
+        $passed = $false
+    }
+} else {
+    Write-Host "FAIL: no diagnostic count in results"
+    $passed = $false
+}
+
+# Cleanup
+Remove-Item -Recurse -Force $tmpBase -ErrorAction SilentlyContinue
+Remove-Item -Force "$smokeDir/check.vim" -ErrorAction SilentlyContinue
+
+if ($passed) {
+    Write-Host ""
+    Write-Host "Smoke test PASSED."
+    exit 0
+} else {
+    Write-Host ""
+    Write-Host "Smoke test FAILED."
+    exit 1
+}

package/test/smoke/vimrc

@@ -0,0 +1,17 @@
+" Minimal vimrc for the coc.nvim smoke test.
+" Loads only coc.nvim from the user's vim-plug directory,
+" configures the merls language server, and runs assertions.
+
+set nocompatible
+filetype off
+
+" Load coc.nvim from the user's vim-plug directory
+set runtimepath+=$USERPROFILE/vimfiles/local/plugged/coc.nvim
+
+filetype plugin indent on
+syntax on
+
+" Point coc.nvim at a temporary config directory so it does not
+" interfere with the user's real configuration.
+let g:coc_config_home = $MERLS_SMOKE_CONFIG
+let g:coc_data_home = $MERLS_SMOKE_DATA

package/test/symbols.test.ts

@@ -0,0 +1,41 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+
+import { parseDocument } from "../src/asm/document";
+import { collectSymbols } from "../src/asm/symbols";
+
+export function runSymbolsTest(): 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 symbols = collectSymbols(document);
+
+  assert.deepEqual(symbols.get("TEXT"), {
+    name: "TEXT",
+    kind: "equate",
+    line: 11
+  });
+
+  assert.deepEqual(symbols.get("TEST_START"), {
+    name: "TEST_START",
+    kind: "label",
+    line: 31
+  });
+
+  assert.deepEqual(symbols.get("dum0"), {
+    name: "dum0",
+    kind: "data",
+    line: 17
+  });
+
+  assert.deepEqual(symbols.get("_num1"), {
+    name: "_num1",
+    kind: "data",
+    line: 25
+  });
+}

package/test/syntax-shape.test.ts

@@ -0,0 +1,18 @@
+import assert from "node:assert/strict";
+
+import {
+  lineShapeTable,
+  tokenKindTable
+} from "../src/asm/syntax";
+
+export function runSyntaxShapeTest(): void {
+  assert.equal(tokenKindTable.get("comment")?.captureExamples[0], "; trailing note");
+  assert.equal(tokenKindTable.get("localLabel")?.captureExamples[0], "]loop");
+  assert.equal(tokenKindTable.get("modifier")?.captureExamples.includes("<value"), true);
+  assert.equal(tokenKindTable.has("expressionOperator"), true);
+
+  assert.equal(lineShapeTable.get("instruction")?.allowsLabel, true);
+  assert.equal(lineShapeTable.get("directive")?.requiresOperand, false);
+  assert.equal(lineShapeTable.get("equate")?.allowsExpression, true);
+  assert.equal(lineShapeTable.get("malformed")?.terminal, true);
+}

package/test/workspace-symbol.test.ts

@@ -0,0 +1,139 @@
+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);
+  }
+}
+
+export async function runWorkspaceSymbolTest(): Promise<void> {
+  const serverPath = path.resolve(__dirname, "../src/server.js");
+  const linkPath = path.resolve(
+    process.cwd(),
+    "test/fixtures/valid/merlin32-linkscript.asm"
+  );
+  const mainPath = path.resolve(
+    process.cwd(),
+    "test/fixtures/valid/merlin32-main-6502.asm"
+  );
+  const linkUri = `file://${linkPath.replace(/\\/g, "/")}`;
+  const mainUri = `file://${mainPath.replace(/\\/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: linkUri,
+        languageId: "asm",
+        version: 1,
+        text: fs.readFileSync(linkPath, "utf8")
+      }
+    });
+    sendNotification("textDocument/didOpen", {
+      textDocument: {
+        uri: mainUri,
+        languageId: "asm",
+        version: 1,
+        text: fs.readFileSync(mainPath, "utf8")
+      }
+    });
+
+    const response = await sendRequest("workspace/symbol", {
+      query: "Get"
+    });
+
+    const symbols = response.result as Array<{ name: string; location: { uri: string } }>;
+    assert.equal(Array.isArray(symbols), true);
+    assert.equal(symbols.some((symbol) => symbol.name === "GetKey" && symbol.location.uri === mainUri), true);
+  } finally {
+    child.kill();
+  }
+}

package/test/workspace.test.ts

@@ -0,0 +1,29 @@
+import assert from "node:assert/strict";
+import path from "node:path";
+
+import { indexWorkspace } from "../src/asm/workspace";
+
+export function runWorkspaceGraphTest(): void {
+  const entryPath = path.resolve(
+    process.cwd(),
+    "test/fixtures/valid/merlin32-linkscript.asm"
+  );
+  const mainPath = path.resolve(
+    process.cwd(),
+    "test/fixtures/valid/merlin32-main-6502.asm"
+  );
+
+  const workspace = indexWorkspace(entryPath);
+
+  assert.deepEqual(workspace.loadOrder, [entryPath, mainPath]);
+  assert.deepEqual(workspace.dependencies.get(entryPath), [mainPath]);
+  assert.equal(workspace.documents.has(entryPath), true);
+  assert.equal(workspace.documents.has(mainPath), true);
+
+  assert.deepEqual(workspace.symbols.get("TEXT"), {
+    name: "TEXT",
+    kind: "equate",
+    line: 11,
+    filePath: mainPath
+  });
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "CommonJS",
+    "moduleResolution": "Node",
+    "lib": ["ES2022"],
+    "rootDir": ".",
+    "outDir": "dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts", "test/**/*.ts"]
+}