Use lldb::user_id_t for target_id

Summary:
- Changed targetId type from uint32_t to lldb::user_id_t
- Added comprehensive documentation for StoreTargetById/TakeTargetById

Author: qxy11

lldb/test/API/tools/lldb-dap/attach/TestDAP_attach.py

@@ -82,4 +82,4 @@ def test_attach_with_invalid_targetId(self):
 
         resp = self.attach(targetId=99999, expectFailure=True)
         self.assertFalse(resp["success"])
-        self.assertIn("Unable to find existing target", resp["body"]["error"]["format"])
+        self.assertIn("invalid target_id 99999 in attach config", resp["body"]["error"]["format"])

lldb/tools/lldb-dap/DAP.cpp

@@ -1309,7 +1309,7 @@ void DAP::StartEventThreads() {
   StartEventThread();
 }
 
-llvm::Error DAP::InitializeDebugger(std::optional<uint32_t> target_id) {
+llvm::Error DAP::InitializeDebugger(std::optional<lldb::user_id_t> target_id) {
   // Initialize debugger instance (shared or individual).
   if (target_id) {
     std::optional<lldb::SBTarget> shared_target =
@@ -1569,7 +1569,7 @@ void DAP::EventThread() {
           auto target = lldb::SBTarget::GetTargetFromEvent(event);
 
           // Generate unique target ID and store the target for handoff.
-          uint32_t target_id = target.GetGloballyUniqueID();
+          lldb::user_id_t target_id = target.GetGloballyUniqueID();
           DAPSessionManager::GetInstance().StoreTargetById(target_id, target);
 
           // We create an attach config that will select the unique

lldb/tools/lldb-dap/DAP.h

@@ -431,7 +431,7 @@ struct DAP final : public DAPTransport::MessageHandler {
 
   /// Perform complete DAP initialization in one call.
   llvm::Error
-  InitializeDebugger(std::optional<uint32_t> target_idx = std::nullopt);
+  InitializeDebugger(std::optional<lldb::user_id_t> target_idx = std::nullopt);
 
   /// Start event handling threads based on client capabilities.
   void StartEventThreads();

lldb/tools/lldb-dap/DAPSessionManager.cpp

@@ -118,14 +118,14 @@ DAPSessionManager::GetEventThreadForDebugger(lldb::SBDebugger debugger,
   return new_thread_sp;
 }
 
-void DAPSessionManager::StoreTargetById(uint32_t target_id,
+void DAPSessionManager::StoreTargetById(lldb::user_id_t target_id,
                                         lldb::SBTarget target) {
   std::lock_guard<std::mutex> lock(m_sessions_mutex);
   m_target_map[target_id] = target;
 }
 
 std::optional<lldb::SBTarget>
-DAPSessionManager::TakeTargetById(uint32_t target_id) {
+DAPSessionManager::TakeTargetById(lldb::user_id_t target_id) {
   std::lock_guard<std::mutex> lock(m_sessions_mutex);
   auto pos = m_target_map.find(target_id);
   if (pos == m_target_map.end())

lldb/tools/lldb-dap/DAPSessionManager.h

@@ -72,10 +72,29 @@ class DAPSessionManager {
   llvm::Error WaitForAllSessionsToDisconnect();
 
   /// Store a target for later retrieval by another session.
-  void StoreTargetById(uint32_t target_id, lldb::SBTarget target);
+  ///
+  /// When a new target is dynamically created (e.g., via scripting hooks or
+  /// child process debugging), it needs to be handed off to a new DAP session.
+  /// This method stores the target in a temporary map using its globally unique
+  /// ID so that the new session can retrieve it via TakeTargetById().
+  ///
+  /// \param target_id The globally unique ID of the target (from
+  ///                  SBTarget::GetGloballyUniqueID()).
+  /// \param target The target to store.
+  void StoreTargetById(lldb::user_id_t target_id, lldb::SBTarget target);
 
   /// Retrieve and remove a stored target by its globally unique target ID.
-  std::optional<lldb::SBTarget> TakeTargetById(uint32_t target_id);
+  ///
+  /// This method is called during the attach request when a new DAP session
+  /// wants to attach to a dynamically created target. The target is removed
+  /// from the map after retrieval because:
+  /// 1. Each target should only be attached to by one DAP session
+  /// 2. Once attached, the DAP session takes ownership of the target
+  /// 3. Keeping the target in the map would prevent proper cleanup
+  ///
+  /// \param target_id The globally unique ID of the target to retrieve.
+  /// \return The target if found, std::nullopt otherwise.
+  std::optional<lldb::SBTarget> TakeTargetById(lldb::user_id_t target_id);
 
   /// Get or create event thread for a specific debugger.
   std::shared_ptr<ManagedEventThread>
@@ -112,7 +131,7 @@ class DAPSessionManager {
 
   /// Map from target ID to target for handing off newly created targets
   /// between sessions.
-  std::map<uint32_t, lldb::SBTarget> m_target_map;
+  std::map<lldb::user_id_t, lldb::SBTarget> m_target_map;
 
   /// Map from debugger ID to its event thread, used when multiple DAP sessions
   /// share the same debugger instance.

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

@@ -32,7 +32,7 @@ namespace lldb_dap {
 Error AttachRequestHandler::Run(const AttachRequestArguments &args) const {
   // Initialize DAP debugger and related components if not sharing previously
   // launched debugger.
-  std::optional<uint32_t> target_id = args.targetId;
+  std::optional<lldb::user_id_t> target_id = args.targetId;
   if (Error err = dap.InitializeDebugger(target_id))
     return err;
 
@@ -76,7 +76,7 @@ Error AttachRequestHandler::Run(const AttachRequestArguments &args) const {
     // Use the unique target ID to get the target.
     target = dap.debugger.FindTargetByGloballyUniqueID(*target_id);
     if (!target.IsValid()) {
-      error.SetErrorStringWithFormat("invalid target_id %u in attach config",
+      error.SetErrorStringWithFormat("invalid target_id %lu in attach config",
                                      *target_id);
     }
   } else {

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

@@ -350,7 +350,7 @@ struct AttachRequestArguments {
   std::string coreFile;
 
   /// Unique ID of an existing target to attach to.
-  std::optional<uint32_t> targetId;
+  std::optional<lldb::user_id_t> targetId;
 
   /// @}
 };