@hydranium/core 1.0.0-next.334 → 1.0.0-next.338

package/src/langium/trivia/comment-preserver.ts

@@ -143,6 +143,36 @@ export interface IndentationTokenNames {
    readonly dedent: string;
 }
 
+/**
+ * A container a run of comment lines can be placed in: the run's own, or one
+ * it is lifted into when a block's DEDENT follows the run. `last` is the index
+ * in its content the run is placed after, `closed` the block the run is lifted
+ * out of, and `liftBelow` the column a comment line has to start left of to be
+ * lifted this far.
+ */
+export interface CommentLiftTarget {
+   readonly container: CompositeCstNode;
+   readonly last: number;
+   readonly closed?: CompositeCstNode;
+   readonly liftBelow?: number;
+}
+
+/**
+ * A run of hidden nodes in `content`, from `start` to `end`, with the syntax
+ * before it and the containers its comments can be placed in, innermost first.
+ */
+export interface CommentRun {
+   readonly content: readonly CstNode[];
+   readonly start: number;
+   readonly end: number;
+   readonly previous?: { readonly end: number };
+   readonly targets: readonly CommentLiftTarget[];
+   /** The nodes {@link CommentPreserver.neighbours} finds before the run, in order. */
+   readonly before: readonly CstNode[];
+   /** Per target, the nodes {@link CommentPreserver.neighbours} finds after its `last`. */
+   readonly after: readonly (readonly CstNode[])[];
+}
+
 /**
  * One splice, with what it takes to check the risky kind afterwards.
  *
@@ -192,6 +222,18 @@ export class CommentPreserver implements TriviaPreserver<CommentTrivia> {
    protected readonly maxIsolatedEdits: number;
    protected commentTokenNames?: readonly string[];
    protected indentationTokenNames?: IndentationTokenNames | null;
+   /**
+    * Set for the duration of one {@link extract}: the run
+    * {@link resolveCommentRun} resolved last, so the run's next comment reuses
+    * it.
+    */
+   protected commentRun?: CommentRun;
+   /**
+    * Set for the duration of one {@link extract}: {@link syntaxSpan} per node,
+    * as a block a run is lifted out of would otherwise be measured once per
+    * comment.
+    */
+   protected spanMemo?: Map<CstNode, { readonly offset: number; readonly end: number } | undefined>;
    /** Set for the duration of one {@link apply}; see {@link cachedAnchorKey}. */
    protected keyMemo?: Map<AstNode, string | undefined>;
    /** Set for the duration of one {@link apply}; see {@link ambiguousRetainedKey}. */
@@ -259,9 +301,14 @@ export class CommentPreserver implements TriviaPreserver<CommentTrivia> {
       if (this.getIndentationTokenNames() === undefined) {
          return node;
       }
+      if (this.spanMemo?.has(node)) {
+         return this.spanMemo.get(node);
+      }
       const first = this.edgeToken(node, 1);
       const last = this.edgeToken(node, -1);
-      return first && last && { offset: first.offset, end: last.end };
+      const span = first && last && { offset: first.offset, end: last.end };
+      this.spanMemo?.set(node, span);
+      return span;
    }
 
    /** The first token of `node` for a `step` of 1, the last for -1, that is neither hidden nor indentation. */
@@ -355,7 +402,14 @@ export class CommentPreserver implements TriviaPreserver<CommentTrivia> {
       }
       const source = document.textDocument.getText();
       const comments: DocumentComment[] = [];
-      this.captureFrom(root, source, commentTokens, comments);
+      this.commentRun = undefined;
+      this.spanMemo = new Map();
+      try {
+         this.captureFrom(root, source, commentTokens, comments);
+      } finally {
+         this.commentRun = undefined;
+         this.spanMemo = undefined;
+      }
       return { comments, sourceRoot: document.parseResult.value };
    }
 
@@ -409,7 +463,14 @@ export class CommentPreserver implements TriviaPreserver<CommentTrivia> {
       const following = content[at + 1];
       const blankLinesAfter = following === undefined ? 0 : this.countBlankLines(source.slice(comment.end, offsetOf(following)));
       const preceding = at > 0 ? content[at - 1] : undefined;
-      const blankLinesBefore = preceding === undefined ? 0 : this.countBlankLines(source.slice(endOf(preceding), comment.offset));
+      // From the last text before the comment: a block it is lifted out of can
+      // end with comment lines of its own, after the block's syntax.
+      const precedingEnd = preceding === undefined ? comment.offset : endOf(preceding);
+      let gapStart = comment.offset;
+      while (gapStart > precedingEnd && /\s/.test(source[gapStart - 1])) {
+         gapStart--;
+      }
+      const blankLinesBefore = preceding === undefined ? 0 : this.countBlankLines(source.slice(gapStart, comment.offset));
 
       // Only a comment that OWNS its line can be reindented — one sharing a line
       // with code keeps whatever spacing that line gives it.
@@ -418,7 +479,7 @@ export class CommentPreserver implements TriviaPreserver<CommentTrivia> {
       const sourceIndent = beforeOnLine.trim().length === 0 ? beforeOnLine : undefined;
 
       const text = this.normalizeLineEndings(comment.text);
-      const sharesLineWithPrevious = previous !== undefined && !source.slice(endOf(previous), comment.offset).includes('\n');
+      const sharesLineWithPrevious = previous !== undefined && !this.breaksLine(source, endOf(previous), comment.offset);
 
       if (sharesLineWithPrevious) {
          // On the same line as whatever precedes it, so it annotates that line.
@@ -451,8 +512,10 @@ export class CommentPreserver implements TriviaPreserver<CommentTrivia> {
    }
 
    /**
-    * Resolves the container {@link classify} anchors `comment` in and its
-    * siblings there without INDENT and DEDENT tokens.
+    * Resolves the container {@link classify} anchors `comment` in, and the
+    * comment's adjacent siblings there and the nearest syntax on each side,
+    * without INDENT and DEDENT tokens. The content is that window, not all of
+    * the container's siblings.
     *
     * An indentation-aware lexer can emit a block's DEDENT after the comment
     * lines that follow the block, so the parser nests them in it. An own-line
@@ -466,10 +529,35 @@ export class CommentPreserver implements TriviaPreserver<CommentTrivia> {
       container: CompositeCstNode,
       source: string
    ): { readonly container: CompositeCstNode; readonly content: readonly CstNode[]; readonly index: number } {
-      if (this.getIndentationTokenNames() === undefined) {
-         return { container, content: container.content, index };
+      const content = container.content;
+      const run = this.resolveCommentRun(index, container, source);
+      let placed = 0;
+      if (run.targets.length > 1 && (run.previous === undefined || this.breaksLine(source, run.previous.end, comment.offset))) {
+         const column = this.columnAt(source, comment.offset);
+         while (placed + 1 < run.targets.length && column < (run.targets[placed + 1].liftBelow ?? 0)) {
+            placed++;
+         }
       }
+      const { container: parent, closed } = run.targets[placed];
+      const before = closed ? [closed] : run.before;
+      const around = content.slice(Math.max(index - 1, run.start), Math.min(index + 1, run.end) + 1);
+      const view = [...before, ...around, ...run.after[placed]];
+      return { container: parent, content: view, index: before.length + (index > run.start ? 1 : 0) };
+   }
+
+   /**
+    * The run of hidden nodes around `container.content[index]`, and the blocks
+    * it can be lifted out of: each that ends right after the run and whose
+    * INDENT opened a column, up to the first that does not.
+    */
+   protected resolveCommentRun(index: number, container: CompositeCstNode, source: string): CommentRun {
       const content = container.content;
+      const cached = this.commentRun;
+      // Resolved once per run, not per comment: a run of k comment lines would
+      // otherwise cost k scans of the run.
+      if (cached?.content === content && index >= cached.start && index <= cached.end) {
+         return cached;
+      }
       let start = index;
       while (start > 0 && content[start - 1].hidden) {
          start--;
@@ -478,37 +566,62 @@ export class CommentPreserver implements TriviaPreserver<CommentTrivia> {
       while (end + 1 < content.length && content[end + 1].hidden) {
          end++;
       }
-      const run = content.slice(start, end + 1);
       let previous: { readonly end: number } | undefined;
-      for (let scan = start - 1; scan >= 0 && previous === undefined; scan--) {
-         previous = content[scan].hidden ? undefined : this.syntaxSpan(content[scan]);
+      const targets: CommentLiftTarget[] = [{ container, last: end }];
+      if (this.getIndentationTokenNames() !== undefined) {
+         for (let scan = start - 1; scan >= 0 && previous === undefined; scan--) {
+            previous = content[scan].hidden ? undefined : this.syntaxSpan(content[scan]);
+         }
+         let target = targets[0];
+         while (target.container.container && this.closesAfter(target.container.content, target.last)) {
+            const opened = this.openedColumn(target.container.content, target.closed ? target.last : start, source) ?? 0;
+            if (opened === 0) {
+               break;
+            }
+            const parent = target.container.container;
+            target = {
+               container: parent,
+               last: this.indexIn(parent.content, target.container),
+               closed: target.container,
+               liftBelow: opened
+            };
+            targets.push(target);
+         }
       }
-      let parent = container;
-      let closed: CstNode | undefined;
-      if (previous === undefined || source.slice(previous.end, comment.offset).includes('\n')) {
-         const column = this.columnAt(source, comment.offset);
-         while (
-            parent.container &&
-            this.closesAfter(parent.content, closed ?? run[run.length - 1]) &&
-            column < (this.openedColumn(parent.content, closed ?? run[0], source) ?? 0)
-         ) {
-            closed = parent;
-            parent = parent.container;
+      const before = this.neighbours(content, start - 1, -1).reverse();
+      const after = targets.map(target => this.neighbours(target.container.content, target.last + 1, 1));
+      return (this.commentRun = { content, start, end, previous, targets, before, after });
+   }
+
+   /** The nodes of `content` from `from` in `step` direction up to the first that is syntax, without indentation tokens. */
+   protected neighbours(content: readonly CstNode[], from: number, step: 1 | -1): CstNode[] {
+      const found: CstNode[] = [];
+      for (let scan = from; scan >= 0 && scan < content.length; scan += step) {
+         const node = content[scan];
+         if (!this.isIndentation(node)) {
+            found.push(node);
+            if (!node.hidden) {
+               break;
+            }
          }
       }
-      const view = parent.content.flatMap(node => (node === closed ? [node, ...run] : this.isIndentation(node) ? [] : [node]));
-      return { container: parent, content: view, index: view.indexOf(comment) };
+      return found;
    }
 
-   /** Whether only hidden and indentation tokens follow `node` in `content`. */
-   protected closesAfter(content: readonly CstNode[], node: CstNode): boolean {
-      return content.slice(content.indexOf(node) + 1).every(sibling => sibling.hidden || this.isIndentation(sibling));
+   /** Whether only hidden and indentation tokens follow `index` in `content`. */
+   protected closesAfter(content: readonly CstNode[], index: number): boolean {
+      for (let scan = index + 1; scan < content.length; scan++) {
+         if (!content[scan].hidden && !this.isIndentation(content[scan])) {
+            return false;
+         }
+      }
+      return true;
    }
 
-   /** The column the last INDENT before `node` in `content` opens, `undefined` without one. */
-   protected openedColumn(content: readonly CstNode[], node: CstNode, source: string): number | undefined {
+   /** The column the last INDENT before `content[index]` opens, `undefined` without one. */
+   protected openedColumn(content: readonly CstNode[], index: number, source: string): number | undefined {
       const indent = this.getIndentationTokenNames()?.indent;
-      for (let scan = content.indexOf(node) - 1; scan >= 0; scan--) {
+      for (let scan = index - 1; scan >= 0; scan--) {
          if (tokenNameOf(content[scan]) === indent) {
             return this.columnAt(source, content[scan].end);
          }
@@ -516,6 +629,41 @@ export class CommentPreserver implements TriviaPreserver<CommentTrivia> {
       return undefined;
    }
 
+   /**
+    * The index of `node` in `content`, found by offset: `indexOf` per lifted
+    * block makes extraction quadratic in a block's siblings.
+    */
+   protected indexIn(content: readonly CstNode[], node: CstNode): number {
+      let low = 0;
+      let high = content.length;
+      while (low < high) {
+         const middle = (low + high) >> 1;
+         if (content[middle].offset < node.offset) {
+            low = middle + 1;
+         } else {
+            high = middle;
+         }
+      }
+      // Zero-width tokens can share the node's offset.
+      for (let index = low; index < content.length && content[index].offset === node.offset; index++) {
+         if (content[index] === node) {
+            return index;
+         }
+      }
+      return content.indexOf(node);
+   }
+
+   /** Whether `text` has a line break from `from` up to `to`, without copying the span. */
+   protected breaksLine(text: string, from: number, to: number): boolean {
+      // Not indexOf, which scans on to the next line break past `to`.
+      for (let offset = from; offset < to; offset++) {
+         if (text.charCodeAt(offset) === 10) {
+            return true;
+         }
+      }
+      return false;
+   }
+
    /** The column of `offset` in `text`. */
    protected columnAt(text: string, offset: number): number {
       return offset - (text.lastIndexOf('\n', offset - 1) + 1);

package/src/langium/validation/document-validator.ts

@@ -38,7 +38,7 @@ import {
 } from '@hydranium/langium';
 import type { CancellationToken } from 'vscode-languageserver-protocol';
 // A VALUE import, for `Diagnostic.getMessageString`: `message` is
-// `string | MarkupContent` in LSP 3.17+, so upstream's own reader is what
+// `string | MarkupContent` since LSP 3.18, so upstream's own reader is what
 // narrows it rather than a hand-rolled union check here.
 import { Diagnostic } from 'vscode-languageserver-types';
 import { type LogNameOptions } from '../diagnostics/logger.js';

package/src/lsp/edit-requests-guard.ts

@@ -0,0 +1,152 @@
+/********************************************************************************
+ * Copyright (c) 2026 EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+
+import { type URI } from '@hydranium/langium';
+import { type LangiumSharedServices } from '@hydranium/langium/lsp';
+import {
+   type Connection,
+   type Disposable,
+   type HandlerResult,
+   LSPErrorCodes,
+   ResponseError,
+   type WorkspaceEdit
+} from 'vscode-languageserver';
+import { LANGUAGE_CLIENT_ID } from '../documents/client-ids.js';
+import { HydraniumTextDocuments } from '../documents/hydranium-text-documents.js';
+import { type ServerSharedServicesMinimal } from '../langium/shared-services.js';
+
+const wrappedConnections = new WeakSet<object>();
+
+type Register<P, A extends unknown[], R, E> = (handler: (params: P, ...rest: A) => HandlerResult<R, E>) => Disposable;
+
+/**
+ * Refuse with `ContentModified` a request whose answer edits documents, when
+ * the editor of the request's document is behind the store as it arrives, or
+ * when a document the answer edits changed while it was computed, by another
+ * client, by a rebuild of a closed document or by its release, or its editor
+ * is then behind.
+ *
+ * The editor applies the edits by position to the text it holds, and sent the
+ * request's position in it, so an answer computed on other text rewrites the
+ * wrong characters. The check runs on the answer, since the documents a rename
+ * or code action edits are only known there, and on the connection, so an
+ * adopter's provider for these requests is covered. Edits that arrive by a
+ * resolve request, a file operation, `willSaveWaitUntil`, an inlay hint or a
+ * command's `workspace/applyEdit` are not.
+ *
+ * Read-only answers are not refused, since a refusal would blank them. An
+ * editor ahead of the store does not exist, as its changes reach the store
+ * before any request it sends after them.
+ */
+export function guardEditRequests(connection: Connection, services: LangiumSharedServices): void {
+   const store = services.workspace.TextDocuments;
+   if (wrappedConnections.has(connection) || !(store instanceof HydraniumTextDocuments)) {
+      return;
+   }
+   wrappedConnections.add(connection);
+   // A Hydranium store implies the Hydranium shared services.
+   const keyOf = (uri: URI | string): string =>
+      (services as LangiumSharedServices & ServerSharedServicesMinimal).workspace.DocumentUriPolicy.canonicalUri(uri);
+   const versions = (): ReadonlyMap<string, number> => new Map(store.all().map(document => [document.uri, document.version]));
+   // A closed document records no author per version, so a rebuild of it
+   // while an answer is computed is what refuses the answer. A release clears
+   // the authors, so a reopen would attribute another client's change to the
+   // editor, and refuses it as well.
+   const watching = new Set<{ readonly rebuilt: Set<string>; readonly released: Set<string> }>();
+   services.workspace.DocumentBuilder.onUpdate((changed, deleted) => {
+      if (watching.size === 0) {
+         return;
+      }
+      const keys = [...changed, ...deleted].map(keyOf);
+      for (const watched of watching) {
+         keys.forEach(key => watched.rebuilt.add(key));
+      }
+   });
+   store.onDidReleaseDocument(event => {
+      for (const watched of watching) {
+         watched.released.add(event.uri);
+      }
+   });
+   // The editor's own changes are not counted: it discards or re-filters an
+   // answer that predates them, and counting them would blank completion
+   // while the user types.
+   const changedByAnother = (uri: string, from: number | undefined, to: number): boolean => {
+      if (from === undefined) {
+         return true;
+      }
+      for (let version = from + 1; version <= to; version++) {
+         if (store.getAuthor(uri, version) !== LANGUAGE_CLIENT_ID) {
+            return true;
+         }
+      }
+      return false;
+   };
+   const refused = <E>(): ResponseError<E> =>
+      new ResponseError<E>(LSPErrorCodes.ContentModified, 'The editor does not hold the text the answer was computed on');
+   // The request's position is in the editor's text, which an answer
+   // computed on the store's would be applied past.
+   const behind = (uri: string): boolean => store.isLanguageClientBehind(uri, store.version(uri));
+   /** Watches the documents an answer may edit while it is computed; dispose it after. */
+   const watch = (): { changed(uris: Iterable<string>): boolean; dispose(): void } => {
+      const computedOn = versions();
+      const watched = { rebuilt: new Set<string>(), released: new Set<string>() };
+      watching.add(watched);
+      return {
+         changed: uris =>
+            [...new Set(uris)].some(uri => {
+               const document = store.get(uri);
+               const key = keyOf(uri);
+               const changed =
+                  watched.released.has(key) ||
+                  (document === undefined
+                     ? watched.rebuilt.has(key)
+                     : changedByAnother(uri, computedOn.get(document.uri), document.version));
+               return changed || behind(uri);
+            }),
+         dispose: () => watching.delete(watched)
+      };
+   };
+   const guard =
+      <P extends { readonly textDocument: { readonly uri: string } }, A extends unknown[], R, E>(
+         register: Register<P, A, R, E>,
+         edited: (result: R | null | undefined | void) => Iterable<string> = () => []
+      ): Register<P, A, R, E> =>
+      handler =>
+         register(async (params, ...rest) => {
+            const uri = params.textDocument.uri;
+            if (behind(uri)) {
+               return refused<E>();
+            }
+            const answer = watch();
+            try {
+               const result = await handler(params, ...rest);
+               return result instanceof ResponseError || !answer.changed([uri, ...edited(result)]) ? result : refused<E>();
+            } finally {
+               answer.dispose();
+            }
+         });
+
+   connection.onCompletion = guard(connection.onCompletion.bind(connection));
+   connection.onDocumentFormatting = guard(connection.onDocumentFormatting.bind(connection));
+   connection.onDocumentRangeFormatting = guard(connection.onDocumentRangeFormatting.bind(connection));
+   connection.onDocumentOnTypeFormatting = guard(connection.onDocumentOnTypeFormatting.bind(connection));
+   connection.onRenameRequest = guard(connection.onRenameRequest.bind(connection), editedUris);
+   connection.onCodeAction = guard(connection.onCodeAction.bind(connection), actions =>
+      (actions ?? []).flatMap(action => ('edit' in action && action.edit ? [...editedUris(action.edit)] : []))
+   );
+}
+
+function* editedUris(edit: WorkspaceEdit | null | undefined | void): Iterable<string> {
+   yield* Object.keys(edit?.changes ?? {});
+   for (const change of edit?.documentChanges ?? []) {
+      if ('textDocument' in change) {
+         yield change.textDocument.uri;
+      }
+   }
+}

package/src/lsp/index.ts

@@ -11,6 +11,7 @@ export * from './completion/hydranium-completion-provider.js';
 export * from './lsp-latency.js';
 export * from './connection-features.js';
 export * from './diagnostics-connection.js';
+export * from './edit-requests-guard.js';
 export * from './semantic-token-provider.js';
 export * from './language-module.js';
 export * from './shared-module.js';
@@ -22,6 +23,6 @@ export * from './save-text-document.js';
  * head: framework overrides + the start function live behind one
  * `@hydranium/core/lsp` subpath, mirroring Langium's own `langium/lsp`
  * convention. Signature-compatible with Langium's `startLanguageServer`, plus
- * a guard that the head's shared module was composed.
+ * the composition check and the connection guards listed in its doc.
  */
 export * from './start-language-server.js';

package/src/lsp/start-language-server.ts

@@ -14,6 +14,7 @@ import {
 } from '@hydranium/langium/lsp';
 import { HydraniumDocumentUpdateHandler } from './hydranium-document-update-handler.js';
 import { guardDiagnosticsConnection } from './diagnostics-connection.js';
+import { guardEditRequests } from './edit-requests-guard.js';
 import { installConsoleTee } from '../langium/diagnostics/console-tee.js';
 
 /**
@@ -59,20 +60,22 @@ export function assertLspHeadComposed(services: LangiumSharedServices): void {
 
 /**
  * The framework's LSP server entry point: {@link assertLspHeadComposed}, then
- * {@link guardDiagnosticsConnection} on the tree's connection, then the
- * console's wrapping for the log file, then Langium's `startLanguageServer`.
- * Signature-compatible with Langium's, so it is a drop-in for adopters
- * importing from `@hydranium/core/lsp`. Calling Langium's directly skips the
- * composition check, the guard without which a publish racing teardown fails
- * the build that validated the document, and the wrapping, which a stdio
- * connection discards where a logger was built before it (see
- * `installConsoleTee`).
+ * {@link guardDiagnosticsConnection} and {@link guardEditRequests} on the
+ * tree's connection, then the console's wrapping for the log file, then
+ * Langium's `startLanguageServer`. Signature-compatible with Langium's, so it
+ * is a drop-in for adopters importing from `@hydranium/core/lsp`. Calling
+ * Langium's directly skips the composition check, the guard without which a
+ * publish racing teardown fails the build that validated the document, the
+ * guard without which an edit lands on text the editor does not hold, and the
+ * wrapping, which a stdio connection discards where a logger was built before
+ * it (see `installConsoleTee`).
  */
 export function startLanguageServer(services: LangiumSharedServices, serviceRequirements: Partial<ServiceRequirements> = {}): void {
    assertLspHeadComposed(services);
    const connection = services.lsp.Connection;
    if (connection) {
       guardDiagnosticsConnection(connection);
+      guardEditRequests(connection, services);
    }
    installConsoleTee();
    startLangiumLanguageServer(services, serviceRequirements);

package/src/messages/carriers.ts

@@ -63,7 +63,7 @@ export function acceptMessage<S extends string, N extends AstNode, P extends Pro
  * Recover the identity from a published diagnostic, for a surface that
  * identifies or renders diagnostics itself.
  *
- * `Diagnostic.message` is `string | MarkupContent` in LSP 3.17+, so the text
+ * `Diagnostic.message` is `string | MarkupContent` since LSP 3.18, so the text
  * comes from upstream's own `Diagnostic.getMessageString` rather than a
  * hand-rolled narrowing — consuming the library in its style, and one fewer
  * place restating the union.