@mrclrchtr/supi-lsp 10.0.0 → 11.0.0

package/src/client/client.ts

@@ -5,6 +5,7 @@
 import { type ChildProcess, execSync, spawn } from "node:child_process";
 import * as path from "node:path";
 import {
+  type CFamilyFileAssociationResolver,
   type CodeQueryResult,
   type CodeRequestControl,
   completedCodeQuery,
@@ -69,11 +70,15 @@ import { createTypeScriptDiagnosticRequestAdapter } from "./client-diagnostic-ty
 import { ClientDiagnostics } from "./client-diagnostics.ts";
 import type { ClientDiagnosticSnapshot, DiagnosticEntry } from "./client-document-state.ts";
 import { type NormalizedDocumentSync, normalizeDocumentSync } from "./client-document-sync.ts";
-import { SemanticInputRequestRetryGuard } from "./client-request-enrollment.ts";
 import {
-  isSemanticInputEnrollmentError,
-  SemanticInputSynchronizationError,
-} from "./client-semantic-input-errors.ts";
+  SemanticInputRequestRetryGuard,
+  type SemanticInputRequestRetryReason,
+} from "./client-request-enrollment.ts";
+import type {
+  SemanticInputDocumentSnapshot,
+  SemanticInputSnapshot,
+} from "./client-semantic-input-barrier.ts";
+import { SemanticInputSynchronizationError } from "./client-semantic-input-errors.ts";
 import { JsonRpcClient, JsonRpcRequestError } from "./transport.ts";
 
 const SHUTDOWN_TIMEOUT_MS = 5_000;
@@ -87,7 +92,15 @@ interface SemanticRequestAttemptState {
 
 interface RefactorTransaction {
   rpc: JsonRpcClient;
-  assertCurrent: () => Promise<void>;
+  assertCurrent: () => Promise<SemanticInputSnapshot>;
+}
+
+export interface RenameDetailedWithSnapshotsResult {
+  readonly result: CodeQueryResult<WorkspaceEdit | null>;
+  /** Verified input revision retained when a rename needs document enrollment. */
+  readonly inputRevision?: number;
+  /** Exact documents synchronized before and rechecked after this request. */
+  readonly documentSnapshots: readonly SemanticInputDocumentSnapshot[];
 }
 
 /**
@@ -529,6 +542,8 @@ export class LspClient {
     private readonly onLifecycleTransition?: LspClientLifecycleListener,
     /** Absolute workspace root for debug-telemetry identity. */
     readonly cwd?: string,
+    /** Immutable workspace association snapshot for document language IDs. */
+    fileAssociations?: CFamilyFileAssociationResolver,
   ) {
     this.name = name;
     this.root = root;
@@ -562,6 +577,7 @@ export class LspClient {
     this.diagnostics = new ClientDiagnostics({
       server: name,
       cwd: cwd,
+      fileAssociations,
       isOperational: () => this.rpc !== null && this._status === "running",
       diagnosticRequestAdapter: this.diagnosticRequestAdapter,
       documentSync: () => this.getDocumentSyncOptions(),
@@ -1155,8 +1171,32 @@ export class LspClient {
     newName: string,
     control?: CodeRequestControl,
   ): Promise<CodeQueryResult<WorkspaceEdit | null>> {
+    return (
+      await this.renameDetailedWithSnapshots(filePath, position, newName, {
+        control,
+        snapshotFiles: [filePath],
+      })
+    ).result;
+  }
+
+  /** Run rename and retain the exact synchronized inputs verified by its transaction. */
+  async renameDetailedWithSnapshots(
+    filePath: string,
+    position: Position,
+    newName: string,
+    options: {
+      readonly control?: CodeRequestControl;
+      readonly snapshotFiles?: readonly string[];
+      /** Reject non-enrollment changes since this earlier rename request. */
+      readonly inputRevision?: number;
+    } = {},
+  ): Promise<RenameDetailedWithSnapshotsResult> {
+    const { control, snapshotFiles = [filePath] } = options;
     if (!this.supportsRename) {
-      return unavailableCodeQuery("The server does not advertise textDocument/rename.");
+      return {
+        result: unavailableCodeQuery("The server does not advertise textDocument/rename."),
+        documentSnapshots: [],
+      };
     }
     if (
       typeof filePath !== "string" ||
@@ -1165,9 +1205,12 @@ export class LspClient {
       typeof newName !== "string" ||
       newName.trim().length === 0
     ) {
-      return unavailableCodeQuery(
-        "Rename requires a valid file, position, and non-empty new name.",
-      );
+      return {
+        result: unavailableCodeQuery(
+          "Rename requires a valid file, position, and non-empty new name.",
+        ),
+        documentSnapshots: [],
+      };
     }
 
     const params = {
@@ -1175,22 +1218,39 @@ export class LspClient {
       position,
       newName,
     };
-    return this.runRefactorTransaction("textDocument/rename", control, async (transaction) => {
-      if (this.supportsPrepareRename) {
-        const prepared = await transaction.rpc.sendRequest(
-          "textDocument/prepareRename",
-          { textDocument: { uri: fileToUri(filePath) }, position },
-          control,
-        );
-        const preparationError = validatePrepareRenameResult(prepared, position);
-        if (preparationError) throw new Error(preparationError);
-        await transaction.assertCurrent();
-      }
-      return (await transaction.rpc.sendRequest("textDocument/rename", params, control)) as
-        | WorkspaceEdit
-        | null
-        | undefined;
-    });
+    let documentSnapshots: readonly SemanticInputDocumentSnapshot[] = [];
+    let inputRevision: number | undefined;
+    const requestedFiles = new Set(snapshotFiles.map((file) => path.resolve(file)));
+    const result = await this.runRefactorTransaction(
+      "textDocument/rename",
+      control,
+      async (transaction) => {
+        if (this.supportsPrepareRename) {
+          const prepared = await transaction.rpc.sendRequest(
+            "textDocument/prepareRename",
+            { textDocument: { uri: fileToUri(filePath) }, position },
+            control,
+          );
+          const preparationError = validatePrepareRenameResult(prepared, position);
+          if (preparationError) throw new Error(preparationError);
+          await transaction.assertCurrent();
+        }
+        return (await transaction.rpc.sendRequest("textDocument/rename", params, control)) as
+          | WorkspaceEdit
+          | null
+          | undefined;
+      },
+      {
+        inputRevision: options.inputRevision,
+        onVerifiedSnapshot: (snapshot) => {
+          inputRevision = snapshot.revision;
+          documentSnapshots = snapshot.documents.filter((document) =>
+            requestedFiles.has(path.resolve(document.filePath)),
+          );
+        },
+      },
+    );
+    return { result, documentSnapshots, inputRevision };
   }
 
   async codeActions(
@@ -1247,7 +1307,9 @@ export class LspClient {
     control?: CodeRequestControl,
   ): Promise<CodeQueryResult<Location | Location[] | LocationLink[] | null>> {
     if (!this.capabilities?.implementationProvider) {
-      return unavailableCodeQuery("Implementation requests are not supported by this server.");
+      return unavailableCodeQuery(
+        `LSP server "${this.name}" does not advertise textDocument/implementation.`,
+      );
     }
     return this.query(
       "textDocument/implementation",
@@ -1300,6 +1362,10 @@ export class LspClient {
     method: string,
     control: CodeRequestControl | undefined,
     operation: (transaction: RefactorTransaction) => Promise<T | null | undefined>,
+    options: {
+      readonly onVerifiedSnapshot?: (snapshot: SemanticInputSnapshot) => void;
+      readonly inputRevision?: number;
+    } = {},
   ): Promise<CodeQueryResult<T | null>> {
     throwIfCodeRequestInterrupted(control);
     if (!this.rpc || this._status !== "running") {
@@ -1308,8 +1374,9 @@ export class LspClient {
       );
     }
 
-    const retryGuard = new SemanticInputRequestRetryGuard((revision) =>
-      this.diagnostics.getSemanticInputChangeSince(revision),
+    const retryGuard = new SemanticInputRequestRetryGuard(
+      (revision) => this.diagnostics.getSemanticInputChangeSince(revision),
+      { inputRevision: options.inputRevision },
     );
     for (;;) {
       const attempt: SemanticRequestAttemptState = { inputRevision: undefined };
@@ -1321,9 +1388,10 @@ export class LspClient {
           operation,
           retryGuard,
           attempt,
+          onVerifiedSnapshot: options.onVerifiedSnapshot,
         });
         if (retryGuard.hasRetried) {
-          this.recordSemanticRetry({ method, control, retryGuard, outcome: "completed" });
+          this.recordRequestRetry({ method, control, retryGuard, outcome: "completed" });
         }
         return completedCodeQuery(data);
       } catch (error) {
@@ -1364,8 +1432,9 @@ export class LspClient {
     operation: (transaction: RefactorTransaction) => Promise<T | null | undefined>;
     retryGuard: SemanticInputRequestRetryGuard;
     attempt: SemanticRequestAttemptState;
+    onVerifiedSnapshot?: (snapshot: SemanticInputSnapshot) => void;
   }): Promise<T | null> {
-    const { method, control, operation, retryGuard, attempt } = options;
+    const { method, control, operation, retryGuard, attempt, onVerifiedSnapshot } = options;
     throwIfCodeRequestInterrupted(control);
     retryGuard.assertCurrent();
     await this.getReady(control);
@@ -1381,10 +1450,14 @@ export class LspClient {
       rpc,
       assertCurrent: async () => {
         retryGuard.assertCurrent();
-        await this.diagnostics.assertSemanticInputsCurrent(inputSnapshot, control);
+        return this.diagnostics.assertSemanticInputsCurrent(inputSnapshot, control);
       },
     });
-    await this.diagnostics.assertSemanticInputsCurrent(inputSnapshot, control);
+    const verifiedSnapshot = await this.diagnostics.assertSemanticInputsCurrent(
+      inputSnapshot,
+      control,
+    );
+    onVerifiedSnapshot?.(verifiedSnapshot);
     return data ?? null;
   }
 
@@ -1418,8 +1491,9 @@ export class LspClient {
     params: unknown,
     control?: CodeRequestControl,
   ): Promise<CodeQueryResult<T | null>> {
-    const retryGuard = new SemanticInputRequestRetryGuard((revision) =>
-      this.diagnostics.getSemanticInputChangeSince(revision),
+    const retryGuard = new SemanticInputRequestRetryGuard(
+      (revision) => this.diagnostics.getSemanticInputChangeSince(revision),
+      { retryContentModified: true },
     );
     for (;;) {
       const attempt: SemanticRequestAttemptState = { inputRevision: undefined };
@@ -1432,7 +1506,7 @@ export class LspClient {
           attempt,
         });
         if (retryGuard.hasRetried) {
-          this.recordSemanticRetry({ method, control, retryGuard, outcome: "completed" });
+          this.recordRequestRetry({ method, control, retryGuard, outcome: "completed" });
         }
         return completedCodeQuery(data);
       } catch (error) {
@@ -1452,7 +1526,7 @@ export class LspClient {
     const { method, control, retryGuard, attempt, error } = options;
     if (isCodeRequestInterruption(error, control)) {
       if (retryGuard.hasRetried) {
-        this.recordSemanticRetry({ method, control, retryGuard, outcome: "interrupted" });
+        this.recordRequestRetry({ method, control, retryGuard, outcome: "interrupted" });
       }
       throwIfCodeRequestInterrupted(control);
       throw error;
@@ -1461,17 +1535,32 @@ export class LspClient {
     const decision = retryGuard.decide(error, attempt.inputRevision);
     if (decision.kind === "retry") {
       throwIfCodeRequestInterrupted(control);
-      this.recordSemanticRetry({ method, control, retryGuard, outcome: "retry", error });
+      this.recordRequestRetry({
+        method,
+        control,
+        retryGuard,
+        outcome: "retry",
+        retryReason: decision.reason,
+        error,
+      });
       return;
     }
     if (retryGuard.hasRetried) {
-      const outcome = isSemanticInputEnrollmentError(decision.error) ? "exhausted" : "failed";
-      this.recordSemanticRetry({ method, control, retryGuard, outcome, error: decision.error });
+      const outcome = decision.reason ? "exhausted" : "failed";
+      this.recordRequestRetry({
+        method,
+        control,
+        retryGuard,
+        outcome,
+        retryReason: retryGuard.retryReason,
+        failureReason: decision.reason,
+        error: decision.error,
+      });
       const detail =
         decision.error instanceof Error ? decision.error.message : String(decision.error);
       const count = retryGuard.retryCount;
       throw new Error(
-        `${detail} Enrollment retry ${outcome} after ${count} ${count === 1 ? "retry" : "retries"}.`,
+        `${detail} Request retry ${outcome} after ${count} ${count === 1 ? "retry" : "retries"}.`,
         {
           cause: decision.error,
         },
@@ -1481,18 +1570,20 @@ export class LspClient {
   }
 
   /** Record request acceptance separately from transport completion, without request content. */
-  private recordSemanticRetry(options: {
+  private recordRequestRetry(options: {
     method: string;
     control?: CodeRequestControl;
     retryGuard: SemanticInputRequestRetryGuard;
     outcome: "retry" | "completed" | "exhausted" | "failed" | "interrupted";
+    retryReason?: SemanticInputRequestRetryReason;
+    failureReason?: SemanticInputRequestRetryReason;
     error?: unknown;
   }): void {
     recordDebugEvent({
       source: "lsp",
       level: "debug",
-      category: "semantic-request.enrollment-retry",
-      message: "LSP semantic request enrollment retry",
+      category: "request.retry",
+      message: "LSP request retry",
       cwd: boundCwd(this.cwd),
       ...(options.control?.operationId ? { operationId: options.control.operationId } : {}),
       data: {
@@ -1500,6 +1591,8 @@ export class LspClient {
         method: truncateIdentity(options.method),
         outcome: options.outcome,
         retryCount: options.retryGuard.retryCount,
+        retryReason: options.retryReason ?? options.retryGuard.retryReason ?? null,
+        failureReason: options.failureReason ?? null,
         changeKind:
           options.error instanceof SemanticInputSynchronizationError
             ? options.error.changeKind