use capabilities event to determine SupportsModuleSymbolsRequest instead of lldb version

Author: eronnen

lldb/tools/lldb-dap/DAP.cpp

@@ -1258,6 +1258,27 @@ protocol::Capabilities DAP::GetCapabilities() {
   return capabilities;
 }
 
+protocol::Capabilities DAP::GetCustomCapabilities() {
+  protocol::Capabilities capabilities;
+
+  // Add all custom capabilities here.
+  const llvm::DenseSet<AdapterFeature> all_custom_features = {
+      protocol::eAdapterFeatureSupportsModuleSymbolsRequest,
+  };
+
+  for (auto &kv : request_handlers) {
+    llvm::SmallDenseSet<AdapterFeature, 1> features =
+        kv.second->GetSupportedFeatures();
+
+    for (auto &feature : features) {
+      if (all_custom_features.contains(feature))
+        capabilities.supportedFeatures.insert(feature);
+    }
+  }
+
+  return capabilities;
+}
+
 void DAP::StartEventThread() {
   event_thread = std::thread(&DAP::EventThread, this);
 }

lldb/tools/lldb-dap/DAP.h

@@ -367,6 +367,9 @@ struct DAP final : private DAPTransport::MessageHandler {
   /// The set of capabilities supported by this adapter.
   protocol::Capabilities GetCapabilities();
 
+  /// The set of custom capabilities supported by this adapter.
+  protocol::Capabilities GetCustomCapabilities();
+
   /// Debuggee will continue from stopped state.
   void WillContinue() { variables.Clear(); }
 

lldb/tools/lldb-dap/EventHelper.cpp

@@ -59,6 +59,14 @@ void SendTargetBasedCapabilities(DAP &dap) {
     dap.Send(protocol::Event{"capabilities", body});
 }
 
+void SendCustomCapabilities(DAP &dap) {
+  protocol::CapabilitiesEventBody body;
+  body.capabilities = dap.GetCustomCapabilities();
+
+  // Notify the client about the custom capabilities.
+  dap.Send(protocol::Event{"capabilities", body});
+}
+
 // "ProcessEvent": {
 //   "allOf": [
 //     { "$ref": "#/definitions/Event" },

lldb/tools/lldb-dap/EventHelper.h

@@ -20,6 +20,9 @@ enum LaunchMethod { Launch, Attach, AttachForSuspendedLaunch };
 /// Update capabilities based on the configured target.
 void SendTargetBasedCapabilities(DAP &dap);
 
+/// Send lldb-dap custom capabilities.
+void SendCustomCapabilities(DAP &dap);
+
 void SendProcessEvent(DAP &dap, LaunchMethod launch_method);
 
 llvm::Error SendThreadStoppedEvent(DAP &dap, bool on_entry = false);

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

@@ -46,6 +46,10 @@ ConfigurationDoneRequestHandler::Run(const ConfigurationDoneArguments &) const {
   // may have different capabilities than the final target.
   SendTargetBasedCapabilities(dap);
 
+  /// Send custom capabilities to the client.
+  /// This is consumed by the lldb-dap specific editor extension.
+  SendCustomCapabilities(dap);
+
   // Clients can request a baseline of currently existing threads after
   // we acknowledge the configurationDone request.
   // Client requests the baseline of currently existing threads after

lldb/tools/lldb-dap/Handler/RequestHandler.h

@@ -601,6 +601,9 @@ class ModuleSymbolsRequestHandler
 public:
   using RequestHandler::RequestHandler;
   static llvm::StringLiteral GetCommand() { return "moduleSymbols"; }
+  FeatureSet GetSupportedFeatures() const override {
+    return {protocol::eAdapterFeatureSupportsModuleSymbolsRequest};
+  }
   llvm::Expected<protocol::ModuleSymbolsResponseBody>
   Run(const protocol::ModuleSymbolsArguments &args) const override;
 };

lldb/tools/lldb-dap/Protocol/ProtocolTypes.cpp

@@ -335,6 +335,8 @@ static llvm::StringLiteral ToString(AdapterFeature feature) {
     return "supportsWriteMemoryRequest";
   case eAdapterFeatureTerminateDebuggee:
     return "supportTerminateDebuggee";
+  case eAdapterFeatureSupportsModuleSymbolsRequest:
+    return "supportsModuleSymbolsRequest";
   }
   llvm_unreachable("unhandled adapter feature.");
 }
@@ -406,6 +408,8 @@ bool fromJSON(const llvm::json::Value &Params, AdapterFeature &feature,
                 eAdapterFeatureValueFormattingOptions)
           .Case("supportsWriteMemoryRequest", eAdapterFeatureWriteMemoryRequest)
           .Case("supportTerminateDebuggee", eAdapterFeatureTerminateDebuggee)
+          .Case("supportsModuleSymbolsRequest",
+                eAdapterFeatureSupportsModuleSymbolsRequest)
           .Default(std::nullopt);
 
   if (!parsedFeature) {

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

@@ -242,8 +242,11 @@ enum AdapterFeature : unsigned {
   /// The debug adapter supports the `terminateDebuggee` attribute on the
   /// `disconnect` request.
   eAdapterFeatureTerminateDebuggee,
+  /// The debug adapter supports the `supportsModuleSymbols` request.
+  /// This request is a custom request of lldb-dap.
+  eAdapterFeatureSupportsModuleSymbolsRequest,
   eAdapterFeatureFirst = eAdapterFeatureANSIStyling,
-  eAdapterFeatureLast = eAdapterFeatureTerminateDebuggee,
+  eAdapterFeatureLast = eAdapterFeatureSupportsModuleSymbolsRequest,
 };
 bool fromJSON(const llvm::json::Value &, AdapterFeature &, llvm::json::Path);
 llvm::json::Value toJSON(const AdapterFeature &);

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

@@ -1,12 +1,17 @@
 import { DebugProtocol } from "@vscode/debugprotocol";
 import * as vscode from "vscode";
 
+export interface LLDBDapCapabilities extends DebugProtocol.Capabilities {
+  /** The debug adapter supports the `moduleSymbols` request. */
+  supportsModuleSymbolsRequest?: boolean;
+}
+
 /** A helper type for mapping event types to their corresponding data type. */
 // prettier-ignore
 interface EventMap {
   "module": DebugProtocol.ModuleEvent;
   "exited": DebugProtocol.ExitedEvent;
-  "initialized": DebugProtocol.InitializedEvent;
+  "capabilities": DebugProtocol.CapabilitiesEvent;
 }
 
 /** A type assertion to check if a ProtocolMessage is an event or if it is a specific event. */
@@ -40,7 +45,8 @@ export class DebugSessionTracker
   private modulesChanged = new vscode.EventEmitter<
     vscode.DebugSession | undefined
   >();
-  private sessionInitialized = new vscode.EventEmitter<vscode.DebugSession>();
+  private sessionGotCapabilities =
+      new vscode.EventEmitter<[ vscode.DebugSession, LLDBDapCapabilities ]>();
   private sessionExited = new vscode.EventEmitter<vscode.DebugSession>();
 
   /**
@@ -52,8 +58,9 @@ export class DebugSessionTracker
     this.modulesChanged.event;
 
   /** Fired when a debug session is initialized. */
-  onDidInitializeSession: vscode.Event<vscode.DebugSession> =
-    this.sessionInitialized.event;
+  onDidGetSessionCapabilities:
+      vscode.Event<[ vscode.DebugSession, LLDBDapCapabilities ]> =
+      this.sessionGotCapabilities.event;
 
   /** Fired when a debug session is exiting. */
   onDidExitSession: vscode.Event<vscode.DebugSession> =
@@ -159,8 +166,8 @@ export class DebugSessionTracker
       );
 
       this.sessionExited.fire(session);
-    } else if (isEvent(message, "initialized")) {
-      this.sessionInitialized.fire(session);
+    } else if (isEvent(message, "capabilities")) {
+      this.sessionGotCapabilities.fire([ session, message.body.capabilities ]);
     }
   }
 }

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

@@ -35,35 +35,18 @@ export class SymbolsProvider extends DisposableContext {
       },
     ));
 
-    this.tracker.onDidInitializeSession((session) => {
-      this.GetLLDBServerVersion(session).then((version) => {
-        if (version !== undefined) {
-          if (version[0] >= 22) {
-            vscode.commands.executeCommand("setContext", "lldb-dap.supportsModuleSymbolsRequest", true);
-          }
-        }
-      });
+    this.tracker.onDidGetSessionCapabilities(([ _session, capabilities ]) => {
+      if (capabilities.supportsModuleSymbolsRequest) {
+        vscode.commands.executeCommand(
+            "setContext", "lldb-dap.supportsModuleSymbolsRequest", true);
+      }
     });
 
     this.tracker.onDidExitSession((_session) => {
       vscode.commands.executeCommand("setContext", "lldb-dap.supportsModuleSymbolsRequest", false);
     });
   }
 
-  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" });
-
-    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) {