[lldb-dap] Refactor request handlers (NFC)

lldb/tools/lldb-dap/CMakeLists.txt

@@ -23,6 +23,7 @@ add_lldb_tool(lldb-dap
   Breakpoint.cpp
   BreakpointBase.cpp
   DAP.cpp
+  EventHelper.cpp
   ExceptionBreakpoint.cpp
   FifoFiles.cpp
   FunctionBreakpoint.cpp
@@ -36,6 +37,19 @@ add_lldb_tool(lldb-dap
   SourceBreakpoint.cpp
   Watchpoint.cpp
 
+  Handler/AttachRequestHandler.cpp
+  Handler/BreakpointLocationsHandler.cpp
+  Handler/CompletionsHandler.cpp
+  Handler/ConfigurationDoneRequestHandler.cpp
+  Handler/ContinueRequestHandler.cpp
+  Handler/DisconnectRequestHandler.cpp
+  Handler/EvaluateRequestHandler.cpp
+  Handler/ExceptionInfoRequestHandler.cpp
+  Handler/InitializeRequestHandler.cpp
+  Handler/LaunchRequestHandler.cpp
+  Handler/RequestHandler.cpp
+  Handler/RestartRequestHandler.cpp
+
   LINK_LIBS
     liblldb
     lldbHost
@@ -46,6 +60,8 @@ add_lldb_tool(lldb-dap
     Support
   )
 
+target_include_directories(lldb-dap PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
+
 if(LLDB_DAP_WELCOME_MESSAGE)
   target_compile_definitions(lldb-dap
     PRIVATE

lldb/tools/lldb-dap/DAP.cpp

@@ -757,16 +757,25 @@ bool DAP::HandleObject(const llvm::json::Object &object) {
   const auto packet_type = GetString(object, "type");
   if (packet_type == "request") {
     const auto command = GetString(object, "command");
+
+    // Try the new request handler first.
+    auto new_handler_pos = new_request_handlers.find(command);
+    if (new_handler_pos != new_request_handlers.end()) {
+      (*new_handler_pos->second)(object);
+      return true; // Success
+    }
+
+    // FIXME: Remove request_handlers once everything has been migrated.
     auto handler_pos = request_handlers.find(command);
-    if (handler_pos == request_handlers.end()) {
-      if (log)
-        *log << "error: unhandled command \"" << command.data() << "\""
-             << std::endl;
-      return false; // Fail
+    if (handler_pos != request_handlers.end()) {
+      handler_pos->second(*this, object);
+      return true; // Success
     }
 
-    handler_pos->second(*this, object);
-    return true; // Success
+    if (log)
+      *log << "error: unhandled command \"" << command.data() << "\""
+           << std::endl;
+    return false; // Fail
   }
 
   if (packet_type == "response") {

lldb/tools/lldb-dap/DAP.h

@@ -12,6 +12,7 @@
 #include "DAPForward.h"
 #include "ExceptionBreakpoint.h"
 #include "FunctionBreakpoint.h"
+#include "Handler/RequestHandler.h"
 #include "IOStream.h"
 #include "InstructionBreakpoint.h"
 #include "OutputRedirector.h"
@@ -37,6 +38,7 @@
 #include "llvm/Support/JSON.h"
 #include "llvm/Support/Threading.h"
 #include <map>
+#include <memory>
 #include <mutex>
 #include <optional>
 #include <thread>
@@ -185,6 +187,7 @@ struct DAP {
   lldb::pid_t restarting_process_id;
   bool configuration_done_sent;
   std::map<std::string, RequestCallback, std::less<>> request_handlers;
+  llvm::StringMap<std::unique_ptr<RequestHandler>> new_request_handlers;
   bool waiting_for_run_in_terminal;
   ProgressEventReporter progress_event_reporter;
   // Keep track of the last stop thread index IDs as threads won't go away
@@ -342,6 +345,12 @@ struct DAP {
   ///     IDE.
   void RegisterRequestCallback(std::string request, RequestCallback callback);
 
+  /// Registers a request handler.
+  template <typename Handler> void RegisterRequest() {
+    new_request_handlers[Handler::getCommand()] =
+        std::make_unique<Handler>(*this);
+  }
+
   /// Debuggee will continue from stopped state.
   void WillContinue() { variables.Clear(); }
 

lldb/tools/lldb-dap/EventHelper.cpp

@@ -0,0 +1,238 @@
+//===-- EventHelper.h -----------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "EventHelper.h"
+#include "DAP.h"
+#include "JSONUtils.h"
+#include "LLDBUtils.h"
+#include "lldb/API/SBFileSpec.h"
+
+namespace lldb_dap {
+
+static void SendThreadExitedEvent(DAP &dap, lldb::tid_t tid) {
+  llvm::json::Object event(CreateEventObject("thread"));
+  llvm::json::Object body;
+  body.try_emplace("reason", "exited");
+  body.try_emplace("threadId", (int64_t)tid);
+  event.try_emplace("body", std::move(body));
+  dap.SendJSON(llvm::json::Value(std::move(event)));
+}
+
+// "ProcessEvent": {
+//   "allOf": [
+//     { "$ref": "#/definitions/Event" },
+//     {
+//       "type": "object",
+//       "description": "Event message for 'process' event type. The event
+//                       indicates that the debugger has begun debugging a
+//                       new process. Either one that it has launched, or one
+//                       that it has attached to.",
+//       "properties": {
+//         "event": {
+//           "type": "string",
+//           "enum": [ "process" ]
+//         },
+//         "body": {
+//           "type": "object",
+//           "properties": {
+//             "name": {
+//               "type": "string",
+//               "description": "The logical name of the process. This is
+//                               usually the full path to process's executable
+//                               file. Example: /home/myproj/program.js."
+//             },
+//             "systemProcessId": {
+//               "type": "integer",
+//               "description": "The system process id of the debugged process.
+//                               This property will be missing for non-system
+//                               processes."
+//             },
+//             "isLocalProcess": {
+//               "type": "boolean",
+//               "description": "If true, the process is running on the same
+//                               computer as the debug adapter."
+//             },
+//             "startMethod": {
+//               "type": "string",
+//               "enum": [ "launch", "attach", "attachForSuspendedLaunch" ],
+//               "description": "Describes how the debug engine started
+//                               debugging this process.",
+//               "enumDescriptions": [
+//                 "Process was launched under the debugger.",
+//                 "Debugger attached to an existing process.",
+//                 "A project launcher component has launched a new process in
+//                  a suspended state and then asked the debugger to attach."
+//               ]
+//             }
+//           },
+//           "required": [ "name" ]
+//         }
+//       },
+//       "required": [ "event", "body" ]
+//     }
+//   ]
+// }
+void SendProcessEvent(DAP &dap, LaunchMethod launch_method) {
+  lldb::SBFileSpec exe_fspec = dap.target.GetExecutable();
+  char exe_path[PATH_MAX];
+  exe_fspec.GetPath(exe_path, sizeof(exe_path));
+  llvm::json::Object event(CreateEventObject("process"));
+  llvm::json::Object body;
+  EmplaceSafeString(body, "name", std::string(exe_path));
+  const auto pid = dap.target.GetProcess().GetProcessID();
+  body.try_emplace("systemProcessId", (int64_t)pid);
+  body.try_emplace("isLocalProcess", true);
+  const char *startMethod = nullptr;
+  switch (launch_method) {
+  case Launch:
+    startMethod = "launch";
+    break;
+  case Attach:
+    startMethod = "attach";
+    break;
+  case AttachForSuspendedLaunch:
+    startMethod = "attachForSuspendedLaunch";
+    break;
+  }
+  body.try_emplace("startMethod", startMethod);
+  event.try_emplace("body", std::move(body));
+  dap.SendJSON(llvm::json::Value(std::move(event)));
+}
+
+// Send a thread stopped event for all threads as long as the process
+// is stopped.
+void SendThreadStoppedEvent(DAP &dap) {
+  lldb::SBProcess process = dap.target.GetProcess();
+  if (process.IsValid()) {
+    auto state = process.GetState();
+    if (state == lldb::eStateStopped) {
+      llvm::DenseSet<lldb::tid_t> old_thread_ids;
+      old_thread_ids.swap(dap.thread_ids);
+      uint32_t stop_id = process.GetStopID();
+      const uint32_t num_threads = process.GetNumThreads();
+
+      // First make a pass through the threads to see if the focused thread
+      // has a stop reason. In case the focus thread doesn't have a stop
+      // reason, remember the first thread that has a stop reason so we can
+      // set it as the focus thread if below if needed.
+      lldb::tid_t first_tid_with_reason = LLDB_INVALID_THREAD_ID;
+      uint32_t num_threads_with_reason = 0;
+      bool focus_thread_exists = false;
+      for (uint32_t thread_idx = 0; thread_idx < num_threads; ++thread_idx) {
+        lldb::SBThread thread = process.GetThreadAtIndex(thread_idx);
+        const lldb::tid_t tid = thread.GetThreadID();
+        const bool has_reason = ThreadHasStopReason(thread);
+        // If the focus thread doesn't have a stop reason, clear the thread ID
+        if (tid == dap.focus_tid) {
+          focus_thread_exists = true;
+          if (!has_reason)
+            dap.focus_tid = LLDB_INVALID_THREAD_ID;
+        }
+        if (has_reason) {
+          ++num_threads_with_reason;
+          if (first_tid_with_reason == LLDB_INVALID_THREAD_ID)
+            first_tid_with_reason = tid;
+        }
+      }
+
+      // We will have cleared dap.focus_tid if the focus thread doesn't have
+      // a stop reason, so if it was cleared, or wasn't set, or doesn't exist,
+      // then set the focus thread to the first thread with a stop reason.
+      if (!focus_thread_exists || dap.focus_tid == LLDB_INVALID_THREAD_ID)
+        dap.focus_tid = first_tid_with_reason;
+
+      // If no threads stopped with a reason, then report the first one so
+      // we at least let the UI know we stopped.
+      if (num_threads_with_reason == 0) {
+        lldb::SBThread thread = process.GetThreadAtIndex(0);
+        dap.focus_tid = thread.GetThreadID();
+        dap.SendJSON(CreateThreadStopped(dap, thread, stop_id));
+      } else {
+        for (uint32_t thread_idx = 0; thread_idx < num_threads; ++thread_idx) {
+          lldb::SBThread thread = process.GetThreadAtIndex(thread_idx);
+          dap.thread_ids.insert(thread.GetThreadID());
+          if (ThreadHasStopReason(thread)) {
+            dap.SendJSON(CreateThreadStopped(dap, thread, stop_id));
+          }
+        }
+      }
+
+      for (auto tid : old_thread_ids) {
+        auto end = dap.thread_ids.end();
+        auto pos = dap.thread_ids.find(tid);
+        if (pos == end)
+          SendThreadExitedEvent(dap, tid);
+      }
+    } else {
+      if (dap.log)
+        *dap.log << "error: SendThreadStoppedEvent() when process"
+                    " isn't stopped ("
+                 << lldb::SBDebugger::StateAsCString(state) << ')' << std::endl;
+    }
+  } else {
+    if (dap.log)
+      *dap.log << "error: SendThreadStoppedEvent() invalid process"
+               << std::endl;
+  }
+  dap.RunStopCommands();
+}
+
+// Send a "terminated" event to indicate the process is done being
+// debugged.
+void SendTerminatedEvent(DAP &dap) {
+  // Prevent races if the process exits while we're being asked to disconnect.
+  llvm::call_once(dap.terminated_event_flag, [&] {
+    dap.RunTerminateCommands();
+    // Send a "terminated" event
+    llvm::json::Object event(CreateTerminatedEventObject(dap.target));
+    dap.SendJSON(llvm::json::Value(std::move(event)));
+  });
+}
+
+// Grab any STDOUT and STDERR from the process and send it up to VS Code
+// via an "output" event to the "stdout" and "stderr" categories.
+void SendStdOutStdErr(DAP &dap, lldb::SBProcess &process) {
+  char buffer[OutputBufferSize];
+  size_t count;
+  while ((count = process.GetSTDOUT(buffer, sizeof(buffer))) > 0)
+    dap.SendOutput(OutputType::Stdout, llvm::StringRef(buffer, count));
+  while ((count = process.GetSTDERR(buffer, sizeof(buffer))) > 0)
+    dap.SendOutput(OutputType::Stderr, llvm::StringRef(buffer, count));
+}
+
+// Send a "continued" event to indicate the process is in the running state.
+void SendContinuedEvent(DAP &dap) {
+  lldb::SBProcess process = dap.target.GetProcess();
+  if (!process.IsValid()) {
+    return;
+  }
+
+  // If the focus thread is not set then we haven't reported any thread status
+  // to the client, so nothing to report.
+  if (!dap.configuration_done_sent || dap.focus_tid == LLDB_INVALID_THREAD_ID) {
+    return;
+  }
+
+  llvm::json::Object event(CreateEventObject("continued"));
+  llvm::json::Object body;
+  body.try_emplace("threadId", (int64_t)dap.focus_tid);
+  body.try_emplace("allThreadsContinued", true);
+  event.try_emplace("body", std::move(body));
+  dap.SendJSON(llvm::json::Value(std::move(event)));
+}
+
+// Send a "exited" event to indicate the process has exited.
+void SendProcessExitedEvent(DAP &dap, lldb::SBProcess &process) {
+  llvm::json::Object event(CreateEventObject("exited"));
+  llvm::json::Object body;
+  body.try_emplace("exitCode", (int64_t)process.GetExitStatus());
+  event.try_emplace("body", std::move(body));
+  dap.SendJSON(llvm::json::Value(std::move(event)));
+}
+
+} // namespace lldb_dap

lldb/tools/lldb-dap/EventHelper.h

@@ -0,0 +1,33 @@
+//===-- EventHelper.h -----------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_TOOLS_LLDB_DAP_EVENTHELPER_H
+#define LLDB_TOOLS_LLDB_DAP_EVENTHELPER_H
+
+#include "DAPForward.h"
+
+namespace lldb_dap {
+struct DAP;
+
+enum LaunchMethod { Launch, Attach, AttachForSuspendedLaunch };
+
+void SendProcessEvent(DAP &dap, LaunchMethod launch_method);
+
+void SendThreadStoppedEvent(DAP &dap);
+
+void SendTerminatedEvent(DAP &dap);
+
+void SendStdOutStdErr(DAP &dap, lldb::SBProcess &process);
+
+void SendContinuedEvent(DAP &dap);
+
+void SendProcessExitedEvent(DAP &dap, lldb::SBProcess &process);
+
+} // namespace lldb_dap
+
+#endif