refactor: gate palette command on javaLSReady, share frame parser, harden navigate

- Add a commandPalette when-clause (javaLSReady) to java.debug.analyzeStackTrace
  so it only shows once the Java language server is ready - matching where the
  linkify provider actually registers, and avoiding a dead-end scratch doc in
  non-Java windows.
- Extract the duplicated frame regex + parsing into stackFrameParser.ts, shared
  by the terminal and document link providers so matching stays identical. The
  helper builds a fresh RegExp per call, preserving the terminal provider's
  no-shared-stateful-RegExp contract.
- Wrap resolveSourceUri/navigation in navigateToStackFrame in try/catch (and
  await the navigation) so a not-ready/restarting language server can't surface
  an unhandled rejection.

Copilot-Session: d80e7a97-119d-4f89-a02a-be25b076e806

Author: wenytang-ms

package.json

@@ -239,6 +239,10 @@
         }
       ],
       "commandPalette": [
+        {
+          "command": "java.debug.analyzeStackTrace",
+          "when": "javaLSReady"
+        },
         {
           "command": "java.debug.hotCodeReplace",
           "when": "false"

src/stackFrameParser.ts

@@ -0,0 +1,43 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT license.
+
+// The single source of truth for parsing a Java stack frame, shared by the terminal link provider
+// and the document (stack-trace) link provider so the matching stays identical across surfaces.
+
+export interface IParsedStackFrame {
+    // The `com.foo.Bar.baz(Bar.java:42)` text handed to `resolveSourceUri` for source resolution.
+    stackTrace: string;
+    // The fully-qualified method (`com.foo.Bar.baz`), used for the class-name quick-pick fallback.
+    methodName: string;
+    // The 1-based source line number parsed from the frame.
+    lineNumber: number;
+    // Offset of the frame within the input line (points at the class name, past the leading `at `).
+    startIndex: number;
+    // Length of the linkifiable frame text (equals `stackTrace.length`).
+    length: number;
+}
+
+/**
+ * Parses the first Java stack frame (e.g. `at module/com.foo.Bar.baz(Bar.java:42)`) out of a line,
+ * or returns undefined when none is present.
+ *
+ * A fresh `RegExp` is created per call on purpose: provider callbacks can overlap asynchronously,
+ * so a shared stateful `RegExp` (were a `g`/`y` flag ever added) could corrupt `lastIndex`.
+ */
+export function parseJavaStackFrame(line: string): IParsedStackFrame | undefined {
+    // Group 2: optional module prefix, group 3: fully-qualified method, group 5: `File.java:line`.
+    const regex = /(\sat\s+)([\w$.]+\/)?(([\w$]+\.)+[<\w$>]+)\(([\w-$]+\.java:\d+)\)/;
+    const result = regex.exec(line);
+    if (!result || !result.length) {
+        return undefined;
+    }
+
+    const stackTrace = `${result[2] || ""}${result[3]}(${result[5]})`;
+    return {
+        stackTrace,
+        methodName: result[3],
+        lineNumber: Number(result[5].split(":")[1]),
+        startIndex: result.index + result[1].length,
+        length: stackTrace.length,
+    };
+}

src/stackTraceLinkProvider.ts

@@ -6,6 +6,7 @@ import { CancellationToken, commands, DocumentLink, DocumentLinkProvider, Docume
     window, workspace } from "vscode";
 import { instrumentOperationAsVsCodeCommand, sendInfo } from "vscode-extension-telemetry-wrapper";
 import { resolveSourceUri } from "./languageServerPlugin";
+import { parseJavaStackFrame } from "./stackFrameParser";
 import { getJavaExtensionAPI, isJavaExtEnabled, ServerMode } from "./utility";
 
 const ANALYZE_STACK_TRACE_COMMAND = "java.debug.analyzeStackTrace";
@@ -18,10 +19,6 @@ const STACK_TRACE_DOCUMENT_SELECTOR: DocumentSelector = [
     { scheme: "untitled" },
 ];
 
-// Matches a Java stack frame such as `at module/com.foo.Bar.baz(Bar.java:42)`.
-// Group 2: optional module prefix, group 3: fully-qualified method, group 5: `File.java:line`.
-const STACK_FRAME_REGEX = /(\sat\s+)([\w$.]+\/)?(([\w$]+\.)+[<\w$>]+)\(([\w-$]+\.java:\d+)\)/;
-
 // Guard against pathological input: cap the length of a scanned line (mitigates ReDoS on the
 // nested-quantifier regex) and the number of links produced for very large pasted traces.
 const MAX_SCANNED_LINE_LENGTH = 1000;
@@ -58,17 +55,21 @@ export class JavaStackTraceLinkProvider implements DocumentLinkProvider {
                 continue;
             }
 
-            const result = STACK_FRAME_REGEX.exec(lineText);
-            if (!result || !result.length) {
+            const frame = parseJavaStackFrame(lineText);
+            if (!frame) {
                 continue;
             }
 
-            const stackTrace = `${result[2] || ""}${result[3]}(${result[5]})`;
-            const lineNumber = Number(result[5].split(":")[1]);
-            const startIndex = result.index + result[1].length;
-            const range = new Range(new Position(i, startIndex), new Position(i, startIndex + stackTrace.length));
+            const range = new Range(
+                new Position(i, frame.startIndex),
+                new Position(i, frame.startIndex + frame.length),
+            );
 
-            const args: IStackFrameLinkArgs = { stackTrace, methodName: result[3], lineNumber };
+            const args: IStackFrameLinkArgs = {
+                stackTrace: frame.stackTrace,
+                methodName: frame.methodName,
+                lineNumber: frame.lineNumber,
+            };
             const target = Uri.parse(`command:${NAVIGATE_TO_STACK_FRAME_COMMAND}?${encodeURIComponent(JSON.stringify(args))}`);
             links.push(new DocumentLink(range, target));
         }
@@ -97,22 +98,28 @@ async function navigateToStackFrame(args: IStackFrameLinkArgs): Promise<void> {
      */
     sendInfo("", { operationName: "navigateToJavaStackFrame" });
 
-    const uri = await resolveSourceUri(args.stackTrace);
-    if (uri) {
-        const parsed = Uri.parse(uri);
-        if (!ALLOWED_SOURCE_SCHEMES.has(parsed.scheme)) {
-            return;
+    try {
+        const uri = await resolveSourceUri(args.stackTrace);
+        if (uri) {
+            const parsed = Uri.parse(uri);
+            if (!ALLOWED_SOURCE_SCHEMES.has(parsed.scheme)) {
+                return;
+            }
+            const targetLine = Math.max(args.lineNumber - 1, 0);
+            await window.showTextDocument(parsed, {
+                preserveFocus: true,
+                selection: new Range(new Position(targetLine, 0), new Position(targetLine, 0)),
+            });
+        } else {
+            // No source found: open the symbol quick pick scoped to the class name.
+            const fullyQualifiedName = args.methodName.substring(0, args.methodName.lastIndexOf("."));
+            const className = fullyQualifiedName.substring(fullyQualifiedName.lastIndexOf(".") + 1);
+            await commands.executeCommand("workbench.action.quickOpen", "#" + className);
         }
-        const targetLine = Math.max(args.lineNumber - 1, 0);
-        window.showTextDocument(parsed, {
-            preserveFocus: true,
-            selection: new Range(new Position(targetLine, 0), new Position(targetLine, 0)),
-        });
-    } else {
-        // No source found: open the symbol quick pick scoped to the class name.
-        const fullyQualifiedName = args.methodName.substring(0, args.methodName.lastIndexOf("."));
-        const className = fullyQualifiedName.substring(fullyQualifiedName.lastIndexOf(".") + 1);
-        commands.executeCommand("workbench.action.quickOpen", "#" + className);
+    } catch {
+        // The internal navigate command is always registered, but resolving a frame needs the Java
+        // language server in Standard mode. If it isn't (e.g. server restarting/downgraded) or the
+        // resolved document fails to open, fail quietly instead of surfacing an unhandled rejection.
     }
 }
 
@@ -124,7 +131,8 @@ async function analyzeStackTrace(): Promise<void> {
     // The command itself is auto-instrumented via instrumentOperationAsVsCodeCommand, so no
     // manual telemetry is needed here to track invocations.
     const clipboard = await env.clipboard.readText();
-    const content = STACK_FRAME_REGEX.test(clipboard.slice(0, MAX_CLIPBOARD_SCAN_LENGTH)) ? clipboard : "";
+    const looksLikeTrace = parseJavaStackFrame(clipboard.slice(0, MAX_CLIPBOARD_SCAN_LENGTH)) !== undefined;
+    const content = looksLikeTrace ? clipboard : "";
     const document = await workspace.openTextDocument({ language: "log", content });
     await window.showTextDocument(document);
 }

src/terminalLinkProvider.ts

@@ -5,6 +5,7 @@ import { CancellationToken, commands, Position, ProviderResult, Range, TerminalL
     TerminalLinkProvider, Uri, window } from "vscode";
 import { sendInfo } from "vscode-extension-telemetry-wrapper";
 import { resolveSourceUri } from "./languageServerPlugin";
+import { parseJavaStackFrame } from "./stackFrameParser";
 
 export class JavaTerminalLinkProvder implements TerminalLinkProvider<IJavaTerminalLink> {
     /**
@@ -17,17 +18,14 @@ export class JavaTerminalLinkProvder implements TerminalLinkProvider<IJavaTermin
      */
     public provideTerminalLinks(context: TerminalLinkContext, _token: CancellationToken): ProviderResult<IJavaTerminalLink[]> {
         const isDebuggerTerminal: boolean = context.terminal.name.startsWith("Run:") || context.terminal.name.startsWith("Debug:");
-        const regex = new RegExp("(\\sat\\s+)([\\w$\\.]+\\/)?(([\\w$]+\\.)+[<\\w$>]+)\\(([\\w-$]+\\.java:\\d+)\\)");
-        const result: RegExpExecArray | null = regex.exec(context.line);
-        if (result && result.length) {
-            const stackTrace = `${result[2] || ""}${result[3]}(${result[5]})`;
-            const sourceLineNumber = Number(result[5].split(":")[1]);
+        const frame = parseJavaStackFrame(context.line);
+        if (frame) {
             return [{
-                startIndex: result.index + result[1].length,
-                length: stackTrace.length,
-                methodName: result[3],
-                stackTrace,
-                lineNumber: sourceLineNumber,
+                startIndex: frame.startIndex,
+                length: frame.length,
+                methodName: frame.methodName,
+                stackTrace: frame.stackTrace,
+                lineNumber: frame.lineNumber,
                 isDebuggerTerminal,
             }];
         }