[lldb-dap] Support thread focused breakpoint mode for SourceBreakpoint

Summary:
This diff mainly did 2 things to support the breakpoint mode in `SourceBreakpoint`

- Return the `breakpointModes` in `Capabilities`
  - "Normal": this is an no-op, it will not change anything about source breakpoints
  - "threadFocused": this is the new mode we want to support for VSCode users; it will used the current "focused tid", which is usually the thread that users stopped on, or the specific thread that user selected to resume from.
  - Currently, the breakpoint modes only apply to `source`

- Handle the mode in `setBreakpoints` request.
  - Only when the `mode` field comes back as `threadFocused` that we will set the bp's thread id to `dap.focus_tid`
  - Do nothing otherwise

Test Plan:
VSCode already supports such capabilities and UI showed up after lldb-dap return `breakpointModes` in its capabilities.

 {F1968843974}
 {F1968844047}
 {F1968844097}
 https://pxl.cl/62NFt

And selecting the breakpoint mode `Thread Focused` will put a filter on the tid to the current stopped thread

 https://pxl.cl/62NFD

The setBreakpoints request will send the `mode`; The setBreakpoint response will return the `tid`
 {F1968849686}

Return empty `breakpointModes` if Single stopped event is turned off
https://pxl.cl/658p3
NOTE: There's an issue with the UI updates, once the capabilities is registered with VSCode, it seems we cann>
Tried using the `CapabilitiesEvent`, wasn't able to update the UI either.
cc. @NBlake

Reviewers: nblake, #lldb_team

Reviewed By: nblake

Subscribers: nblake, pdepetro, #lldb_team

Differential Revision: https://phabricator.intern.facebook.com/D66549375
Differential Revision: https://phabricator.intern.facebook.com/D66835436

Tags: accept2ship

Author: kusmour

lldb/tools/lldb-dap/Breakpoint.cpp

@@ -84,7 +84,9 @@ protocol::Breakpoint Breakpoint::ToProtocolBreakpoint() {
             1;
       }
     }
-
+    // Return the tid if the breakpoint is set for a specific thread
+    if (m_bp.GetThreadID() != LLDB_INVALID_THREAD_ID)
+      breakpoint.threadId = m_bp.GetThreadID();
     breakpoint.source = std::move(source);
   }
 

lldb/tools/lldb-dap/DAP.cpp

@@ -1224,6 +1224,13 @@ protocol::Capabilities DAP::GetCapabilities() {
   completion_characters.emplace_back("\t");
   capabilities.completionTriggerCharacters = std::move(completion_characters);
 
+  // Only allow breakpoint mode if we set single_stoppped_event until
+  // we support user specified thread id, as it will affect the value
+  // of the dap.focus_tid
+  if (configuration.singleStoppedEvent) {
+  capabilities.breakpointModes = CreateBreakpointModes();
+  }
+
   // Put in non-DAP specification lldb specific information.
   capabilities.lldbExtVersion = debugger.GetVersionString();
 
@@ -1497,6 +1504,11 @@ std::vector<protocol::Breakpoint> DAP::SetSourceBreakpoints(
 
       const auto [iv, inserted] =
           existing_breakpoints.try_emplace(bp_pos, src_bp);
+      // Set thread id filter to focus_tid if the mode is "threadFocused"
+      const auto breakpoint_mode = bp.mode.value_or("");
+      if (breakpoint_mode == "threadFocused" &&
+          this->focus_tid != LLDB_INVALID_THREAD_ID)
+        iv->second.SetThreadID(this->focus_tid);
       // We check if this breakpoint already exists to update it.
       if (inserted) {
         if (llvm::Error error = iv->second.SetBreakpoint(source)) {

lldb/tools/lldb-dap/JSONUtils.cpp

@@ -1291,4 +1291,60 @@ std::string JSONToString(const llvm::json::Value &json) {
   return data;
 }
 
+// "BreakpointMode": {
+//   "type": "object",
+//   "description": "A BreakpointMode is provided as a option when setting 
+//                   breakpoints on sources or instructions.",
+//   "properties": {
+//     "mode": {
+//       "type": "string",
+//       "description": "The internal ID of the mode. This value is passed 
+//                       to the setBreakpoints request."
+//     },
+//     "label": {
+//       "type": "string",
+//       "description": "The name of the breakpoint mode. This is shown in the UI."
+//     },
+//     "description": {
+//       "type": "string",
+//       "description": "An optional help text providing additional information about 
+//                       the breakpoint mode. This string is typically shown as a
+//                       hover and can be translated."
+//     }
+//     "appliesTo": {
+//       "type": "array",
+//       "items": {
+//         "$ref": "#/definitions/BreakpointModeApplicability"
+//       },
+//       "description": "Describes one or more type of breakpoint this mode applies to."
+//     }
+//   },
+//   "required": [ "mode", "label", "appliesTo" ]
+// }
+
+std::vector<protocol::BreakpointMode> CreateBreakpointModes() {
+  std::vector<protocol::BreakpointMode> breakpointModes;
+  std::vector<protocol::BreakpointModeApplicability> appliesTo;
+  appliesTo.emplace_back(protocol::BreakpointModeApplicability::eBreakpointModeApplicabilitySource);
+
+  // Currently we support "Normal" and "Thread Focused" modes for source bp
+  // where "Normal" is no-op, and "Thread Focused" will add filter for tid
+  // using the builtin dap.focus_tid
+  protocol::BreakpointMode normal{
+    "normal", // mode
+    "Normal", // label
+    "Regular source breakpoint", // description
+    appliesTo,
+  };
+  protocol::BreakpointMode threadFocused{
+    "threadFocused", // mode
+    "Thread Focus", // label 
+    "Breakpoint that will focus on the current selected thread.", // description
+    appliesTo,
+  };
+  breakpointModes.emplace_back(normal);
+  breakpointModes.emplace_back(threadFocused);
+  return breakpointModes;
+}
+
 } // namespace lldb_dap

lldb/tools/lldb-dap/JSONUtils.h

@@ -464,6 +464,13 @@ llvm::json::Object CreateInitializedEventObject(lldb::SBTarget &target);
 /// Convert a given JSON object to a string.
 std::string JSONToString(const llvm::json::Value &json);
 
+/// Create a "breakpointModes" JSON object that contains supported
+/// modes
+///
+/// \return
+///     A JSON object with breakpoint modes
+std::vector<protocol::BreakpointMode> CreateBreakpointModes();
+
 } // namespace lldb_dap
 
 #endif

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

@@ -560,6 +560,8 @@ struct Breakpoint {
   /// a breakpoint is verified or a specific reason is not known, the adapter
   /// should omit this property.
   std::optional<BreakpointReason> reason;
+  // The tid is breakpoint is set for a specific thread.
+  std::optional<lldb::tid_t> threadId;
 };
 bool fromJSON(const llvm::json::Value &, Breakpoint &, llvm::json::Path);
 llvm::json::Value toJSON(const Breakpoint &);