@telorun/ide-support 0.20.2 → 0.21.0

package/src/rename/build-rename.ts

@@ -9,14 +9,18 @@ import {
   type LoadedFile,
   type LoadedGraph,
   type LoadedModule,
+  type ManifestAnalysis,
+  type NameLevel,
   type Range,
 } from "@telorun/analyzer";
 
 import { chainAt } from "../cel-chain.js";
 import { resolveNodeAtPosition, scalarString } from "../completions/resolve-node.js";
 import { moduleDoc, moduleForFile, moduleFiles } from "../definition/manifest-navigation.js";
+import { moduleCallSites } from "../cel/module-calls.js";
 import {
   declarationSites,
+  functionCallSites,
   resourceDeclarations,
   resourceSites,
   stepDeclarations,
@@ -87,7 +91,7 @@ export function prepareRename(
     end: offsetToPosition(span[1], lineOffsets),
   });
 
-  const symbol = symbolAt(resolved, astDocs, toRange);
+  const symbol = symbolAt(resolved, astDocs, toRange, text, ownReceivers(mod));
   if (!symbol) return { ok: false, reason: "Nothing renameable here." };
   if ("reason" in symbol) return { ok: false, reason: symbol.reason };
 
@@ -104,6 +108,9 @@ export function buildRename(
   graph: LoadedGraph,
   currentFilePath: string,
   docs?: AstDocument[],
+  /** Decides whether a resource's name denotes a type (a named shape) or a
+   *  value. Without it every resource name is checked as a value. */
+  analysis?: ManifestAnalysis,
 ): RenameResult {
   const prepared = prepareRename(text, line, character, graph, currentFilePath, docs);
   if (!prepared.ok) return prepared;
@@ -111,19 +118,20 @@ export function buildRename(
 
   if (newName === symbol.name) return { ok: true, symbol, files: [] };
 
-  // Every renameable surface is value-level, so the new name is checked against
-  // that half of the convention — the same rule `telo check` enforces. Renaming
-  // *into* a name the analyzer would reject is a mistake worth catching in the
-  // rename box rather than as a squiggle afterwards.
-  const violation = checkName(newName, "value", surfaceLabel(symbol));
+  const mod = moduleForFile(graph, currentFilePath)!;
+
+  // The new name is checked against the half of the convention its declaration
+  // belongs to — the same rule `telo check` enforces. Renaming *into* a name the
+  // analyzer would reject is a mistake worth catching in the rename box rather
+  // than as a squiggle afterwards.
+  const violation = checkName(newName, nameLevelOf(symbol, mod, analysis), surfaceLabel(symbol));
   if (violation) return { ok: false, reason: violation.message };
 
-  const mod = moduleForFile(graph, currentFilePath)!;
   const files = filesForRename(symbol, mod, currentFilePath, text, docs);
 
   const out: RenameFileEdits[] = [];
   for (const file of files) {
-    const edits = editsIn(file, symbol, newName);
+    const edits = editsIn(file, symbol, newName, ownReceivers(mod));
     if (edits.length > 0) out.push({ uri: file.uri, edits });
   }
   if (out.length === 0) {
@@ -138,6 +146,26 @@ export function buildRename(
 
 type SymbolOrRefusal = RenameSymbol | { reason: string };
 
+/** Steps and config keys are values; a resource is whatever its capability makes
+ *  it — a named shape's name is a type. */
+function nameLevelOf(symbol: RenameSymbol, mod: LoadedModule, analysis: ManifestAnalysis | undefined): NameLevel {
+  if (symbol.kind !== "resource" || !analysis) return "value";
+  const sources = new Set(moduleFiles(mod).map((file) => file.source));
+  const declaration = analysis.manifests.find(
+    (m) =>
+      m.metadata?.name === symbol.name &&
+      sources.has((m.metadata as { source?: string } | undefined)?.source ?? ""),
+  );
+  return declaration ? analysis.nameLevel(declaration) : "value";
+}
+
+/** The receivers a module call names a function of THIS module through: `Self`
+ *  and the module's own name. */
+function ownReceivers(mod: LoadedModule): ReadonlySet<string> {
+  const name = (moduleDoc(mod) as { metadata?: { name?: unknown } } | undefined)?.metadata?.name;
+  return new Set(typeof name === "string" && name ? ["Self", name] : ["Self"]);
+}
+
 const DECLARATION_BLOCKS = new Set(["variables", "secrets", "ports"]);
 const MODULE_DOC_KINDS = new Set(["Telo.Application", "Telo.Library"]);
 const KIND_DOC_KINDS = new Set(["Telo.Definition", "Telo.Abstract"]);
@@ -150,8 +178,10 @@ function symbolAt(
   resolved: ReturnType<typeof resolveNodeAtPosition> & object,
   astDocs: AstDocument[],
   toRange: (span: [number, number]) => Range,
+  text: string,
+  receivers: ReadonlySet<string>,
 ): SymbolOrRefusal | undefined {
-  if (resolved.cel) return celSymbol(resolved.cel, toRange);
+  if (resolved.cel) return celSymbol(resolved.cel, toRange, text, receivers);
 
   const path = resolved.path;
   const node = resolved.node;
@@ -247,6 +277,8 @@ function symbolAt(
 function celSymbol(
   cel: { segment: { ast(): unknown; source: string }; offset: number },
   toRange: (span: [number, number]) => Range,
+  text: string,
+  receivers: ReadonlySet<string>,
 ): SymbolOrRefusal | undefined {
   let ast;
   try {
@@ -255,6 +287,11 @@ function celSymbol(
     if (!(error instanceof CelParseError)) throw error;
     return undefined;
   }
+  // A call of one of this module's functions renames the function resource.
+  const call = moduleCallSites(text, ast, (receiver) => receivers.has(receiver)).find(
+    (site) => cel.offset >= site.nameRange[0] && cel.offset <= site.nameRange[1],
+  );
+  if (call) return { kind: "resource", name: call.name, range: toRange(call.nameRange) };
   const hit = chainAt(ast, cel.offset);
   if (!hit || hit.index !== 1) return undefined;
   const root = hit.parts[0].name;
@@ -426,7 +463,12 @@ function filesForRename(
   return [];
 }
 
-function editsIn(file: RenameFile, symbol: RenameSymbol, newName: string): RenameEdit[] {
+function editsIn(
+  file: RenameFile,
+  symbol: RenameSymbol,
+  newName: string,
+  receivers: ReadonlySet<string>,
+): RenameEdit[] {
   const lineOffsets = buildLineOffsets(file.text);
   const spans: Array<[number, number]> = [];
 
@@ -434,6 +476,9 @@ function editsIn(file: RenameFile, symbol: RenameSymbol, newName: string): Renam
     if (symbol.kind === "resource") {
       for (const span of resourceDeclarations(doc, symbol.name)) spans.push(span);
       for (const site of resourceSites(doc, symbol.name)) spans.push(site.range);
+      for (const site of functionCallSites(doc, file.text, receivers, symbol.name)) {
+        spans.push(site.range);
+      }
       for (const span of exportEntrySpans(doc, symbol.name)) spans.push(span);
     } else if (symbol.kind === "step") {
       for (const span of stepDeclarations(doc, symbol.name)) spans.push(span);

package/src/rename/find-sites.ts

@@ -7,6 +7,7 @@ import {
 } from "@telorun/analyzer";
 
 import { walkCel } from "../cel-chain.js";
+import { moduleCallSites } from "../cel/module-calls.js";
 import { scalarString } from "../completions/resolve-node.js";
 
 /**
@@ -113,6 +114,35 @@ export function resourceSites(doc: AstDocument, name: string): NameSite[] {
   return sites;
 }
 
+/** A function's calls within one document: `<receiver>.<name>(…)` in CEL, for a
+ *  receiver naming the declaring module itself (`Self`, its own name). A call
+ *  through an import alias is another module's reference and is not matched.
+ *  `text` is the document text the CEL offsets are measured against. */
+export function functionCallSites(
+  doc: AstDocument,
+  text: string,
+  receivers: ReadonlySet<string>,
+  name: string,
+): NameSite[] {
+  const sites: NameSite[] = [];
+  if (!doc.root) return sites;
+  eachScalar(doc.root, (scalar) => {
+    for (const segment of scalar.celSegments()) {
+      let ast: CelNode;
+      try {
+        ast = segment.ast();
+      } catch (error) {
+        if (!(error instanceof CelParseError)) throw error;
+        continue;
+      }
+      for (const site of moduleCallSites(text, ast, (receiver) => receivers.has(receiver))) {
+        if (site.name === name) sites.push({ range: site.nameRange });
+      }
+    }
+  });
+  return sites;
+}
+
 /** A step's references within its declaring document: `steps.<name>` in CEL.
  *  Deliberately document-scoped — `steps.<name>.result` is readable only inside
  *  the resource whose body declares the step, and a resource is one document. */

package/src/signature-help/build-signature-help.ts

@@ -0,0 +1,100 @@
+/**
+ * Signature help inside a CEL body: the signature of the module call the cursor
+ * is writing the arguments of, with the argument under the cursor active.
+ *
+ * TEXTUAL, like completion's cursor chain, because it fires while the call is
+ * unfinished — `Billing.total(items, ` does not parse — and a parse-first
+ * approach would go silent exactly when help is asked for. The scan tracks
+ * brackets and string literals, so a comma inside a list or a quoted string is
+ * not an argument separator. Which receivers are modules, and what a call binds
+ * to, stay the analyzer's answers.
+ */
+import {
+  parseToAst,
+  type AstDocument,
+  type ManifestAnalysis,
+} from "@telorun/analyzer";
+import type { SignatureHelpResult } from "../types.js";
+import { bodyStart } from "../cel/cursor-chain.js";
+import { describeFunction, functionSignature } from "../cel/module-calls.js";
+import { resolveNodeAtPosition } from "../completions/resolve-node.js";
+import { docIdentity } from "../doc-identity.js";
+
+interface Frame {
+  /** `Receiver.name` for a call's parenthesis; undefined for any other bracket. */
+  call?: { receiver: string; name: string };
+  commas: number;
+}
+
+/** `Receiver.name` immediately before a `(`, where the receiver is a bare
+ *  identifier — not a member of something else, which templating reads as an
+ *  ordinary method call (`a.Billing.format(`). */
+const CALLEE = /(?<![\w.])([A-Za-z_][A-Za-z0-9_]*)\.([A-Za-z_][A-Za-z0-9_]*)\s*$/;
+
+/** The innermost bracket still open at the end of `source`. */
+function openFrame(source: string): Frame | undefined {
+  const stack: Frame[] = [];
+  for (let i = 0; i < source.length; i++) {
+    const c = source[i]!;
+    if (c === '"' || c === "'") {
+      // Skip the literal, honouring escapes; an unterminated one runs to the end.
+      for (i++; i < source.length && source[i] !== c; i++) {
+        if (source[i] === "\\") i++;
+      }
+      continue;
+    }
+    if (c === "(") {
+      const match = CALLEE.exec(source.slice(0, i));
+      stack.push({ ...(match ? { call: { receiver: match[1]!, name: match[2]! } } : {}), commas: 0 });
+    } else if (c === "[" || c === "{") {
+      stack.push({ commas: 0 });
+    } else if (c === ")" || c === "]" || c === "}") {
+      stack.pop();
+    } else if (c === "," && stack.length > 0) {
+      stack[stack.length - 1]!.commas++;
+    }
+  }
+  return stack[stack.length - 1];
+}
+
+export function buildSignatureHelp(
+  text: string,
+  line: number,
+  character: number,
+  docs: AstDocument[] | undefined,
+  analysis: ManifestAnalysis | undefined,
+): SignatureHelpResult | undefined {
+  const query = analysis?.celScope;
+  if (!query) return undefined;
+  const astDocs = docs ?? parseToAst(text);
+  const resolved = resolveNodeAtPosition(text, astDocs, line, character);
+  if (!resolved?.cel) return undefined;
+  const { segment, offset } = resolved.cel;
+
+  const start = bodyStart(text, segment);
+  const frame = openFrame(segment.source.slice(0, Math.max(0, offset - start)));
+  if (!frame?.call) return undefined;
+
+  const identity = docIdentity(astDocs[resolved.docIndex]);
+  const resource = query.resourceFor(identity.kind, identity.name);
+  if (!resource) return undefined;
+  const scope = query.scopeAt(resource, resolved.concretePath ?? "");
+  if (!scope.moduleNames.has(frame.call.receiver)) return undefined;
+  const qualified = `${frame.call.receiver}.${frame.call.name}`;
+  const fn = scope.moduleFunction(qualified);
+  if (!fn) return undefined;
+
+  const signature = functionSignature(qualified, fn);
+  const documentation = describeFunction(fn, scope.moduleCallFlags(qualified));
+  return {
+    signatures: [
+      {
+        label: signature.label,
+        parameters: signature.parameters,
+        ...(documentation ? { documentation } : {}),
+      },
+    ],
+    activeSignature: 0,
+    activeParameter: Math.min(frame.commas, Math.max(0, fn.params.length - 1)),
+  };
+}

package/src/signature-help/index.ts

@@ -0,0 +1 @@
+export { buildSignatureHelp } from "./build-signature-help.js";

package/src/types.ts

@@ -12,6 +12,7 @@ export type {
 
 import type {
   AnalysisRegistry,
+  DiagnosticFixTag,
   DiagnosticSeverity,
   DiagnosticTag,
   Position,
@@ -53,6 +54,19 @@ export interface HoverResult {
   range?: ReplaceRange;
 }
 
+/** Signature help for the call the cursor is inside. Each parameter's `label` is
+ *  its `[start, end]` span inside the signature's own `label`, the form both
+ *  VS Code and Monaco highlight the active parameter by. */
+export interface SignatureHelpResult {
+  signatures: Array<{
+    label: string;
+    documentation?: string;
+    parameters: Array<{ label: [number, number]; documentation?: string }>;
+  }>;
+  activeSignature: number;
+  activeParameter: number;
+}
+
 /** Semantic token type names emitted by `buildSemanticTokens`. Kept to the
  *  standard VS Code / LSP set so hosts register them against a stock legend and
  *  every theme colors them without extra configuration.
@@ -167,8 +181,9 @@ export interface NormalizedDiagnostic {
   source: string;
   message: string;
   /** Mechanically applicable repairs. `replacement` is the whole corrected
-   *  value at the diagnostic's range — apply it by replacing that range. */
-  suggestions?: Array<{ kind: "replace"; replacement: string }>;
+   *  value at the diagnostic's range — apply it by replacing that range,
+   *  rendered through `renderFixReplacement` with `tag` when one is present. */
+  suggestions?: Array<{ kind: "replace"; replacement: string; tag?: DiagnosticFixTag }>;
   /** LSP diagnostic tags, carried through verbatim. Orthogonal to `severity`:
    *  they say what KIND of thing the range is (deprecated, unnecessary), which
    *  is what a host renders as strikethrough or fading rather than as a colour. */