@tsuzuri-lab/sed-language-server 0.2.0 → 0.3.1

package/README.md

@@ -22,6 +22,7 @@ sed-language-server --stdio
 
 - Tree-sitter-based diagnostics
 - go to definition from `b`, `t`, and GNU `T` label references
+- document formatting for command lists and nested blocks
 
 Scripts are analyzed without executing them or accessing referenced files.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tsuzuri-lab/sed-language-server",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Language server for POSIX sed with opt-in GNU syntax support.",
   "keywords": [
     "sed",

package/src/definition.js

@@ -0,0 +1,35 @@
+import { rangeForNode, syntaxTreeFor } from "./syntax.js";
+
+function labelReferenceAt(rootNode, offset) {
+  let node = rootNode.namedDescendantForIndex(offset);
+  while (node !== null) {
+    if (
+      node.type === "label_reference" &&
+      node.startIndex <= offset &&
+      offset < node.endIndex
+    ) {
+      return node;
+    }
+    node = node.parent;
+  }
+  return undefined;
+}
+
+export function createDefinitionLocations(document, position, dialect) {
+  const rootNode = syntaxTreeFor(document, dialect).rootNode;
+  const reference = labelReferenceAt(rootNode, document.offsetAt(position));
+
+  if (reference === undefined) {
+    return null;
+  }
+
+  const locations = rootNode
+    .descendantsOfType("label_definition")
+    .filter((definition) => definition.text === reference.text)
+    .map((definition) => ({
+      uri: document.uri,
+      range: rangeForNode(document, definition),
+    }));
+
+  return locations.length === 0 ? null : locations;
+}

package/src/diagnostics.js

@@ -0,0 +1,189 @@
+import { DiagnosticSeverity } from "vscode-languageserver/node";
+import {
+  collectSyntaxIssueNodes,
+  rangeForNode,
+  syntaxTreeFor,
+} from "./syntax.js";
+
+const diagnosticSource = "sed-language-server";
+
+const issueDescriptions = {
+  incomplete_escape: {
+    code: "incomplete-escape",
+    message: "This escape sequence is incomplete.",
+  },
+  incomplete_regex: {
+    code: "unterminated-regular-expression",
+    message: "This regular expression is not terminated.",
+  },
+  incomplete_replacement: {
+    code: "unterminated-replacement",
+    message: "This replacement is not terminated.",
+  },
+  incomplete_translate: {
+    code: "unterminated-translation",
+    message: "This translation is not terminated.",
+  },
+  invalid_control_escape: {
+    code: "invalid-control-escape",
+    message: "This GNU sed control escape is invalid.",
+  },
+  unclosed_bracket: {
+    code: "unclosed-bracket-expression",
+    message: "This bracket expression is not terminated.",
+  },
+  invalid_command: (node, dialect) => ({
+    code: "invalid-command",
+    message: `Unknown ${dialectName(dialect)} sed command: \`${node.text}\`.`,
+  }),
+  invalid_flag: (node, dialect) => ({
+    code: "invalid-substitution-flag",
+    message: `Unknown ${dialectName(dialect)} sed substitution flag: \`${node.text}\`.`,
+  }),
+  invalid_flags: (node, dialect) => ({
+    code: "invalid-substitution-flag",
+    message: `The ${dialectName(dialect)} sed substitution flags \`${node.text}\` contain invalid characters.`,
+  }),
+  unexpected_text: (_node, dialect) => ({
+    code: "unexpected-text",
+    message: `Unexpected text after this ${dialectName(dialect)} sed command.`,
+  }),
+};
+
+function dialectName(dialect) {
+  return dialect === "gnu" ? "GNU" : "POSIX";
+}
+
+function descriptionFor(node, dialect) {
+  const description = issueDescriptions[node.type];
+  if (typeof description === "function") {
+    return description(node, dialect);
+  }
+  if (description !== undefined) {
+    return description;
+  }
+
+  if (node.isMissing) {
+    return {
+      code: "missing-syntax",
+      message: `Expected ${node.type.replaceAll("_", " ")}.`,
+    };
+  }
+
+  return {
+    code: "syntax-error",
+    message: `Invalid ${dialectName(dialect)} sed syntax.`,
+  };
+}
+
+function issueSpecificity(node) {
+  if (node.isError) {
+    return 0;
+  }
+  if (node.isMissing) {
+    return 1;
+  }
+  return 2;
+}
+
+function compareIssueRanges(left, right) {
+  return left.startIndex - right.startIndex || left.endIndex - right.endIndex;
+}
+
+function preferSpecificIssues(nodes) {
+  const issuesByRange = new Map();
+
+  for (const node of nodes) {
+    const key = `${node.startIndex}:${node.endIndex}`;
+    const existing = issuesByRange.get(key);
+    if (
+      existing === undefined ||
+      issueSpecificity(node) > issueSpecificity(existing)
+    ) {
+      issuesByRange.set(key, node);
+    }
+  }
+
+  return [...issuesByRange.values()].sort(compareIssueRanges);
+}
+
+function collapseInvalidFlags(nodes) {
+  const groupedByParent = new Map();
+  const issues = [];
+
+  for (const node of nodes) {
+    const parent = node.parent;
+    if (node.type !== "invalid_flag" || parent?.type !== "substitute_flags") {
+      issues.push(node);
+      continue;
+    }
+
+    const key = `${parent.startIndex}:${parent.endIndex}`;
+    const group = groupedByParent.get(key);
+    if (group === undefined) {
+      groupedByParent.set(key, [node]);
+    } else {
+      group.push(node);
+    }
+  }
+
+  for (const invalidFlags of groupedByParent.values()) {
+    if (invalidFlags.length === 1) {
+      issues.push(invalidFlags[0]);
+      continue;
+    }
+
+    const first = invalidFlags[0];
+    const last = invalidFlags.at(-1);
+    issues.push({
+      type: "invalid_flags",
+      startIndex: first.startIndex,
+      endIndex: last.endIndex,
+      text: first.parent.text,
+    });
+  }
+
+  return issues.sort(compareIssueRanges);
+}
+
+function mergeAdjacentIssues(nodes) {
+  const merged = [];
+
+  for (const node of nodes) {
+    const previous = merged.at(-1);
+    if (previous === undefined || node.startIndex > previous.endIndex) {
+      merged.push(node);
+      continue;
+    }
+
+    merged[merged.length - 1] = {
+      type: previous.type,
+      text: previous.text,
+      isMissing: previous.isMissing,
+      startIndex: previous.startIndex,
+      endIndex: Math.max(previous.endIndex, node.endIndex),
+    };
+  }
+
+  return merged;
+}
+
+function normalizeIssues(nodes) {
+  return mergeAdjacentIssues(collapseInvalidFlags(preferSpecificIssues(nodes)));
+}
+
+export function createDiagnostics(document, dialect) {
+  const rootNode = syntaxTreeFor(document, dialect).rootNode;
+  const issueNodes = normalizeIssues(collectSyntaxIssueNodes(rootNode));
+
+  return issueNodes.map((node) => {
+    const { code, message } = descriptionFor(node, dialect);
+    return {
+      severity: DiagnosticSeverity.Error,
+      range: rangeForNode(document, node),
+      message,
+      code,
+      source: diagnosticSource,
+    };
+  });
+}

package/src/formatting.js

@@ -0,0 +1,100 @@
+import { collectSyntaxIssueNodes, syntaxTreeFor } from "./syntax.js";
+
+function formatCommandList(node, indentation, lineEnding, depth) {
+  return node.children
+    .filter((child) => child.type === "command")
+    .map((command) => formatCommand(command, indentation, lineEnding, depth))
+    .join(lineEnding);
+}
+
+function formatCommand(command, indentation, lineEnding, depth) {
+  const prefix = indentation.repeat(depth);
+  const body = command.childForFieldName("body");
+  if (body.type !== "block_command") {
+    return `${prefix}${command.text}`;
+  }
+
+  const openingBrace = body.childForFieldName("name");
+  const opening = command.text.slice(
+    0,
+    openingBrace.endIndex - command.startIndex,
+  );
+  const commandList = body.childForFieldName("argument");
+  if (commandList === null) {
+    return `${prefix}${opening}}`;
+  }
+
+  const formattedCommands = formatCommandList(
+    commandList,
+    indentation,
+    lineEnding,
+    depth + 1,
+  );
+  const content =
+    formattedCommands === "" ? "" : `${formattedCommands}${lineEnding}`;
+
+  return `${prefix}${opening}${lineEnding}${content}${prefix}}`;
+}
+
+function indentationFor(options) {
+  return options.insertSpaces ? " ".repeat(options.tabSize) : "\t";
+}
+
+function formatScript(rootNode, source, options) {
+  const lineEnding = source.match(/\r\n|\n/)?.[0] ?? "\n";
+  const indentation = indentationFor(options);
+  const firstLine = rootNode.children.find(
+    (child) => child.type === "first_line_silent",
+  );
+  const commandList = rootNode.children.find(
+    (child) => child.type === "command_list",
+  );
+  const sections = [];
+
+  if (firstLine !== undefined) {
+    sections.push(firstLine.text);
+  }
+  if (commandList !== undefined) {
+    const formattedCommands = formatCommandList(
+      commandList,
+      indentation,
+      lineEnding,
+      0,
+    );
+    if (formattedCommands !== "") {
+      sections.push(formattedCommands);
+    }
+  }
+
+  let formatted = sections.join(lineEnding);
+  if (source.endsWith("\n") && !formatted.endsWith("\n")) {
+    formatted += lineEnding;
+  }
+  return formatted;
+}
+
+export function createFormattingEdits(document, dialect, options) {
+  const source = document.getText();
+  const rootNode = syntaxTreeFor(document, dialect).rootNode;
+  if (rootNode.hasError || collectSyntaxIssueNodes(rootNode).length > 0) {
+    return [];
+  }
+
+  const formatted = formatScript(rootNode, source, options);
+  if (!source.startsWith("#n") && formatted.startsWith("#n")) {
+    return [];
+  }
+  if (formatted === source) {
+    return [];
+  }
+
+  return [
+    {
+      range: {
+        start: document.positionAt(0),
+        end: document.positionAt(source.length),
+      },
+      newText: formatted,
+    },
+  ];
+}

package/src/server.js

@@ -3,19 +3,16 @@
 import {
   createConnection,
   ErrorCodes,
-  MessageType,
   ProposedFeatures,
   ResponseError,
-  ShowMessageNotification,
   TextDocumentSyncKind,
   TextDocuments,
 } from "vscode-languageserver/node";
 import { TextDocument } from "vscode-languageserver-textdocument";
-import {
-  createDefinitionLocations,
-  createDiagnostics,
-  invalidateSyntaxTreeCache,
-} from "./analysis.js";
+import { createDefinitionLocations } from "./definition.js";
+import { createDiagnostics } from "./diagnostics.js";
+import { createFormattingEdits } from "./formatting.js";
+import { invalidateSyntaxTreeCache } from "./syntax.js";
 
 if (process.argv.length === 2) {
   process.argv.push("--stdio");
@@ -47,19 +44,6 @@ function resolveDialect(options) {
   return { dialect };
 }
 
-function configurationOptions(settings) {
-  if (
-    settings !== null &&
-    typeof settings === "object" &&
-    !Array.isArray(settings) &&
-    Object.hasOwn(settings, "sedLanguageServer")
-  ) {
-    return settings.sedLanguageServer;
-  }
-
-  return settings;
-}
-
 function publishDiagnostics(document) {
   return connection.sendDiagnostics({
     uri: document.uri,
@@ -81,26 +65,11 @@ connection.onInitialize(({ initializationOptions }) => {
     capabilities: {
       textDocumentSync: TextDocumentSyncKind.Incremental,
       definitionProvider: true,
+      documentFormattingProvider: true,
     },
   };
 });
 
-connection.onDidChangeConfiguration(async ({ settings }) => {
-  const result = resolveDialect(configurationOptions(settings));
-  if (result.error !== undefined) {
-    connection.sendNotification(ShowMessageNotification.type, {
-      type: MessageType.Error,
-      message: result.error,
-    });
-    return;
-  }
-
-  activeDialect = result.dialect;
-  await Promise.all(
-    documents.all().map((document) => publishDiagnostics(document)),
-  );
-});
-
 connection.onDefinition(({ textDocument, position }) => {
   const document = documents.get(textDocument.uri);
   return document === undefined
@@ -108,6 +77,13 @@ connection.onDefinition(({ textDocument, position }) => {
     : createDefinitionLocations(document, position, activeDialect);
 });
 
+connection.onDocumentFormatting(({ textDocument, options }) => {
+  const document = documents.get(textDocument.uri);
+  return document === undefined
+    ? []
+    : createFormattingEdits(document, activeDialect, options);
+});
+
 documents.onDidChangeContent(({ document }) => {
   publishDiagnostics(document);
 });

package/src/syntax.js

@@ -0,0 +1,124 @@
+import { fileURLToPath } from "node:url";
+import { Language, Parser } from "web-tree-sitter";
+
+await Parser.init();
+
+async function createParser(dialect) {
+  const path = fileURLToPath(
+    new URL(`../vendor/tree-sitter-sed-${dialect}.wasm`, import.meta.url),
+  );
+  return new Parser().setLanguage(await Language.load(path));
+}
+
+const parsers = {
+  posix: await createParser("posix"),
+  gnu: await createParser("gnu"),
+};
+
+const documentTrees = new Map();
+
+export function syntaxTreeFor(document, dialect) {
+  const source = document.getText();
+  let trees = documentTrees.get(document.uri);
+
+  if (trees === undefined) {
+    trees = new Map();
+    documentTrees.set(document.uri, trees);
+  }
+
+  const cached = trees.get(dialect);
+  if (
+    cached !== undefined &&
+    cached.version === document.version &&
+    cached.source === source
+  ) {
+    return cached.tree;
+  }
+
+  cached?.tree.delete();
+  const tree = parsers[dialect].parse(source);
+  if (tree === null) {
+    throw new Error(`Failed to parse ${dialect} sed source.`);
+  }
+
+  trees.set(dialect, {
+    source,
+    tree,
+    version: document.version,
+  });
+  return tree;
+}
+
+export function invalidateSyntaxTreeCache(document) {
+  const trees = documentTrees.get(document.uri);
+  if (trees !== undefined) {
+    for (const { tree } of trees.values()) {
+      tree.delete();
+    }
+    documentTrees.delete(document.uri);
+  }
+}
+
+function isSpecificSyntaxIssue(node) {
+  return (
+    node.isMissing ||
+    node.type.startsWith("incomplete_") ||
+    node.type.startsWith("invalid_") ||
+    node.type === "unclosed_bracket" ||
+    node.type === "unexpected_text"
+  );
+}
+
+export function collectSyntaxIssueNodes(rootNode) {
+  const issues = [];
+  const stack = [
+    {
+      node: rootNode,
+      children: rootNode.children,
+      childIndex: 0,
+      hasDescendantIssue: false,
+      issueStartIndex: 0,
+    },
+  ];
+
+  while (stack.length > 0) {
+    const frame = stack.at(-1);
+    if (frame.childIndex < frame.children.length) {
+      const child = frame.children[frame.childIndex];
+      frame.childIndex += 1;
+      stack.push({
+        node: child,
+        children: child.children,
+        childIndex: 0,
+        hasDescendantIssue: false,
+        issueStartIndex: issues.length,
+      });
+      continue;
+    }
+
+    const specific = isSpecificSyntaxIssue(frame.node);
+    const selected =
+      specific || (frame.node.hasError && !frame.hasDescendantIssue);
+    if (specific) {
+      issues.length = frame.issueStartIndex;
+    }
+    if (selected) {
+      issues.push(frame.node);
+    }
+
+    stack.pop();
+    const parent = stack.at(-1);
+    if (parent !== undefined) {
+      parent.hasDescendantIssue ||= frame.hasDescendantIssue || selected;
+    }
+  }
+
+  return issues;
+}
+
+export function rangeForNode(document, node) {
+  return {
+    start: document.positionAt(node.startIndex),
+    end: document.positionAt(node.endIndex),
+  };
+}

package/src/analysis.js

@@ -1,275 +0,0 @@
-import { fileURLToPath } from "node:url";
-import { DiagnosticSeverity } from "vscode-languageserver/node";
-import { Language, Parser } from "web-tree-sitter";
-
-await Parser.init();
-
-async function createParser(dialect) {
-  const path = fileURLToPath(
-    new URL(`../vendor/tree-sitter-sed-${dialect}.wasm`, import.meta.url),
-  );
-  return new Parser().setLanguage(await Language.load(path));
-}
-
-const parsers = {
-  posix: await createParser("posix"),
-  gnu: await createParser("gnu"),
-};
-
-const documentTrees = new Map();
-
-function parseDocument(document, dialect) {
-  const source = document.getText();
-  let trees = documentTrees.get(document.uri);
-
-  if (trees === undefined) {
-    trees = new Map();
-    documentTrees.set(document.uri, trees);
-  }
-
-  const cached = trees.get(dialect);
-  if (
-    cached !== undefined &&
-    cached.version === document.version &&
-    cached.source === source
-  ) {
-    return cached.tree;
-  }
-
-  cached?.tree.delete();
-  const tree = parsers[dialect].parse(source);
-  if (tree === null) {
-    throw new Error(`Failed to parse ${dialect} sed source.`);
-  }
-
-  trees.set(dialect, {
-    source,
-    tree,
-    version: document.version,
-  });
-  return tree;
-}
-
-export function invalidateSyntaxTreeCache(document) {
-  const trees = documentTrees.get(document.uri);
-  if (trees !== undefined) {
-    for (const { tree } of trees.values()) {
-      tree.delete();
-    }
-    documentTrees.delete(document.uri);
-  }
-}
-
-const diagnosticSource = "sed-language-server";
-
-const issueDescriptions = {
-  incomplete_escape: {
-    code: "incomplete-escape",
-    message: "This escape sequence is incomplete.",
-  },
-  incomplete_regex: {
-    code: "unterminated-regular-expression",
-    message: "This regular expression is not terminated.",
-  },
-  incomplete_replacement: {
-    code: "unterminated-replacement",
-    message: "This replacement is not terminated.",
-  },
-  incomplete_translate: {
-    code: "unterminated-translation",
-    message: "This translation is not terminated.",
-  },
-  invalid_control_escape: {
-    code: "invalid-control-escape",
-    message: "This GNU sed control escape is invalid.",
-  },
-  unclosed_bracket: {
-    code: "unclosed-bracket-expression",
-    message: "This bracket expression is not terminated.",
-  },
-  invalid_command: (node, dialect) => ({
-    code: "invalid-command",
-    message: `Unknown ${dialectName(dialect)} sed command: \`${node.text}\`.`,
-  }),
-  invalid_flag: (node, dialect) => ({
-    code: "invalid-substitution-flag",
-    message: `Unknown ${dialectName(dialect)} sed substitution flag: \`${node.text}\`.`,
-  }),
-  unexpected_text: (_node, dialect) => ({
-    code: "unexpected-text",
-    message: `Unexpected text after this ${dialectName(dialect)} sed command.`,
-  }),
-};
-
-function dialectName(dialect) {
-  return dialect === "gnu" ? "GNU" : "POSIX";
-}
-
-function descriptionFor(node, dialect) {
-  const description = issueDescriptions[node.type];
-  if (typeof description === "function") {
-    return description(node, dialect);
-  }
-  if (description !== undefined) {
-    return description;
-  }
-
-  const displayName = dialectName(dialect);
-  if (node.isMissing) {
-    return {
-      code: "missing-syntax",
-      message: `Expected ${node.type.replaceAll("_", " ")}.`,
-    };
-  }
-
-  return {
-    code: "syntax-error",
-    message: `Invalid ${displayName} sed syntax.`,
-  };
-}
-
-function isSpecificIssue(node) {
-  return node.isMissing || Object.hasOwn(issueDescriptions, node.type);
-}
-
-function collectIssueNodes(rootNode) {
-  const issues = [];
-  const stack = [
-    {
-      node: rootNode,
-      children: rootNode.children,
-      childIndex: 0,
-      hasDescendantIssue: false,
-      issueStartIndex: 0,
-    },
-  ];
-
-  while (stack.length > 0) {
-    const frame = stack.at(-1);
-    if (frame.childIndex < frame.children.length) {
-      const child = frame.children[frame.childIndex];
-      frame.childIndex += 1;
-      stack.push({
-        node: child,
-        children: child.children,
-        childIndex: 0,
-        hasDescendantIssue: false,
-        issueStartIndex: issues.length,
-      });
-      continue;
-    }
-
-    const specific = isSpecificIssue(frame.node);
-    const selected =
-      specific || (frame.node.isError && !frame.hasDescendantIssue);
-    if (specific) {
-      issues.length = frame.issueStartIndex;
-    }
-    if (selected) {
-      issues.push(frame.node);
-    }
-
-    stack.pop();
-    const parent = stack.at(-1);
-    if (parent !== undefined) {
-      parent.hasDescendantIssue ||= frame.hasDescendantIssue || selected;
-    }
-  }
-
-  return issues;
-}
-
-function issuePriority(node) {
-  if (node.isError) {
-    return 0;
-  }
-  if (node.isMissing) {
-    return 1;
-  }
-  return 2;
-}
-
-function preferSpecificIssues(nodes) {
-  const issuesByRange = new Map();
-
-  for (const node of nodes) {
-    const key = `${node.startIndex}:${node.endIndex}`;
-    const existing = issuesByRange.get(key);
-    if (
-      existing === undefined ||
-      issuePriority(node) > issuePriority(existing)
-    ) {
-      issuesByRange.set(key, node);
-    }
-  }
-
-  return [...issuesByRange.values()].sort(
-    (left, right) =>
-      left.startIndex - right.startIndex || left.endIndex - right.endIndex,
-  );
-}
-
-function rangeForNode(document, node) {
-  return {
-    start: document.positionAt(node.startIndex),
-    end: document.positionAt(node.endIndex),
-  };
-}
-
-function collectLabels(rootNode, offset) {
-  const definitions = [];
-  let reference;
-  const stack = [rootNode];
-
-  while (stack.length > 0) {
-    const node = stack.pop();
-    if (node.type === "label_definition") {
-      definitions.push(node);
-    } else if (
-      node.type === "label_reference" &&
-      node.startIndex <= offset &&
-      offset < node.endIndex
-    ) {
-      reference = node;
-    }
-    stack.push(...node.children.toReversed());
-  }
-
-  return { definitions, reference };
-}
-
-export function createDiagnostics(document, dialect) {
-  const tree = parseDocument(document, dialect);
-
-  return preferSpecificIssues(collectIssueNodes(tree.rootNode)).map((node) => {
-    const { code, message } = descriptionFor(node, dialect);
-    return {
-      severity: DiagnosticSeverity.Error,
-      range: rangeForNode(document, node),
-      message,
-      code,
-      source: diagnosticSource,
-    };
-  });
-}
-
-export function createDefinitionLocations(document, position, dialect) {
-  const tree = parseDocument(document, dialect);
-  const { definitions, reference } = collectLabels(
-    tree.rootNode,
-    document.offsetAt(position),
-  );
-
-  if (reference === undefined) {
-    return null;
-  }
-
-  const locations = definitions
-    .filter((definition) => definition.text === reference.text)
-    .map((definition) => ({
-      uri: document.uri,
-      range: rangeForNode(document, definition),
-    }));
-
-  return locations.length === 0 ? null : locations;
-}