@tsuzuri-lab/sed-language-server 0.1.2 → 0.3.0

package/src/formatting.js

@@ -0,0 +1,97 @@
+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 tree = syntaxTreeFor(document, dialect);
+  if (collectSyntaxIssueNodes(tree.rootNode).length > 0) {
+    return [];
+  }
+
+  const formatted = formatScript(tree.rootNode, source, options);
+  if (formatted === source) {
+    return [];
+  }
+
+  return [
+    {
+      range: {
+        start: document.positionAt(0),
+        end: document.positionAt(source.length),
+      },
+      newText: formatted,
+    },
+  ];
+}

package/src/server.js

@@ -11,17 +11,10 @@ import {
   TextDocuments,
 } from "vscode-languageserver/node";
 import { TextDocument } from "vscode-languageserver-textdocument";
-import {
-  completionProviderOptions,
-  createCompletionHandler,
-} from "./completion.js";
-import { createDefinitionHandler, definitionProvider } from "./definition.js";
+import { createDefinitionLocations } from "./definition.js";
 import { createDiagnostics } from "./diagnostics.js";
-import { invalidateDocumentStructureCache } from "./document-structure.js";
-import {
-  defaultSyntaxProfile,
-  resolveSyntaxProfile,
-} from "./syntax-profile.js";
+import { createFormattingEdits } from "./formatting.js";
+import { invalidateSyntaxTreeCache } from "./syntax.js";
 
 if (process.argv.length === 2) {
   process.argv.push("--stdio");
@@ -29,19 +22,31 @@ if (process.argv.length === 2) {
 
 const connection = createConnection(ProposedFeatures.all);
 const documents = new TextDocuments(TextDocument);
-let activeSyntaxProfile = defaultSyntaxProfile;
+const defaultDialect = "posix";
+let activeDialect = defaultDialect;
+
+function resolveDialect(options) {
+  if (options === undefined || options === null) {
+    return { dialect: defaultDialect };
+  }
+  if (typeof options !== "object" || Array.isArray(options)) {
+    return {
+      error: "Syntax options must be provided as an object or null.",
+    };
+  }
 
-const serverCapabilities = {
-  textDocumentSync: TextDocumentSyncKind.Incremental,
-  completionProvider: completionProviderOptions,
-  definitionProvider,
-};
+  const dialect =
+    options.dialect === undefined ? defaultDialect : options.dialect;
+  if (dialect !== "posix" && dialect !== "gnu") {
+    return {
+      error: 'The syntax dialect must be either "posix" or "gnu".',
+    };
+  }
 
-function syntaxProfileErrorMessage(errors) {
-  return errors.map(({ message }) => message).join(" ");
+  return { dialect };
 }
 
-function configurationProfileOptions(settings) {
+function configurationOptions(settings) {
   if (
     settings !== null &&
     typeof settings === "object" &&
@@ -54,63 +59,68 @@ function configurationProfileOptions(settings) {
   return settings;
 }
 
-function publishDiagnostics(document, syntaxProfile = activeSyntaxProfile) {
+function publishDiagnostics(document) {
   return connection.sendDiagnostics({
     uri: document.uri,
     version: document.version,
-    diagnostics: createDiagnostics(document, syntaxProfile),
+    diagnostics: createDiagnostics(document, activeDialect),
   });
 }
 
 connection.onInitialize(({ initializationOptions }) => {
-  const result = resolveSyntaxProfile(initializationOptions);
-  if (!result.ok) {
-    return new ResponseError(
-      ErrorCodes.InvalidParams,
-      syntaxProfileErrorMessage(result.errors),
-      { retry: false },
-    );
+  const result = resolveDialect(initializationOptions);
+  if (result.error !== undefined) {
+    return new ResponseError(ErrorCodes.InvalidParams, result.error, {
+      retry: false,
+    });
   }
 
-  activeSyntaxProfile = result.profile;
+  activeDialect = result.dialect;
   return {
-    capabilities: serverCapabilities,
+    capabilities: {
+      textDocumentSync: TextDocumentSyncKind.Incremental,
+      definitionProvider: true,
+      documentFormattingProvider: true,
+    },
   };
 });
 
 connection.onDidChangeConfiguration(async ({ settings }) => {
-  const result = resolveSyntaxProfile(configurationProfileOptions(settings));
-  if (!result.ok) {
+  const result = resolveDialect(configurationOptions(settings));
+  if (result.error !== undefined) {
     connection.sendNotification(ShowMessageNotification.type, {
       type: MessageType.Error,
-      message: syntaxProfileErrorMessage(result.errors),
+      message: result.error,
     });
     return;
   }
 
-  const nextSyntaxProfile = result.profile;
-  activeSyntaxProfile = nextSyntaxProfile;
-  invalidateDocumentStructureCache();
+  activeDialect = result.dialect;
   await Promise.all(
-    documents
-      .all()
-      .map((document) => publishDiagnostics(document, nextSyntaxProfile)),
+    documents.all().map((document) => publishDiagnostics(document)),
   );
 });
 
-connection.onCompletion(
-  createCompletionHandler(documents, () => activeSyntaxProfile),
-);
-connection.onDefinition(
-  createDefinitionHandler(documents, () => activeSyntaxProfile),
-);
+connection.onDefinition(({ textDocument, position }) => {
+  const document = documents.get(textDocument.uri);
+  return document === undefined
+    ? null
+    : 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);
 });
 
 documents.onDidClose(({ document }) => {
-  invalidateDocumentStructureCache(document);
+  invalidateSyntaxTreeCache(document);
   connection.sendDiagnostics({ uri: document.uri, diagnostics: [] });
 });
 

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.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;
+}
+
+export function rangeForNode(document, node) {
+  return {
+    start: document.positionAt(node.startIndex),
+    end: document.positionAt(node.endIndex),
+  };
+}

package/src/completion.js

@@ -1,148 +0,0 @@
-import {
-  CompletionItemKind,
-  InsertTextFormat,
-} from "vscode-languageserver/node";
-import { getDocumentStructure } from "./document-structure.js";
-import {
-  commandSpecificationsFor,
-  substituteFlagSpecificationsFor,
-} from "./sed-syntax.js";
-import {
-  defaultSyntaxProfile,
-  requireSyntaxProfile,
-} from "./syntax-profile.js";
-
-function plainCompletion(label, kind, documentation) {
-  return {
-    label,
-    kind,
-    insertText: label,
-    insertTextFormat: InsertTextFormat.PlainText,
-    documentation,
-  };
-}
-
-const commandCompletionsByProfile = new Map();
-const substituteFlagCompletionsByProfile = new Map();
-
-function commandCompletionsFor(syntaxProfile) {
-  let completions = commandCompletionsByProfile.get(syntaxProfile);
-  if (completions !== undefined) {
-    return completions;
-  }
-
-  completions = [
-    plainCompletion(
-      ";",
-      CompletionItemKind.Keyword,
-      "Insert an empty command and begin the next command.",
-    ),
-    ...commandSpecificationsFor(syntaxProfile).map(
-      ({ command, documentation }) =>
-        plainCompletion(command, CompletionItemKind.Keyword, documentation),
-    ),
-  ];
-  commandCompletionsByProfile.set(syntaxProfile, completions);
-  return completions;
-}
-
-function substituteFlagCompletionsFor(syntaxProfile) {
-  let completions = substituteFlagCompletionsByProfile.get(syntaxProfile);
-  if (completions !== undefined) {
-    return completions;
-  }
-
-  completions = [
-    ...Array.from({ length: 9 }, (_, index) => {
-      const occurrence = String(index + 1);
-      return plainCompletion(
-        occurrence,
-        CompletionItemKind.Value,
-        `Replace only occurrence number ${occurrence}.`,
-      );
-    }),
-    ...substituteFlagSpecificationsFor(syntaxProfile).map(
-      ({ flag, documentation }) =>
-        plainCompletion(flag, CompletionItemKind.Keyword, documentation),
-    ),
-  ];
-  substituteFlagCompletionsByProfile.set(syntaxProfile, completions);
-  return completions;
-}
-
-export const completionProviderOptions = Object.freeze({});
-
-function branchLabelEditRange(document, context, offset) {
-  const replacementRange = context.replacementRange ?? {
-    startOffset: offset,
-    endOffset: offset,
-  };
-  const startOffset = Math.min(replacementRange.startOffset, offset);
-  const endOffset = Math.max(replacementRange.endOffset, offset);
-
-  return {
-    start: document.positionAt(startOffset),
-    end: document.positionAt(endOffset),
-  };
-}
-
-export function createCompletions(
-  document,
-  position,
-  options = defaultSyntaxProfile,
-) {
-  const syntaxProfile = requireSyntaxProfile(options);
-  const structure = getDocumentStructure(document, syntaxProfile);
-  const offset = document.offsetAt(position);
-  const context = structure.contextDetailsAt(offset);
-
-  if (context?.kind === "command") {
-    return commandCompletionsFor(syntaxProfile).map((completion) => ({
-      ...completion,
-    }));
-  }
-
-  if (context?.kind === "substitute-flag") {
-    return substituteFlagCompletionsFor(syntaxProfile).map((completion) => ({
-      ...completion,
-    }));
-  }
-
-  if (context?.kind !== "branch-label") {
-    return [];
-  }
-
-  const names = new Set();
-  const completions = [];
-  const editRange = branchLabelEditRange(document, context, offset);
-  for (const definition of structure.labelDefinitions) {
-    if (names.has(definition.name)) {
-      continue;
-    }
-
-    names.add(definition.name);
-    completions.push({
-      label: definition.name,
-      kind: CompletionItemKind.Reference,
-      insertTextFormat: InsertTextFormat.PlainText,
-      documentation: "Branch label defined in this document.",
-      textEdit: {
-        range: editRange,
-        newText: definition.name,
-      },
-    });
-  }
-  return completions;
-}
-
-export function createCompletionHandler(
-  documents,
-  getSyntaxProfile = () => defaultSyntaxProfile,
-) {
-  return ({ textDocument, position }) => {
-    const document = documents.get(textDocument.uri);
-    return document === undefined
-      ? null
-      : createCompletions(document, position, getSyntaxProfile());
-  };
-}