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

package/README.md

@@ -2,13 +2,7 @@
 
 [![CI](https://github.com/tsuzuri-lab/sed-language-server/actions/workflows/ci.yml/badge.svg)](https://github.com/tsuzuri-lab/sed-language-server/actions/workflows/ci.yml)
 
-A [Language Server Protocol](https://microsoft.github.io/language-server-protocol/)
-implementation for
-[POSIX `sed`](https://pubs.opengroup.org/onlinepubs/9799919799.2024edition/utilities/sed.html)
-with opt-in GNU sed 4.10 syntax support.
-
-The default profile is POSIX with basic regular expressions. BSD and
-other implementation-specific extensions are outside the current scope.
+A Language Server Protocol implementation for POSIX and GNU `sed`.
 
 ## Installation
 
@@ -18,7 +12,7 @@ Requires Node.js 22 or later.
 npm install --global @tsuzuri-lab/sed-language-server
 ```
 
-Configure the LSP client to start the server with:
+Start the server with:
 
 ```sh
 sed-language-server --stdio
@@ -26,49 +20,59 @@ sed-language-server --stdio
 
 ## Features
 
-The server provides:
-
-- profile-aware diagnostics for supported POSIX and GNU sed syntax
-- profile-aware command, substitute-flag, and branch-label completion
+- Tree-sitter-based diagnostics
 - go to definition from `b`, `t`, and GNU `T` label references
 
-It analyzes scripts without executing them, running shell commands, or
-accessing referenced files.
-
-## Syntax profiles
+Scripts are analyzed without executing them or accessing referenced files.
 
-The supported profile values are:
+## Configuration
 
-- `dialect`: `posix` or `gnu`
-- `regexpMode`: `bre` or `ere`
-
-Clients can select a profile during initialization:
+The default dialect is `posix`. To use GNU syntax, pass the following LSP
+initialization options:
 
 ```json
 {
-  "initializationOptions": {
-    "dialect": "gnu",
-    "regexpMode": "bre"
-  }
+  "dialect": "gnu"
 }
 ```
 
-They can change it for all open documents through
-`workspace/didChangeConfiguration`:
+The supported dialects are `posix` and `gnu`.
 
-```json
-{
-  "settings": {
-    "sedLanguageServer": {
-      "dialect": "gnu",
-      "regexpMode": "ere"
-    }
-  }
-}
+## Editor setup
+
+Configure the LSP client to use:
+
+- command: `sed-language-server --stdio`
+- language ID or filetype: `sed`
+- initialization options: `{"dialect":"gnu"}` when using GNU syntax
+
+For example, with Emacs and Eglot:
+
+```elisp
+(require 'eglot)
+
+(add-to-list 'eglot-server-programs
+             '((sed-ts-mode sed-mode) .
+               ("sed-language-server" "--stdio"
+                :initializationOptions (:dialect "gnu"))))
+```
+
+Run `M-x eglot` in a `sed-ts-mode` or `sed-mode` buffer. Omit
+`:initializationOptions` to use the default POSIX dialect.
+
+For Neovim 0.11 or later:
+
+```lua
+vim.lsp.config("sed_language_server", {
+  cmd = { "sed-language-server", "--stdio" },
+  filetypes = { "sed" },
+  init_options = { dialect = "gnu" },
+})
+
+vim.lsp.enable("sed_language_server")
 ```
 
-Omitted settings select `posix` and `bre`. The server does not infer a dialect
-from document contents.
+Omit `init_options` to use the default POSIX dialect.
 
 ## Development
 
@@ -76,7 +80,13 @@ from document contents.
 npm ci
 npm run check
 npm test
-npm start
+```
+
+The published package includes prebuilt POSIX and GNU grammar Wasm files.
+Rebuild them from the pinned `tree-sitter-sed` revision with:
+
+```sh
+npm run build:grammar -- /path/to/tree-sitter-sed
 ```
 
 ## License

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tsuzuri-lab/sed-language-server",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Language server for POSIX sed with opt-in GNU syntax support.",
   "keywords": [
     "sed",
@@ -9,12 +9,14 @@
   ],
   "type": "module",
   "files": [
-    "src"
+    "src",
+    "vendor"
   ],
   "bin": {
     "sed-language-server": "src/server.js"
   },
   "scripts": {
+    "build:grammar": "node scripts/build-tree-sitter-sed-wasm.js",
     "check": "biome check .",
     "check:write": "biome check --write .",
     "prepublishOnly": "npm run check && npm test",
@@ -38,9 +40,11 @@
   },
   "dependencies": {
     "vscode-languageserver": "10.1.0",
-    "vscode-languageserver-textdocument": "1.0.12"
+    "vscode-languageserver-textdocument": "1.0.12",
+    "web-tree-sitter": "0.26.11"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.5.5"
+    "@biomejs/biome": "2.5.5",
+    "tree-sitter-cli": "0.26.11"
   }
 }

package/src/analysis.js

@@ -0,0 +1,275 @@
+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;
+}

package/src/server.js

@@ -12,16 +12,10 @@ import {
 } from "vscode-languageserver/node";
 import { TextDocument } from "vscode-languageserver-textdocument";
 import {
-  completionProviderOptions,
-  createCompletionHandler,
-} from "./completion.js";
-import { createDefinitionHandler, definitionProvider } from "./definition.js";
-import { createDiagnostics } from "./diagnostics.js";
-import { invalidateDocumentStructureCache } from "./document-structure.js";
-import {
-  defaultSyntaxProfile,
-  resolveSyntaxProfile,
-} from "./syntax-profile.js";
+  createDefinitionLocations,
+  createDiagnostics,
+  invalidateSyntaxTreeCache,
+} from "./analysis.js";
 
 if (process.argv.length === 2) {
   process.argv.push("--stdio");
@@ -29,19 +23,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;
 
-const serverCapabilities = {
-  textDocumentSync: TextDocumentSyncKind.Incremental,
-  completionProvider: completionProviderOptions,
-  definitionProvider,
-};
+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.",
+    };
+  }
 
-function syntaxProfileErrorMessage(errors) {
-  return errors.map(({ message }) => message).join(" ");
+  const dialect =
+    options.dialect === undefined ? defaultDialect : options.dialect;
+  if (dialect !== "posix" && dialect !== "gnu") {
+    return {
+      error: 'The syntax dialect must be either "posix" or "gnu".',
+    };
+  }
+
+  return { dialect };
 }
 
-function configurationProfileOptions(settings) {
+function configurationOptions(settings) {
   if (
     settings !== null &&
     typeof settings === "object" &&
@@ -54,63 +60,60 @@ 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,
+    },
   };
 });
 
 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);
+});
 
 documents.onDidChangeContent(({ document }) => {
   publishDiagnostics(document);
 });
 
 documents.onDidClose(({ document }) => {
-  invalidateDocumentStructureCache(document);
+  invalidateSyntaxTreeCache(document);
   connection.sendDiagnostics({ uri: document.uri, diagnostics: [] });
 });