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

package/package.json

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

package/src/definition.js

@@ -1,39 +1,30 @@
 import { rangeForNode, syntaxTreeFor } from "./syntax.js";
 
-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 (
+function labelReferenceAt(rootNode, offset) {
+  let node = rootNode.namedDescendantForIndex(offset);
+  while (node !== null) {
+    if (
       node.type === "label_reference" &&
       node.startIndex <= offset &&
       offset < node.endIndex
     ) {
-      reference = node;
+      return node;
     }
-    stack.push(...node.children.toReversed());
+    node = node.parent;
   }
-
-  return { definitions, reference };
+  return undefined;
 }
 
 export function createDefinitionLocations(document, position, dialect) {
-  const tree = syntaxTreeFor(document, dialect);
-  const { definitions, reference } = collectLabels(
-    tree.rootNode,
-    document.offsetAt(position),
-  );
+  const rootNode = syntaxTreeFor(document, dialect).rootNode;
+  const reference = labelReferenceAt(rootNode, document.offsetAt(position));
 
   if (reference === undefined) {
     return null;
   }
 
-  const locations = definitions
+  const locations = rootNode
+    .descendantsOfType("label_definition")
     .filter((definition) => definition.text === reference.text)
     .map((definition) => ({
       uri: document.uri,

package/src/diagnostics.js

@@ -40,6 +40,10 @@ const issueDescriptions = {
     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.`,
@@ -71,7 +75,8 @@ function descriptionFor(node, dialect) {
     message: `Invalid ${dialectName(dialect)} sed syntax.`,
   };
 }
-function issuePriority(node) {
+
+function issueSpecificity(node) {
   if (node.isError) {
     return 0;
   }
@@ -81,6 +86,10 @@ function issuePriority(node) {
   return 2;
 }
 
+function compareIssueRanges(left, right) {
+  return left.startIndex - right.startIndex || left.endIndex - right.endIndex;
+}
+
 function preferSpecificIssues(nodes) {
   const issuesByRange = new Map();
 
@@ -89,31 +98,92 @@ function preferSpecificIssues(nodes) {
     const existing = issuesByRange.get(key);
     if (
       existing === undefined ||
-      issuePriority(node) > issuePriority(existing)
+      issueSpecificity(node) > issueSpecificity(existing)
     ) {
       issuesByRange.set(key, node);
     }
   }
 
-  return [...issuesByRange.values()].sort(
-    (left, right) =>
-      left.startIndex - right.startIndex || left.endIndex - right.endIndex,
-  );
+  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 tree = syntaxTreeFor(document, dialect);
-
-  return preferSpecificIssues(collectSyntaxIssueNodes(tree.rootNode)).map(
-    (node) => {
-      const { code, message } = descriptionFor(node, dialect);
-      return {
-        severity: DiagnosticSeverity.Error,
-        range: rangeForNode(document, node),
-        message,
-        code,
-        source: diagnosticSource,
-      };
-    },
-  );
+  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

@@ -75,12 +75,15 @@ function formatScript(rootNode, source, options) {
 
 export function createFormattingEdits(document, dialect, options) {
   const source = document.getText();
-  const tree = syntaxTreeFor(document, dialect);
-  if (collectSyntaxIssueNodes(tree.rootNode).length > 0) {
+  const rootNode = syntaxTreeFor(document, dialect).rootNode;
+  if (rootNode.hasError || collectSyntaxIssueNodes(rootNode).length > 0) {
     return [];
   }
 
-  const formatted = formatScript(tree.rootNode, source, options);
+  const formatted = formatScript(rootNode, source, options);
+  if (!source.startsWith("#n") && formatted.startsWith("#n")) {
+    return [];
+  }
   if (formatted === source) {
     return [];
   }

package/src/server.js

@@ -3,10 +3,8 @@
 import {
   createConnection,
   ErrorCodes,
-  MessageType,
   ProposedFeatures,
   ResponseError,
-  ShowMessageNotification,
   TextDocumentSyncKind,
   TextDocuments,
 } from "vscode-languageserver/node";
@@ -46,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,
@@ -85,22 +70,6 @@ connection.onInitialize(({ initializationOptions }) => {
   };
 });
 
-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

package/src/syntax.js

@@ -98,7 +98,7 @@ export function collectSyntaxIssueNodes(rootNode) {
 
     const specific = isSpecificSyntaxIssue(frame.node);
     const selected =
-      specific || (frame.node.isError && !frame.hasDescendantIssue);
+      specific || (frame.node.hasError && !frame.hasDescendantIssue);
     if (specific) {
       issues.length = frame.issueStartIndex;
     }