@elyracode/lsp-rust 0.9.19 → 0.9.20

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## [0.9.20] - 2026-07-19
+
+### Added
+- Auto-diagnostics and blast radius on edit: after an `edit`, the extension now also reports fresh Rust compiler errors for the edited file and lists call sites of the edited function/class in other files (via `textDocument/documentSymbol` + `references`), alongside the existing related-symbol summaries
+
 ## [0.9.19] - 2026-07-18
 
 ## [0.9.18] - 2026-07-18

package/extensions/index.ts

@@ -176,6 +176,82 @@ function summarizeHover(result: unknown): string | undefined {
 	return firstLine.length > 160 ? `${firstLine.slice(0, 160)}…` : firstLine;
 }
 
+// LSP SymbolKind values that can meaningfully own a blast radius:
+// Class, Method, Constructor, Enum, Interface, Function, Variable, Constant, Struct.
+const BLAST_SYMBOL_KINDS = new Set([5, 6, 9, 10, 11, 12, 13, 14, 23]);
+
+interface FlatSymbol {
+	name: string;
+	kind: number;
+	startLine: number;
+	endLine: number;
+	depth: number;
+	/** 0-based position of the symbol's name (for references lookups). */
+	selLine: number;
+	selChar: number;
+}
+
+/** Flatten a documentSymbol response (hierarchical DocumentSymbol[] or flat SymbolInformation[]). */
+function flattenSymbols(result: unknown): FlatSymbol[] {
+	if (!Array.isArray(result)) return [];
+	const out: FlatSymbol[] = [];
+	const walk = (nodes: unknown[], depth: number): void => {
+		for (const n of nodes) {
+			if (!n || typeof n !== "object") continue;
+			const sym = n as {
+				name?: unknown;
+				kind?: unknown;
+				range?: LspRange;
+				selectionRange?: LspRange;
+				location?: { range?: LspRange };
+				children?: unknown[];
+			};
+			const range = sym.range ?? sym.location?.range;
+			if (typeof sym.name === "string" && typeof sym.kind === "number" && range) {
+				const sel = sym.selectionRange ?? range;
+				out.push({
+					name: sym.name,
+					kind: sym.kind,
+					startLine: range.start.line,
+					endLine: range.end.line,
+					depth,
+					selLine: sel.start.line,
+					selChar: sel.start.character,
+				});
+			}
+			if (Array.isArray(sym.children)) walk(sym.children, depth + 1);
+		}
+	};
+	walk(result, 0);
+	return out;
+}
+
+/** Find the innermost symbol (by line span, then nesting depth) containing a 0-based line. */
+function findEnclosingSymbol(symbols: FlatSymbol[], line0: number): FlatSymbol | undefined {
+	let best: FlatSymbol | undefined;
+	for (const s of symbols) {
+		if (!BLAST_SYMBOL_KINDS.has(s.kind)) continue;
+		if (line0 < s.startLine || line0 > s.endLine) continue;
+		if (!best) {
+			best = s;
+			continue;
+		}
+		const bestSpan = best.endLine - best.startLine;
+		const span = s.endLine - s.startLine;
+		if (span < bestSpan || (span === bestSpan && s.depth > best.depth)) best = s;
+	}
+	return best;
+}
+
+/** True when the edit tool's own result already contains a diagnostics section. */
+function hasExistingDiagnostics(content: ReadonlyArray<unknown>): boolean {
+	return content.some((c) => {
+		if (!c || typeof c !== "object") return false;
+		const item = c as { type?: unknown; text?: unknown };
+		return item.type === "text" && typeof item.text === "string" && item.text.includes("\nDiagnostics (");
+	});
+}
+
 // ── Extension ───────────────────────────────────────────────────────────────
 
 export default function (elyra: ExtensionAPI): void {
@@ -187,6 +263,7 @@ export default function (elyra: ExtensionAPI): void {
 	let cwd = "";
 	const openedFiles = new Set<string>();
 	const diagnosticsByUri = new Map<string, LspDiagnostic[]>();
+	const diagnosticsWaiters = new Map<string, Array<() => void>>();
 
 	// ── JSON-RPC Client ─────────────────────────────────────────────────
 
@@ -275,6 +352,11 @@ export default function (elyra: ExtensionAPI): void {
 				if (msg.method === "textDocument/publishDiagnostics" && msg.params) {
 					const p = msg.params as { uri: string; diagnostics: LspDiagnostic[] };
 					diagnosticsByUri.set(p.uri, p.diagnostics);
+					const waiters = diagnosticsWaiters.get(p.uri);
+					if (waiters) {
+						diagnosticsWaiters.delete(p.uri);
+						for (const w of waiters) w();
+					}
 				}
 			}
 		}
@@ -316,6 +398,28 @@ export default function (elyra: ExtensionAPI): void {
 		openFile(filePath);
 	}
 
+	/** Resolve when the server publishes diagnostics for `uri`, or after `timeoutMs`. */
+	function waitForDiagnostics(uri: string, timeoutMs: number): Promise<void> {
+		return new Promise<void>((resolveWait) => {
+			const waiter = () => {
+				clearTimeout(timer);
+				resolveWait();
+			};
+			const timer = setTimeout(() => {
+				const arr = diagnosticsWaiters.get(uri);
+				if (arr) {
+					const remaining = arr.filter((w) => w !== waiter);
+					if (remaining.length > 0) diagnosticsWaiters.set(uri, remaining);
+					else diagnosticsWaiters.delete(uri);
+				}
+				resolveWait();
+			}, timeoutMs);
+			const list = diagnosticsWaiters.get(uri) ?? [];
+			list.push(waiter);
+			diagnosticsWaiters.set(uri, list);
+		});
+	}
+
 	function formatLocations(result: unknown, workingDir: string): string {
 		if (!result) return "No results found.";
 
@@ -540,7 +644,7 @@ export default function (elyra: ExtensionAPI): void {
 			},
 		});
 
-		// ── Hook: auto-context on edit (see "Symbol-aware auto-context" above) ──
+		// ── Hook: auto-context, auto-diagnostics, and blast radius on edit ──
 		elyra.on("tool_result", async (event) => {
 			if (!initialized || !isEditToolResult(event) || event.isError) return undefined;
 
@@ -554,14 +658,14 @@ export default function (elyra: ExtensionAPI): void {
 				const fileText = readFileSync(absPath, "utf-8");
 				const details = event.details as EditToolDetails | undefined;
 				const fromLine = details?.firstChangedLine ?? 1;
+				const uri = fileUri(absPath);
+				const sections: string[] = [];
 
+				// 1. Related symbols: hover summaries for referenced types.
 				const candidates = new Set<string>();
 				for (const edit of input.edits) {
 					for (const s of extractCandidateSymbols(edit.newText, RUST_SYMBOL_STOPLIST, 4)) candidates.add(s);
 				}
-				if (candidates.size === 0) return undefined;
-
-				const uri = fileUri(absPath);
 				const lookups = [...candidates].slice(0, 5).map(async (symbol) => {
 					const pos = findSymbolPosition(fileText, symbol, fromLine);
 					if (!pos) return undefined;
@@ -577,10 +681,67 @@ export default function (elyra: ExtensionAPI): void {
 					}
 				});
 
-				const lines = (await Promise.all(lookups)).filter((l): l is string => !!l);
-				if (lines.length === 0) return undefined;
+				// 2. Blast radius: references to the edited symbol outside this file.
+				const blastRadius = (async () => {
+					try {
+						const symbolResult = await sendRequest("textDocument/documentSymbol", {
+							textDocument: { uri },
+						});
+						const enclosing = findEnclosingSymbol(flattenSymbols(symbolResult), fromLine - 1);
+						if (!enclosing) return undefined;
+
+						const refsResult = await sendRequest("textDocument/references", {
+							textDocument: { uri },
+							position: { line: enclosing.selLine, character: enclosing.selChar },
+							context: { includeDeclaration: false },
+						});
+						if (!Array.isArray(refsResult)) return undefined;
+
+						const external = (refsResult as LspLocation[]).filter((loc) => uriToPath(loc.uri) !== absPath);
+						if (external.length === 0) return undefined;
+
+						const prefix = `${cwd}/`;
+						const shown = external.slice(0, 8).map((loc) => {
+							const p = uriToPath(loc.uri);
+							const rel = p.startsWith(prefix) ? p.slice(prefix.length) : p;
+							return `${rel}:${loc.range.start.line + 1}`;
+						});
+						const more = external.length > shown.length ? ` (+${external.length - shown.length} more)` : "";
+						return `${enclosing.name} is referenced in ${external.length} place${external.length === 1 ? "" : "s"} outside this file:\n${shown.map((s) => `- ${s}`).join("\n")}${more}`;
+					} catch {
+						return undefined;
+					}
+				})();
+
+				// 3. Fresh diagnostics for the edited file (skip if the edit tool already reported diagnostics).
+				const freshDiagnostics = (async () => {
+					if (hasExistingDiagnostics(event.content)) return undefined;
+					try {
+						await waitForDiagnostics(uri, 2500);
+						const errors = (diagnosticsByUri.get(uri) ?? []).filter((d) => (d.severity ?? 1) === 1);
+						if (errors.length === 0) return undefined;
+						const shown = errors.slice(0, 8).map((d) => {
+							const code = d.code ? ` [${d.code}]` : "";
+							return `- ${input.path}:${d.range.start.line + 1}:${d.range.start.character + 1}${code}: ${d.message.split("\n")[0]}`;
+						});
+						const more = errors.length > shown.length ? ` (+${errors.length - shown.length} more)` : "";
+						return `${errors.length} error${errors.length === 1 ? "" : "s"} in this file after the edit:\n${shown.join("\n")}${more}`;
+					} catch {
+						return undefined;
+					}
+				})();
+
+				const [hoverLines, blast, diag] = await Promise.all([Promise.all(lookups), blastRadius, freshDiagnostics]);
+
+				const related = hoverLines.filter((l): l is string => !!l);
+				if (diag) sections.push(`[Diagnostics — auto-checked via LSP]\n${diag}`);
+				if (blast) sections.push(`[Blast radius — auto-resolved via LSP]\n${blast}`);
+				if (related.length > 0) {
+					sections.push(`[Related symbols — auto-resolved via LSP, no extra tool call needed]\n${related.join("\n")}`);
+				}
+				if (sections.length === 0) return undefined;
 
-				const contextBlock = `\n\n[Related symbols — auto-resolved via LSP, no extra tool call needed]\n${lines.join("\n")}`;
+				const contextBlock = `\n\n${sections.join("\n\n")}`;
 				return { content: [...event.content, { type: "text" as const, text: contextBlock }] };
 			} catch {
 				return undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elyracode/lsp-rust",
-  "version": "0.9.19",
+  "version": "0.9.20",
   "description": "Rust LSP integration for Elyra — semantic code navigation and diagnostics via rust-analyzer",
   "type": "module",
   "keywords": [