smoke.mjs

import { spawn } from "node:child_process";

const doc = [
  "@echo off",
  "call :log hi",
  "goto :eof",
  "",
  ":log",
  "echo %~1",
  "exit /b 0",
].join("\n");
const uri = "file:///c:/tmp/sample.bat";

const server = spawn(process.execPath, [
  import.meta.dirname + "/dist/server.js",
  "--stdio",
]);

const send = (payload) => {
  const body = JSON.stringify({ jsonrpc: "2.0", ...payload });
  server.stdin.write(
    "Content-Length: " + Buffer.byteLength(body) + "\r\n\r\n" + body,
  );
};

let buffer = "";
const responses = new Map();

server.stdout.on("data", (chunk) => {
  buffer += chunk.toString();

  while (true) {
    const headerEnd = buffer.indexOf("\r\n\r\n");
    if (headerEnd < 0) return;

    const length = Number(
      buffer.slice(0, headerEnd).split("Content-Length:")[1].trim(),
    );
    const start = headerEnd + 4;
    if (buffer.length < start + length) return;

    const message = JSON.parse(buffer.slice(start, start + length));
    buffer = buffer.slice(start + length);
    if (message.id !== undefined) responses.set(message.id, message);
  }
});

const waitFor = (id) =>
  new Promise((resolve, reject) => {
    const timer = setInterval(() => {
      if (responses.has(id)) {
        clearInterval(timer);
        resolve(responses.get(id));
      }
    }, 20);
    setTimeout(() => {
      clearInterval(timer);
      reject(new Error("timeout waiting for response " + id));
    }, 8000);
  });

const assert = (condition, message) => {
  if (!condition) {
    console.error("FAIL " + message);
    server.kill();
    process.exit(1);
  }
  console.log("ok   " + message);
};

(async () => {
  send({
    id: 1,
    method: "initialize",
    params: { processId: null, rootUri: null, capabilities: {} },
  });
  const initialized = await waitFor(1);
  const capabilities = initialized.result.capabilities;

  assert(capabilities.definitionProvider, "definitionProvider advertised");
  assert(capabilities.referencesProvider, "referencesProvider advertised");
  assert(capabilities.renameProvider, "renameProvider advertised");

  send({ method: "initialized", params: {} });
  send({
    method: "textDocument/didOpen",
    params: { textDocument: { uri, languageId: "bat", version: 1, text: doc } },
  });

  send({
    id: 2,
    method: "textDocument/definition",
    params: { textDocument: { uri }, position: { line: 1, character: 7 } },
  });
  const definition = await waitFor(2);

  assert(definition.result, "definition returned for call :log");
  assert(
    definition.result.range.start.line === 4,
    "definition points at line 4, got " + definition.result.range.start.line,
  );

  send({
    id: 3,
    method: "textDocument/references",
    params: {
      textDocument: { uri },
      position: { line: 1, character: 7 },
      context: { includeDeclaration: true },
    },
  });
  const references = await waitFor(3);

  assert(
    references.result.length >= 2,
    "found " + references.result.length + " references",
  );

  server.kill();
})().catch((error) => {
  console.error("FAIL " + error.message);
  server.kill();
  process.exit(1);
});