@hienlh/ppm 0.20.9 → 0.21.0

package/src/web/lib/lsp/lsp-navigation.ts

@@ -0,0 +1,129 @@
+/**
+ * Go to definition across files.
+ *
+ * Monaco's own F12 is left in place for everything that stays inside the open
+ * file, but a target in *another* file cannot be. Standalone Monaco resolves it
+ * through its default editor service, which — once a model exists for the
+ * target — swaps that model into the current editor. The tab keeps its old
+ * title and its old file's dirty state while showing different contents, which
+ * is worse than the feature not working.
+ *
+ * So this replaces the F12 binding with one that asks the server directly and
+ * routes the answer: reveal it here if it is here, and otherwise open the file
+ * as its own tab, positioned on the definition.
+ *
+ * Peek (Alt+F12) and find-all-references (Shift+F12) keep Monaco's bindings,
+ * because those render in place and never navigate — they need a resolvable
+ * model, which `lsp-shadow-models.ts` provides, but no interception.
+ */
+import type * as MonacoType from "monaco-editor";
+import { lspDocumentFor } from "./lsp-documents";
+import { fromLspPosition, toLspPosition, type LspRange } from "./lsp-monaco";
+import { fileUriToPath } from "../../../shared/lsp-uri";
+
+interface LspLocation {
+  uri: string;
+  range: LspRange;
+}
+
+interface LspLocationLink {
+  targetUri: string;
+  targetRange: LspRange;
+  targetSelectionRange?: LspRange;
+}
+
+export interface NavigationHost {
+  /**
+   * Open a project file positioned on a line.
+   *
+   * Line only, not line and column: `metadata.lineNumber` is the convention
+   * PPM's tabs already use for the search panel and chat `file:line` links, and
+   * a second reveal mechanism alongside it would be worse than losing the
+   * column.
+   */
+  openFileTab: (path: string, projectName: string, lineNumber: number) => void;
+}
+
+/**
+ * Bind F12 on this editor.
+ *
+ * `addAction` registers into the editor's own action set, which takes
+ * precedence over the built-in contribution, so this replaces rather than
+ * competes with Monaco's binding.
+ */
+export function registerLspNavigation(
+  monaco: typeof MonacoType,
+  editor: MonacoType.editor.IStandaloneCodeEditor,
+  host: NavigationHost,
+): MonacoType.IDisposable {
+  return editor.addAction({
+    id: "ppm.lsp.goToDefinition",
+    label: "Go to Definition",
+    keybindings: [monaco.KeyCode.F12],
+    contextMenuGroupId: "navigation",
+    contextMenuOrder: 1.1,
+    run: async (ed) => {
+      const model = ed.getModel();
+      const position = ed.getPosition();
+      if (!model || !position) return;
+
+      const document = lspDocumentFor(model);
+      if (!document) return;
+
+      let result: LspLocation | LspLocation[] | LspLocationLink[] | null = null;
+      try {
+        result = await document.connection.request(document.path, "textDocument/definition", {
+          textDocument: { uri: model.uri.toString() },
+          position: toLspPosition(position),
+        });
+      } catch {
+        // No server, or it declined. Nothing to navigate to, and an error
+        // dialog for a keypress would be worse than silence.
+        return;
+      }
+
+      const first = (Array.isArray(result) ? result[0] : result) ?? null;
+      if (!first) return;
+
+      const uri = "targetUri" in first ? first.targetUri : first.uri;
+      const range = "targetUri" in first ? (first.targetSelectionRange ?? first.targetRange) : first.range;
+      if (!uri || !range) return;
+
+      const target = fromLspPosition(range.start);
+
+      // The bridge rewrites a URI in the open file to the model's own, so this
+      // comparison is how "same file" is detected.
+      if (uri === model.uri.toString()) {
+        ed.setPosition(target);
+        ed.revealPositionInCenterIfOutsideViewport(target, monaco.editor.ScrollType.Smooth);
+        // Matches what VS Code does on a jump within a file.
+        ed.setSelection({
+          startLineNumber: target.lineNumber,
+          startColumn: target.column,
+          endLineNumber: range.end.line + 1,
+          endColumn: range.end.character + 1,
+        });
+        return;
+      }
+
+      const status = document.connection.statusOf(document.path);
+      if (status?.state !== "ready" || !status.projectPath) return;
+
+      const absolute = fileUriToPath(uri);
+      if (!absolute) return; // a virtual document, with no file to open
+      const relative = relativeTo(status.projectPath, absolute);
+      // Outside the project — a definition in node_modules or a toolchain
+      // library. PPM's tabs are project-scoped, so there is nowhere to put it.
+      if (!relative) return;
+
+      host.openFileTab(relative, document.connection.projectName, target.lineNumber);
+    },
+  });
+}
+
+function relativeTo(projectPath: string, absolute: string): string | null {
+  const root = projectPath.replace(/\\/g, "/").replace(/\/+$/, "");
+  const path = absolute.replace(/\\/g, "/");
+  if (!path.startsWith(root + "/")) return null;
+  return path.slice(root.length + 1);
+}

package/src/web/lib/lsp/lsp-responses.ts

@@ -0,0 +1,244 @@
+/**
+ * The shapes a language server answers with, turned into the shapes Monaco wants.
+ *
+ * Split out of `register-providers.ts`, which was doing two jobs at 673 lines: deciding what
+ * to ask and translating what came back. These are the second job — one level above
+ * `lsp-monaco.ts`, which handles the primitives (positions, kinds, markdown, one edit) with no
+ * Monaco instance at all. Everything here needs `monaco` itself, for `Uri.parse` and the enum
+ * values, and one of them needs the network, for the models a cross-file result names.
+ */
+import type * as MonacoType from "monaco-editor";
+import type { LspDocument } from "./lsp-documents";
+import { ensureShadowModels } from "./lsp-shadow-models";
+import {
+  completionKind,
+  fromLspRange,
+  symbolKind,
+  toMarkdown,
+  type LspMarkup,
+  type LspRange,
+  type LspTextEdit,
+} from "./lsp-monaco";
+
+// ── Shapes a server can answer with ────────────────────────────────────────
+
+export interface LspLocation {
+  uri: string;
+  range: LspRange;
+}
+
+export interface LspLocationLink {
+  targetUri: string;
+  targetSelectionRange?: LspRange;
+  targetRange: LspRange;
+}
+
+export interface LspCompletionItem {
+  label: string | { label: string; detail?: string; description?: string };
+  kind?: number;
+  detail?: string;
+  documentation?: LspMarkup;
+  sortText?: string;
+  filterText?: string;
+  preselect?: boolean;
+  insertText?: string;
+  insertTextFormat?: number;
+  textEdit?: { range?: LspRange; insert?: LspRange; replace?: LspRange; newText: string };
+  additionalTextEdits?: LspTextEdit[];
+  tags?: number[];
+  command?: { title: string; command: string; arguments?: unknown[] };
+  data?: unknown;
+}
+
+export interface LspDocumentSymbol {
+  name: string;
+  detail?: string;
+  kind: number;
+  range: LspRange;
+  selectionRange: LspRange;
+  children?: LspDocumentSymbol[];
+  /** The flat `SymbolInformation` shape, which older servers still return. */
+  location?: LspLocation;
+  containerName?: string;
+}
+
+export interface LspWorkspaceEdit {
+  changes?: Record<string, LspTextEdit[]>;
+  documentChanges?: Array<{ textDocument: { uri: string; version?: number }; edits: LspTextEdit[] }>;
+}
+
+/**
+ * What a suggestion has to carry to be resolvable.
+ *
+ * The document itself, not its path: a path is project-relative, and two projects open on
+ * `src/index.ts` are two different files on two different servers. Looking the model back up
+ * by path found whichever of them Monaco listed first, so resolving a suggestion could ask the
+ * wrong project's server — for a completion item it has never issued.
+ */
+export type ResolvableItem = MonacoType.languages.CompletionItem & {
+  __lsp?: LspCompletionItem;
+  __document?: LspDocument;
+};
+
+// ── Conversions that need Monaco ───────────────────────────────────────────
+
+export function toMonacoLocations(
+  monaco: typeof MonacoType,
+  result: LspLocation | LspLocation[] | LspLocationLink[] | null,
+): MonacoType.languages.Location[] {
+  if (!result) return [];
+  const list = Array.isArray(result) ? result : [result];
+  return list.flatMap((entry) => {
+    // `LocationLink` carries the target under different names; its selection
+    // range is the identifier itself, which is where the cursor should land.
+    if ("targetUri" in entry) {
+      return [{
+        uri: monaco.Uri.parse(entry.targetUri),
+        range: fromLspRange(entry.targetSelectionRange ?? entry.targetRange),
+      }];
+    }
+    if (!entry.uri || !entry.range) return [];
+    return [{ uri: monaco.Uri.parse(entry.uri), range: fromLspRange(entry.range) }];
+  });
+}
+
+/**
+ * Convert locations, first making sure Monaco can resolve every file they name.
+ *
+ * Monaco needs a model per URI or a cross-file result does nothing — F12 goes
+ * nowhere and peek opens blank. Awaiting the fetch here costs a moment on the
+ * first jump into an unopened file and makes the feature work at all.
+ */
+export async function toResolvableLocations(
+  monaco: typeof MonacoType,
+  document: LspDocument,
+  result: LspLocation | LspLocation[] | LspLocationLink[] | null,
+): Promise<MonacoType.languages.Location[]> {
+  const locations = toMonacoLocations(monaco, result);
+  const status = document.connection.statusOf(document.path);
+  if (status?.state === "ready") {
+    await ensureShadowModels(
+      monaco,
+      document.connection.projectName,
+      status.projectPath,
+      locations.map((location) => location.uri.toString()),
+    );
+  }
+  return locations;
+}
+
+export function toMonacoWorkspaceEdit(
+  monaco: typeof MonacoType,
+  edit: LspWorkspaceEdit | null | undefined,
+): MonacoType.languages.WorkspaceEdit {
+  const edits: MonacoType.languages.IWorkspaceTextEdit[] = [];
+
+  const push = (uri: string, textEdits: LspTextEdit[]) => {
+    for (const textEdit of textEdits) {
+      edits.push({
+        resource: monaco.Uri.parse(uri),
+        versionId: undefined,
+        textEdit: { range: fromLspRange(textEdit.range), text: textEdit.newText },
+      });
+    }
+  };
+
+  // `documentChanges` wins when present: it is the versioned form, and a server
+  // that sends both means them to be the same thing.
+  if (edit?.documentChanges) {
+    for (const change of edit.documentChanges) {
+      if (change.textDocument?.uri && Array.isArray(change.edits)) push(change.textDocument.uri, change.edits);
+    }
+  } else if (edit?.changes) {
+    for (const [uri, textEdits] of Object.entries(edit.changes)) push(uri, textEdits);
+  }
+
+  return { edits };
+}
+
+/**
+ * The range a completion replaces.
+ *
+ * A server may specify it three ways or not at all. When it does not, the word
+ * under the cursor is the right target — using the cursor position alone would
+ * insert the suggestion beside a half-typed identifier instead of completing it.
+ */
+function completionRange(
+  model: MonacoType.editor.ITextModel,
+  position: MonacoType.IPosition,
+  item: LspCompletionItem,
+): MonacoType.languages.CompletionItem["range"] {
+  const edit = item.textEdit;
+  if (edit?.insert && edit.replace) {
+    return { insert: fromLspRange(edit.insert), replace: fromLspRange(edit.replace) };
+  }
+  if (edit?.range) return fromLspRange(edit.range);
+
+  const word = model.getWordUntilPosition(position);
+  return {
+    startLineNumber: position.lineNumber,
+    startColumn: word.startColumn,
+    endLineNumber: position.lineNumber,
+    endColumn: word.endColumn,
+  };
+}
+
+export function toMonacoCompletion(
+  monaco: typeof MonacoType,
+  model: MonacoType.editor.ITextModel,
+  position: MonacoType.IPosition,
+  item: LspCompletionItem,
+  document: LspDocument,
+): ResolvableItem {
+  const label = typeof item.label === "string" ? item.label : item.label.label;
+  const insertText = item.textEdit?.newText ?? item.insertText ?? label;
+
+  const converted: ResolvableItem = {
+    label: typeof item.label === "string"
+      ? item.label
+      : { label: item.label.label, detail: item.label.detail, description: item.label.description },
+    kind: completionKind(monaco, item.kind),
+    insertText,
+    range: completionRange(model, position, item),
+    detail: item.detail,
+    documentation: toMarkdown(item.documentation),
+    sortText: item.sortText,
+    filterText: item.filterText,
+    preselect: item.preselect,
+    // 1 = Deprecated in LSP's CompletionItemTag.
+    tags: item.tags?.includes(1) ? [monaco.languages.CompletionItemTag.Deprecated] : undefined,
+    additionalTextEdits: item.additionalTextEdits?.map((e) => ({
+      range: fromLspRange(e.range),
+      text: e.newText,
+    })),
+    __lsp: item,
+    __document: document,
+  };
+
+  // 2 = Snippet. Without this rule the placeholders arrive as literal `${1:x}`.
+  if (item.insertTextFormat === 2) {
+    converted.insertTextRules = monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet;
+  }
+  return converted;
+}
+
+export function toMonacoSymbols(
+  monaco: typeof MonacoType,
+  symbols: LspDocumentSymbol[],
+): MonacoType.languages.DocumentSymbol[] {
+  return symbols.flatMap((symbol) => {
+    // Servers answer with either the hierarchical `DocumentSymbol` or the flat
+    // `SymbolInformation`, which puts the range inside a location instead.
+    const range = symbol.range ?? symbol.location?.range;
+    if (!range) return [];
+    return [{
+      name: symbol.name,
+      detail: symbol.detail ?? symbol.containerName ?? "",
+      kind: symbolKind(monaco, symbol.kind),
+      tags: [],
+      range: fromLspRange(range),
+      selectionRange: fromLspRange(symbol.selectionRange ?? range),
+      children: symbol.children ? toMonacoSymbols(monaco, symbol.children) : undefined,
+    }];
+  });
+}

package/src/web/lib/lsp/lsp-semantic-tokens.ts

@@ -0,0 +1,180 @@
+/**
+ * Colouring by what a name *is*, not by what it looks like.
+ *
+ * Monaco's own tokenizer is a set of regular expressions: it can tell a keyword
+ * from a string, but `Foo` is just an identifier whether it is a class, a type
+ * parameter or a local. The language server already knows which, and semantic
+ * tokens are how it says so. This is the same division VS Code uses — the regex
+ * grammar paints immediately, the server's answer refines it a moment later.
+ *
+ * Registration has to be lazy, and that is the whole reason this is not in
+ * `register-providers.ts` with the rest. Every other provider can be registered
+ * for a language before any server exists, because its request and response
+ * shapes are fixed. A semantic token is an *index* into a legend that only the
+ * server's initialize result contains, so a provider registered before a server
+ * connects would have nothing to decode with — and decoding with the wrong
+ * legend is worse than not colouring at all, because every token comes out as
+ * some other, plausible-looking kind.
+ */
+import type * as MonacoType from "monaco-editor";
+import { lspDocumentFor, type LspDocument } from "./lsp-documents";
+import { abortSignalFor } from "./lsp-monaco";
+
+export interface SemanticTokensLegend {
+  tokenTypes: string[];
+  tokenModifiers: string[];
+}
+
+/** What a server advertises in `initialize`, as much of it as matters here. */
+export interface SemanticTokensCapability {
+  legend?: SemanticTokensLegend;
+  full?: boolean | { delta?: boolean };
+  range?: boolean;
+}
+
+/** The relative-encoded token array, straight off the wire. */
+interface LspSemanticTokens {
+  resultId?: string;
+  data: number[];
+}
+
+/** A server's answer to a delta request when nothing was rebuilt. */
+interface LspSemanticTokensDelta {
+  resultId?: string;
+  edits: Array<{ start: number; deleteCount: number; data?: number[] }>;
+}
+
+/**
+ * Keyed by language *and* legend, not by language alone.
+ *
+ * Two projects can be open on one language and served by different servers — a repository
+ * that pins its own `typescript-language-server` next to one that does not — and a semantic
+ * token is an index into a legend, so one provider decoding both projects colours one of them
+ * as some other, arbitrary set of token types. Nothing fails; the file is simply wrong.
+ * A provider per legend, each answering only for the models whose server uses it, is what
+ * lets both be right at once.
+ */
+const registrations = new Map<string, MonacoType.IDisposable>();
+
+function registrationKey(language: string, fingerprint: string): string {
+  return `${language}\u0000${fingerprint}`;
+}
+
+/**
+ * Read the legend a server offered, or nothing if it offered none.
+ *
+ * A server may advertise the provider without a legend, or with an empty one.
+ * Both mean there is nothing to decode with, so there is nothing to register.
+ */
+export function semanticTokensLegendOf(capabilities: Record<string, unknown>): SemanticTokensLegend | null {
+  const provider = capabilities.semanticTokensProvider as SemanticTokensCapability | undefined;
+  const legend = provider?.legend;
+  if (!legend || !Array.isArray(legend.tokenTypes) || legend.tokenTypes.length === 0) return null;
+  return { tokenTypes: legend.tokenTypes, tokenModifiers: legend.tokenModifiers ?? [] };
+}
+
+/** True when the server will answer `semanticTokens/full/delta`. */
+export function supportsDelta(capabilities: Record<string, unknown>): boolean {
+  const full = (capabilities.semanticTokensProvider as SemanticTokensCapability | undefined)?.full;
+  return typeof full === "object" && full?.delta === true;
+}
+
+/**
+ * Register the provider for a language served by a server with this legend.
+ *
+ * Idempotent: every editor mount calls it, and a second server for the same language adds a
+ * provider rather than replacing the first. Monaco asks each of them in turn and takes the
+ * first non-null answer, which is what makes "answer only for my own models" sufficient.
+ */
+export function registerSemanticTokens(
+  monaco: typeof MonacoType,
+  language: string,
+  legend: SemanticTokensLegend,
+): void {
+  const fingerprint = JSON.stringify(legend);
+  const key = registrationKey(language, fingerprint);
+  if (registrations.has(key)) return;
+
+  const disposable = monaco.languages.registerDocumentSemanticTokensProvider(language, {
+    getLegend: () => legend,
+
+    provideDocumentSemanticTokens: async (model, lastResultId, token) => {
+      const document = lspDocumentFor(model);
+      if (!document) return null;
+      // This provider decodes with `legend`. A model whose server uses a different one has
+      // to be left to that server's provider, or its indices are read against this table.
+      if (legendFingerprintOf(document) !== fingerprint) return null;
+
+      const result = await requestTokens(document, model, lastResultId, token);
+      if (!result) return null;
+
+      // Monaco's own encoding is LSP's, so the numbers need no rewriting — only
+      // the array type differs.
+      if ("edits" in result) {
+        return {
+          resultId: result.resultId,
+          edits: result.edits.map((edit) => ({
+            start: edit.start,
+            deleteCount: edit.deleteCount,
+            data: edit.data ? new Uint32Array(edit.data) : undefined,
+          })),
+        };
+      }
+      return { resultId: result.resultId, data: new Uint32Array(result.data) };
+    },
+
+    // Nothing is held per result: the server keeps its own previous result under
+    // the id, and asking it to forget one is optional in the protocol.
+    releaseDocumentSemanticTokens: () => {},
+  });
+
+  registrations.set(key, disposable);
+}
+
+/** The legend the server behind this document is currently using, as a comparable string. */
+function legendFingerprintOf(document: LspDocument): string | null {
+  const status = document.connection.statusOf(document.path);
+  if (status?.state !== "ready") return null;
+  const legend = semanticTokensLegendOf(status.capabilities);
+  return legend ? JSON.stringify(legend) : null;
+}
+
+async function requestTokens(
+  document: LspDocument,
+  model: MonacoType.editor.ITextModel,
+  lastResultId: string | null,
+  token?: MonacoType.CancellationToken,
+): Promise<LspSemanticTokens | LspSemanticTokensDelta | null> {
+  const status = document.connection.statusOf(document.path);
+  if (status?.state !== "ready") return null;
+
+  const textDocument = { uri: model.uri.toString() };
+  const useDelta = Boolean(lastResultId) && supportsDelta(status.capabilities);
+  // The most expensive question in the file — a whole-document colouring, asked again on
+  // every edit — so it is the one most worth taking out of the server's queue when Monaco
+  // gives up on it.
+  const options = { signal: abortSignalFor(token) };
+
+  try {
+    if (useDelta) {
+      return await document.connection.request(document.path, "textDocument/semanticTokens/full/delta", {
+        textDocument,
+        previousResultId: lastResultId,
+      }, options);
+    }
+    return await document.connection.request(document.path, "textDocument/semanticTokens/full", {
+      textDocument,
+    }, options);
+  } catch {
+    // Same rule as every other provider: a rejection makes Monaco stop asking,
+    // and losing the colouring for the rest of the session is worse than one
+    // stale paint.
+    return null;
+  }
+}
+
+/** Drop every registration. Exported for tests; nothing in the app unregisters. */
+export function resetSemanticTokens(): void {
+  for (const disposable of registrations.values()) disposable.dispose();
+  registrations.clear();
+}