@razdolbai/merls 0.1.0

package/src/lsp/diagnostics.ts

@@ -0,0 +1,82 @@
+import { fileURLToPath } from "node:url";
+
+import {
+  DiagnosticSeverity,
+  type Diagnostic as LspDiagnostic
+} from "vscode-languageserver/node";
+
+import { parseDocument } from "../asm/document";
+import {
+  collectWorkspaceDiagnostics,
+  type Diagnostic as AsmDiagnostic,
+  type DocumentEntry
+} from "../asm/diagnostics";
+
+export function collectDiagnosticsByUri(
+  openDocuments: ReadonlyMap<string, string>
+): Map<string, readonly LspDiagnostic[]> {
+  const sourcesByFilePath = new Map<string, string>();
+  const uriByFilePath = new Map<string, string>();
+  const entries: DocumentEntry[] = [];
+
+  for (const [uri, source] of openDocuments.entries()) {
+    const filePath = uriToFilePath(uri);
+    sourcesByFilePath.set(filePath, source);
+    uriByFilePath.set(filePath, uri);
+    entries.push({
+      filePath,
+      document: parseDocument(source)
+    });
+  }
+
+  const diagnosticsByFilePath = new Map<string, LspDiagnostic[]>();
+  for (const entry of entries) {
+    diagnosticsByFilePath.set(entry.filePath, []);
+  }
+
+  for (const diagnostic of collectWorkspaceDiagnostics(entries)) {
+    const source = sourcesByFilePath.get(diagnostic.filePath);
+    const diagnostics = diagnosticsByFilePath.get(diagnostic.filePath);
+    if (source === undefined || diagnostics === undefined) {
+      continue;
+    }
+
+    diagnostics.push(toLspDiagnostic(source, diagnostic));
+  }
+
+  const diagnosticsByUri = new Map<string, readonly LspDiagnostic[]>();
+  for (const [filePath, uri] of uriByFilePath.entries()) {
+    diagnosticsByUri.set(uri, diagnosticsByFilePath.get(filePath) ?? []);
+  }
+
+  return diagnosticsByUri;
+}
+
+function toLspDiagnostic(source: string, diagnostic: AsmDiagnostic): LspDiagnostic {
+  const lineText = source.split(/\r?\n/)[diagnostic.line] ?? "";
+
+  return {
+    severity: DiagnosticSeverity.Error,
+    message: diagnostic.message,
+    source: "merls",
+    code: diagnostic.code,
+    range: {
+      start: {
+        line: diagnostic.line,
+        character: 0
+      },
+      end: {
+        line: diagnostic.line,
+        character: lineText.length
+      }
+    }
+  };
+}
+
+function uriToFilePath(uri: string): string {
+  if (uri.startsWith("file://")) {
+    return fileURLToPath(uri);
+  }
+
+  return uri;
+}

package/src/lsp/document-symbols.ts

@@ -0,0 +1,111 @@
+import {
+  type Location,
+  type Range,
+  type SymbolInformation,
+  SymbolKind
+} from "vscode-languageserver/node";
+
+import { parseDocument } from "../asm/document";
+import { type ParsedLine } from "../asm/parser";
+
+export function buildDocumentSymbols(
+  uri: string,
+  source: string
+): SymbolInformation[] {
+  const document = parseDocument(source);
+  const symbols: SymbolInformation[] = [];
+
+  for (const line of document.lines) {
+    const symbol = toSymbolInformation(uri, line.node, line.line);
+    if (symbol !== null) {
+      symbols.push(symbol);
+    }
+  }
+
+  return symbols;
+}
+
+function toSymbolInformation(
+  uri: string,
+  node: ParsedLine,
+  line: number
+): SymbolInformation | null {
+  const name = getNodeName(node);
+  const kind = getNodeKind(node);
+
+  if (name === null || kind === null) {
+    return null;
+  }
+
+  return {
+    name,
+    kind,
+    location: createLocation(uri, line, name)
+  };
+}
+
+function getNodeName(node: ParsedLine): string | null {
+  if (node.shape === "equate") {
+    return node.label;
+  }
+
+  if (node.shape === "labelOnly") {
+    return node.label;
+  }
+
+  if (node.shape === "instruction" && node.label !== null) {
+    return node.label;
+  }
+
+  if (node.shape === "directive" && node.label !== null) {
+    return node.label;
+  }
+
+  if (node.shape === "data" && node.label !== null) {
+    return node.label;
+  }
+
+  return null;
+}
+
+function getNodeKind(node: ParsedLine): SymbolKind | null {
+  if (node.shape === "equate") {
+    return SymbolKind.Variable;
+  }
+
+  if (node.shape === "labelOnly") {
+    return SymbolKind.Method;
+  }
+
+  if (node.shape === "instruction" && node.label !== null) {
+    return SymbolKind.Method;
+  }
+
+  if (node.shape === "directive" && node.label !== null) {
+    return SymbolKind.Field;
+  }
+
+  if (node.shape === "data" && node.label !== null) {
+    return SymbolKind.Field;
+  }
+
+  return null;
+}
+
+function createLocation(uri: string, line: number, name: string): Location {
+  const range: Range = {
+    start: {
+      line,
+      character: 0
+    },
+    end: {
+      line,
+      character: name.length
+    }
+  };
+
+  return {
+    uri,
+    range
+  };
+}

package/src/lsp/hover.ts

@@ -0,0 +1,90 @@
+import { type Hover } from "vscode-languageserver/node";
+
+import { directiveTable, opcodeTable } from "../asm/metadata";
+import { parseDocument } from "../asm/document";
+import { lexSource, type Token } from "../asm/lexer";
+import { findDefinition } from "./symbol-navigation";
+
+export function buildHover(
+  openDocuments: ReadonlyMap<string, string>,
+  uri: string,
+  line: number,
+  character: number
+): Hover | null {
+  const source = openDocuments.get(uri);
+  if (source === undefined) {
+    return null;
+  }
+
+  const documentLine = parseDocument(source).lines[line];
+  const lexedLine = lexSource(source).lines[line];
+  if (documentLine === undefined || lexedLine === undefined) {
+    return null;
+  }
+
+  const token = tokenAtCharacter(lexedLine.tokens, character);
+  if (token?.kind === "mnemonic") {
+    const definition = opcodeTable.get(token.lexeme.toLowerCase());
+    if (definition !== undefined) {
+      return {
+        contents: `Opcode ${definition.mnemonic}: ${definition.modes.join(", ")}`
+      };
+    }
+  }
+
+  if (token?.kind === "directive") {
+    const definition = directiveTable.get(token.lexeme.toLowerCase());
+    if (definition !== undefined) {
+      return {
+        contents: `Directive ${definition.name}: ${definition.summary}`
+      };
+    }
+  }
+
+  if (token?.kind === "identifier" || token?.kind === "label" || token?.kind === "localLabel") {
+    const lexemeLower = token.lexeme.toLowerCase();
+    if (lexemeLower === "a" || lexemeLower === "x" || lexemeLower === "y") {
+      return {
+        contents: `Register ${token.lexeme.toUpperCase()}`
+      };
+    }
+
+    const definition = findDefinition(openDocuments, uri, line);
+    if (definition !== null) {
+      return {
+        contents: `Symbol ${token.lexeme} defined at line ${definition.range.start.line}`
+      };
+    }
+  }
+
+  const node = documentLine.node;
+  if (node.shape === "instruction") {
+    const definition = opcodeTable.get(node.mnemonic);
+    if (definition !== undefined) {
+      return {
+        contents: `Opcode ${definition.mnemonic}: ${definition.modes.join(", ")}`
+      };
+    }
+  }
+
+  if (node.shape === "directive") {
+    const definition = directiveTable.get(node.directive);
+    if (definition !== undefined) {
+      return {
+        contents: `Directive ${definition.name}: ${definition.summary}`
+      };
+    }
+  }
+
+  return null;
+}
+
+function tokenAtCharacter(tokens: readonly Token[], character: number): Token | null {
+  for (const token of tokens) {
+    if (character >= token.start && character < token.end) {
+      return token;
+    }
+  }
+
+  return null;
+}

package/src/lsp/symbol-navigation.ts

@@ -0,0 +1,244 @@
+import { type Location } from "vscode-languageserver/node";
+
+import { parseDocument } from "../asm/document";
+import { type Expression, type Operand } from "../asm/expression";
+import { type ParsedLine } from "../asm/parser";
+
+type SymbolDefinition = {
+  name: string;
+  location: Location;
+};
+
+type SymbolReference = {
+  name: string;
+  location: Location;
+};
+
+export function findDefinition(
+  openDocuments: ReadonlyMap<string, string>,
+  uri: string,
+  line: number
+): Location | null {
+  const targetName = getSymbolAtLine(openDocuments.get(uri), line);
+  if (targetName === null) {
+    return null;
+  }
+
+  for (const [documentUri, source] of openDocuments.entries()) {
+    for (const definition of collectDefinitions(documentUri, source)) {
+      if (definition.name === targetName) {
+        return definition.location;
+      }
+    }
+  }
+
+  return null;
+}
+
+export function findReferences(
+  openDocuments: ReadonlyMap<string, string>,
+  uri: string,
+  line: number,
+  includeDeclaration: boolean
+): Location[] {
+  const targetName = getSymbolAtLine(openDocuments.get(uri), line);
+  if (targetName === null) {
+    return [];
+  }
+
+  const locations: Location[] = [];
+
+  for (const [documentUri, source] of openDocuments.entries()) {
+    if (includeDeclaration) {
+      for (const definition of collectDefinitions(documentUri, source)) {
+        if (definition.name === targetName) {
+          locations.push(definition.location);
+        }
+      }
+    }
+
+    for (const reference of collectReferences(documentUri, source)) {
+      if (reference.name === targetName) {
+        locations.push(reference.location);
+      }
+    }
+  }
+
+  return locations;
+}
+
+function getSymbolAtLine(source: string | undefined, line: number): string | null {
+  if (source === undefined) {
+    return null;
+  }
+
+  const node = parseDocument(source).lines[line]?.node;
+  if (node === undefined) {
+    return null;
+  }
+
+  if (node.shape === "labelOnly") {
+    return node.label;
+  }
+
+  if (node.shape === "instruction") {
+    if (node.label !== null) {
+      return node.label;
+    }
+
+    return readOperandIdentifier(node.operand);
+  }
+
+  if (node.shape === "directive") {
+    if (node.label !== null) {
+      return node.label;
+    }
+
+    return readExpressionIdentifier(node.operand);
+  }
+
+  if (node.shape === "equate") {
+    return node.label;
+  }
+
+  if (node.shape === "data" && node.label !== null) {
+    return node.label;
+  }
+
+  return null;
+}
+
+function collectDefinitions(uri: string, source: string): readonly SymbolDefinition[] {
+  const document = parseDocument(source);
+  const definitions: SymbolDefinition[] = [];
+
+  for (const line of document.lines) {
+    const name = getDefinedName(line.node);
+    if (name === null) {
+      continue;
+    }
+
+    definitions.push({
+      name,
+      location: createLocation(uri, line.line, name)
+    });
+  }
+
+  return definitions;
+}
+
+function collectReferences(uri: string, source: string): readonly SymbolReference[] {
+  const document = parseDocument(source);
+  const references: SymbolReference[] = [];
+
+  for (const line of document.lines) {
+    for (const name of getReferencedNames(line.node)) {
+      references.push({
+        name,
+        location: createLocation(uri, line.line, name)
+      });
+    }
+  }
+
+  return references;
+}
+
+function getDefinedName(node: ParsedLine): string | null {
+  if (node.shape === "equate") {
+    return node.label;
+  }
+
+  if (node.shape === "labelOnly") {
+    return node.label;
+  }
+
+  if (node.shape === "instruction" && node.label !== null) {
+    return node.label;
+  }
+
+  if (node.shape === "directive" && node.label !== null) {
+    return node.label;
+  }
+
+  if (node.shape === "data" && node.label !== null) {
+    return node.label;
+  }
+
+  return null;
+}
+
+function getReferencedNames(node: ParsedLine): readonly string[] {
+  if (node.shape === "instruction" && node.operand !== null) {
+    return collectExpressionIdentifiers(node.operand.expression);
+  }
+
+  if (node.shape === "directive" && node.operand !== null) {
+    return collectExpressionIdentifiers(node.operand);
+  }
+
+  if (node.shape === "equate") {
+    return collectExpressionIdentifiers(node.expression);
+  }
+
+  return [];
+}
+
+function readOperandIdentifier(operand: Operand | null): string | null {
+  if (operand === null) {
+    return null;
+  }
+
+  return readExpressionIdentifier(operand.expression);
+}
+
+function readExpressionIdentifier(expression: Expression | null): string | null {
+  if (expression === null) {
+    return null;
+  }
+
+  if (expression.kind === "identifier") {
+    return expression.value;
+  }
+
+  if (expression.kind === "modifier") {
+    return readExpressionIdentifier(expression.expression);
+  }
+
+  if (expression.kind === "binary") {
+    return readExpressionIdentifier(expression.left);
+  }
+
+  return null;
+}
+
+function collectExpressionIdentifiers(expression: Expression): readonly string[] {
+  switch (expression.kind) {
+    case "identifier":
+      return [expression.value];
+    case "modifier":
+      return collectExpressionIdentifiers(expression.expression);
+    case "binary":
+      return [
+        ...collectExpressionIdentifiers(expression.left),
+        ...collectExpressionIdentifiers(expression.right)
+      ];
+    default:
+      return [];
+  }
+}
+
+function createLocation(uri: string, line: number, name: string): Location {
+  return {
+    uri,
+    range: {
+      start: {
+        line,
+        character: 0
+      },
+      end: {
+        line,
+        character: name.length
+      }
+    }
+  };
+}

package/src/lsp/workspace-symbols.ts

@@ -0,0 +1,24 @@
+import { type SymbolInformation } from "vscode-languageserver/node";
+
+import { buildDocumentSymbols } from "./document-symbols";
+
+export function buildWorkspaceSymbols(
+  openDocuments: ReadonlyMap<string, string>,
+  query: string
+): SymbolInformation[] {
+  const normalizedQuery = query.trim().toLowerCase();
+  const symbols: SymbolInformation[] = [];
+
+  for (const [uri, source] of openDocuments.entries()) {
+    for (const symbol of buildDocumentSymbols(uri, source)) {
+      if (
+        normalizedQuery.length === 0 ||
+        symbol.name.toLowerCase().includes(normalizedQuery)
+      ) {
+        symbols.push(symbol);
+      }
+    }
+  }
+
+  return symbols;
+}

package/src/server.ts

@@ -0,0 +1,121 @@
+import {
+  Connection,
+  ProposedFeatures,
+  TextDocumentSyncKind,
+  createConnection
+} from "vscode-languageserver/node";
+
+import { buildDocumentSymbols } from "./lsp/document-symbols";
+import { buildCompletionItems } from "./lsp/completion";
+import { collectDiagnosticsByUri } from "./lsp/diagnostics";
+import { buildHover } from "./lsp/hover";
+import { findDefinition, findReferences } from "./lsp/symbol-navigation";
+import { buildWorkspaceSymbols } from "./lsp/workspace-symbols";
+
+export function createServerConnection(
+  inputStream: NodeJS.ReadableStream = process.stdin,
+  outputStream: NodeJS.WritableStream = process.stdout
+): Connection {
+  return createConnection(ProposedFeatures.all, inputStream, outputStream);
+}
+
+export function startServer(
+  inputStream: NodeJS.ReadableStream = process.stdin,
+  outputStream: NodeJS.WritableStream = process.stdout
+): Connection {
+  const connection = createServerConnection(inputStream, outputStream);
+  const openDocuments = new Map<string, string>();
+
+  connection.onInitialize(() => ({
+    capabilities: {
+      completionProvider: {},
+      definitionProvider: true,
+      documentSymbolProvider: true,
+      hoverProvider: true,
+      referencesProvider: true,
+      workspaceSymbolProvider: true,
+      textDocumentSync: {
+        openClose: true,
+        change: TextDocumentSyncKind.Full
+      }
+    }
+  }));
+  connection.onDidOpenTextDocument((params) => {
+    openDocuments.set(params.textDocument.uri, params.textDocument.text);
+    publishDiagnostics();
+  });
+  connection.onDidChangeTextDocument((params) => {
+    const nextText = params.contentChanges.at(-1)?.text;
+    if (nextText === undefined) {
+      return;
+    }
+
+    openDocuments.set(params.textDocument.uri, nextText);
+    publishDiagnostics();
+  });
+  connection.onDidCloseTextDocument((params) => {
+    openDocuments.delete(params.textDocument.uri);
+    connection.sendDiagnostics({
+      uri: params.textDocument.uri,
+      diagnostics: []
+    });
+    publishDiagnostics();
+  });
+  connection.onDocumentSymbol((params) => {
+    const source = openDocuments.get(params.textDocument.uri);
+    if (source === undefined) {
+      return [];
+    }
+
+    return buildDocumentSymbols(params.textDocument.uri, source);
+  });
+  connection.onWorkspaceSymbol((params) =>
+    buildWorkspaceSymbols(openDocuments, params.query)
+  );
+  connection.onDefinition((params) =>
+    findDefinition(
+      openDocuments,
+      params.textDocument.uri,
+      params.position.line
+    )
+  );
+  connection.onReferences((params) =>
+    findReferences(
+      openDocuments,
+      params.textDocument.uri,
+      params.position.line,
+      params.context.includeDeclaration
+    )
+  );
+  connection.onHover((params) =>
+    buildHover(
+      openDocuments,
+      params.textDocument.uri,
+      params.position.line,
+      params.position.character
+    )
+  );
+  connection.onCompletion((params) =>
+    buildCompletionItems(
+      openDocuments,
+      params.textDocument.uri,
+      params.position.line
+    )
+  );
+
+  function publishDiagnostics(): void {
+    for (const [uri, diagnostics] of collectDiagnosticsByUri(openDocuments).entries()) {
+      connection.sendDiagnostics({
+        uri,
+        diagnostics: [...diagnostics]
+      });
+    }
+  }
+
+  connection.listen();
+  return connection;
+}
+
+if (require.main === module) {
+  startServer();
+}

package/test/bootstrap.test.ts

@@ -0,0 +1,7 @@
+import assert from "node:assert/strict";
+
+import { projectName } from "../src/index";
+
+export function runBootstrapTest(): void {
+  assert.equal(projectName, "merls");
+}