identifying lldb-dap version and using it in command context to enable symbols request

Author: eronnen

lldb/tools/lldb-dap/Handler/ModuleSymbolsRequestHandler.cpp

@@ -26,25 +26,23 @@ ModuleSymbolsRequestHandler::Run(const ModuleSymbolsArguments &args) const {
   ModuleSymbolsResponseBody response;
 
   lldb::SBModuleSpec module_spec;
-  if (args.moduleId) {
+  if (!args.moduleId.empty()) {
     llvm::SmallVector<uint8_t, 20> uuid_bytes;
-    if (!lldb_private::UUID::DecodeUUIDBytesFromString(*args.moduleId,
+    if (!lldb_private::UUID::DecodeUUIDBytesFromString(args.moduleId,
                                                        uuid_bytes)
              .empty())
       return llvm::make_error<DAPError>("Invalid module ID");
 
     module_spec.SetUUIDBytes(uuid_bytes.data(), uuid_bytes.size());
   }
 
-  if (args.moduleName) {
+  if (!args.moduleName.empty()) {
     lldb::SBFileSpec file_spec;
-    file_spec.SetFilename(args.moduleName->c_str());
+    file_spec.SetFilename(args.moduleName.c_str());
     module_spec.SetFileSpec(file_spec);
   }
 
   // Empty request, return empty response.
-  // We use it in the client to check if the lldb-dap server supports this
-  // request.
   if (!module_spec.IsValid())
     return response;
 

lldb/tools/lldb-dap/Protocol/ProtocolRequests.h

@@ -983,10 +983,10 @@ llvm::json::Value toJSON(const WriteMemoryResponseBody &);
 
 struct ModuleSymbolsArguments {
   /// The module UUID for which to retrieve symbols.
-  std::optional<std::string> moduleId;
+  std::string moduleId;
 
   /// The module path.
-  std::optional<std::string> moduleName;
+  std::string moduleName;
 };
 bool fromJSON(const llvm::json::Value &, ModuleSymbolsArguments &,
               llvm::json::Path);

lldb/tools/lldb-dap/package.json

@@ -289,7 +289,7 @@
         },
         {
           "command": "lldb-dap.debug.showSymbols",
-          "when": "debuggersAvailable && debugType == 'lldb-dap'"
+          "when": "debuggersAvailable && debugType == 'lldb-dap' && lldb-dap.supportsModuleSymbolsRequest"
         }
       ],
       "view/item/context": [
@@ -299,7 +299,7 @@
         },
         {
           "command": "lldb-dap.modules.showSymbols",
-          "when": "view == lldb-dap.modules && viewItem == module"
+          "when": "view == lldb-dap.modules && viewItem == module && lldb-dap.supportsModuleSymbolsRequest"
         }
       ]
     },

lldb/tools/lldb-dap/src-ts/debug-configuration-provider.ts

@@ -69,6 +69,10 @@ const configurations: Record<string, DefaultConfig> = {
   terminateCommands: { type: "stringArray", default: [] },
 };
 
+export function getDefaultConfigKey(key: string): string | number | boolean | string[] | undefined {
+  return configurations[key]?.default;
+}
+
 export class LLDBDapConfigurationProvider
   implements vscode.DebugConfigurationProvider
 {

lldb/tools/lldb-dap/src-ts/debug-session-tracker.ts

@@ -6,6 +6,7 @@ import * as vscode from "vscode";
 interface EventMap {
   "module": DebugProtocol.ModuleEvent;
   "exited": DebugProtocol.ExitedEvent;
+  "initialized": DebugProtocol.InitializedEvent;
 }
 
 /** A type assertion to check if a ProtocolMessage is an event or if it is a specific event. */
@@ -39,6 +40,8 @@ export class DebugSessionTracker
   private modulesChanged = new vscode.EventEmitter<
     vscode.DebugSession | undefined
   >();
+  private sessionInitialized = new vscode.EventEmitter<vscode.DebugSession>();
+  private sessionExited = new vscode.EventEmitter<vscode.DebugSession>();
 
   /**
    * Fired when modules are changed for any active debug session.
@@ -48,6 +51,14 @@ export class DebugSessionTracker
   onDidChangeModules: vscode.Event<vscode.DebugSession | undefined> =
     this.modulesChanged.event;
 
+  /** Fired when a debug session is initialized. */
+  onDidInitializeSession: vscode.Event<vscode.DebugSession> =
+    this.sessionInitialized.event;
+
+  /** Fired when a debug session is exiting. */
+  onDidExitSession: vscode.Event<vscode.DebugSession> =
+    this.sessionExited.event;
+
   constructor(private logger: vscode.LogOutputChannel) {
     this.onDidChangeModules(this.moduleChangedListener, this);
     vscode.debug.onDidChangeActiveDebugSession((session) =>
@@ -146,6 +157,10 @@ export class DebugSessionTracker
       this.logger.info(
         `Session "${session.name}" exited with code ${exitCode}`,
       );
+
+      this.sessionExited.fire(session);
+    } else if (isEvent(message, "initialized")) {
+      this.sessionInitialized.fire(session);
     }
   }
 }

lldb/tools/lldb-dap/src-ts/ui/symbols-provider.ts

@@ -5,6 +5,7 @@ import { DebugSessionTracker } from "../debug-session-tracker";
 import { DisposableContext } from "../disposable-context";
 
 import { DAPSymbolType } from "..";
+import { getDefaultConfigKey } from "../debug-configuration-provider";
 
 export class SymbolsProvider extends DisposableContext {
   constructor(
@@ -16,54 +17,64 @@ export class SymbolsProvider extends DisposableContext {
     this.pushSubscription(vscode.commands.registerCommand(
       "lldb-dap.debug.showSymbols",
       () => {
-        this.SelectModuleAndShowSymbols();
+        const session = vscode.debug.activeDebugSession;
+        if (!session) return;
+
+        this.SelectModuleAndShowSymbols(session);
       },
     ));
 
     this.pushSubscription(vscode.commands.registerCommand(
       "lldb-dap.modules.showSymbols",
       (moduleItem: DebugProtocol.Module) => {
         const session = vscode.debug.activeDebugSession;
-        if (!session) {
-            return;
-        }
+        if (!session) return;
+
         this.showSymbolsForModule(session, moduleItem);
       },
     ));
-  }
 
-  static async doesServerSupportSymbolsRequest(session: vscode.DebugSession): Promise<boolean> {
-    try {
-      const dummyArguments = { _dummy: true };
-      await session.customRequest("moduleSymbols", dummyArguments);
-      return true;
-    } catch (_error) {
-      return false;
-    }
+    this.tracker.onDidInitializeSession((session) => {
+      this.GetLLDBServerVersion(session).then((version) => {
+        if (version !== undefined) {
+          if (version[0] >= 23) {
+            vscode.commands.executeCommand("setContext", "lldb-dap.supportsModuleSymbolsRequest", true);
+          }
+        }
+      });
+    });
+
+    this.tracker.onDidExitSession((session) => {
+      vscode.commands.executeCommand("setContext", "lldb-dap.supportsModuleSymbolsRequest", false);
+    });
   }
 
-  private async SelectModuleAndShowSymbols() {
-    const session = vscode.debug.activeDebugSession;
-    if (!session) {
-        return;
-    }
+  private async GetLLDBServerVersion(session: vscode.DebugSession): Promise<[number, number, number] | undefined> {
+    const commandEscapePrefix = session.configuration.commandEscapePrefix || getDefaultConfigKey("commandEscapePrefix");
+    const response = await session.customRequest("evaluate", { expression: commandEscapePrefix + "version", context: "repl" });
 
-    if (!await SymbolsProvider.doesServerSupportSymbolsRequest(session)) {
-        vscode.window.showErrorMessage("The debug adapter does not support symbol requests.");
-        return;
-    }
+    const versionLine = response.result?.split("\n")[0];
+    if (!versionLine) return undefined;
+    
+    const versionMatch = versionLine.match(/(\d+)\.(\d+)\.(\d+)/);
+    if (!versionMatch) return undefined;
 
+    const [major, minor, patch] = versionMatch.slice(1, 4).map(Number);
+    return [major, minor, patch];
+  }
+
+  private async SelectModuleAndShowSymbols(session: vscode.DebugSession) {
     const modules = this.tracker.debugSessionModules(session);
     if (!modules || modules.length === 0) {
-        return;
+      return;
     }
 
     // Let the user select a module to show symbols for
     const selectedModule = await vscode.window.showQuickPick(modules.map(m => new ModuleQuickPickItem(m)), {
         placeHolder: "Select a module to show symbols for"
     });
     if (!selectedModule) {
-        return;
+      return;
     }
 
     this.showSymbolsForModule(session, selectedModule.module);
@@ -86,8 +97,7 @@ export class SymbolsProvider extends DisposableContext {
 
   private async getSymbolsForModule(session: vscode.DebugSession, moduleId: string): Promise<DAPSymbolType[]> {
     console.log(`Getting symbols for module: ${moduleId}`);
-    const symbols_response: { symbols: Array<DAPSymbolType> } = await session.customRequest("moduleSymbols", { moduleId });
-
+    const symbols_response: { symbols: Array<DAPSymbolType> } = await session.customRequest("moduleSymbols", { moduleId, moduleName: '' });
 
     return symbols_response?.symbols || [];
   }