Pulsar-Debugger: Accept source.path in SetBreakpointsRequest and SourceRequest.

Also breakpoints are now correctly unverified for files not used by the
running module, and VSCode shows breakpoints set outside of the debugging
session.

Author: Marco4413

include/pulsar-debugger/types.h

@@ -74,6 +74,8 @@ namespace PulsarDebugger
         std::optional<Pulsar::String> GetSourcePath(SourceReference sourceReference) const;
         std::optional<Pulsar::String> GetSourceContent(SourceReference sourceReference) const;
 
+        SourceReference FindSourceReferenceForPath(const char* path) const;
+
         // TODO: This may be optimized by batching
         // void FilterReachableLines(SourceReference sourceReference, Pulsar::List<size_t>& lines) const;
 

src/pulsar-debugger/dapserver.cpp

@@ -166,28 +166,54 @@ DAPServer::DAPServer(Session& session, LogFile logFile)
 
     m_Session->registerHandler([this](const dap::SetBreakpointsRequest& req) -> dap::ResponseOrError<dap::SetBreakpointsResponse>
     {
-        if (!req.source.sourceReference) {
-            return dap::Error("Only source.sourceReference is supported for SetBreakpointsRequest.");
+        auto debuggableModule = this->m_Debugger.GetModule();
+        SourceReference sourceReference = req.source.sourceReference.value(NULL_REFERENCE);
+        if (!req.source.sourceReference && req.source.path) {
+            if (debuggableModule) {
+                sourceReference = debuggableModule->FindSourceReferenceForPath(req.source.path->c_str());
+            }
         }
 
         dap::SetBreakpointsResponse res;
-        this->m_Debugger.ClearBreakpoints(*req.source.sourceReference);
-        
-        if (req.breakpoints) {
-            res.breakpoints.resize(req.breakpoints->size());
-
-            for (size_t i = 0; i < req.breakpoints->size(); ++i) {
-                const auto& reqBreakpoint = (*req.breakpoints)[i];
-                auto& resBreakpoint = res.breakpoints[i];
-                
-                auto breakpointError = this->m_Debugger.SetBreakpoint(
-                        *req.source.sourceReference,
-                        this->m_LinesStartAt1
-                            ? static_cast<size_t>(reqBreakpoint.line-1)
-                            : static_cast<size_t>(reqBreakpoint.line));
-                resBreakpoint.verified = !breakpointError;
-                if (!resBreakpoint.verified)
-                    resBreakpoint.message = breakpointError->CString();
+        if (sourceReference == NULL_REFERENCE) {
+            if (req.breakpoints) {
+                res.breakpoints.resize(req.breakpoints->size());
+    
+                for (size_t i = 0; i < req.breakpoints->size(); ++i) {
+                    auto& resBreakpoint = res.breakpoints[i];
+                    resBreakpoint.verified = false;
+                    resBreakpoint.message  = "Source not loaded.";
+                }
+            }
+        } else {
+            this->m_Debugger.ClearBreakpoints(sourceReference);
+
+            if (req.breakpoints) {
+                res.breakpoints.resize(req.breakpoints->size());
+    
+                for (size_t i = 0; i < req.breakpoints->size(); ++i) {
+                    const auto& reqBreakpoint = (*req.breakpoints)[i];
+                    auto& resBreakpoint = res.breakpoints[i];
+    
+                    if (debuggableModule) {
+                        dap::Source breakpointSource;
+                        breakpointSource.path = debuggableModule->GetSourcePath(sourceReference)->CString();
+                        breakpointSource.sourceReference = sourceReference;
+                        resBreakpoint.source = std::move(breakpointSource);
+                    }
+    
+                    auto breakpointError = this->m_Debugger.SetBreakpoint(
+                            sourceReference,
+                            this->m_LinesStartAt1
+                                ? static_cast<size_t>(reqBreakpoint.line-1)
+                                : static_cast<size_t>(reqBreakpoint.line));
+    
+                    resBreakpoint.verified = !breakpointError;
+                    if (!resBreakpoint.verified) {
+                        resBreakpoint.reason  = "failed";
+                        resBreakpoint.message = breakpointError->CString();
+                    }
+                }
             }
         }
 
@@ -231,13 +257,31 @@ DAPServer::DAPServer(Session& session, LogFile logFile)
 
     m_Session->registerHandler([this](const dap::SourceRequest& req) -> dap::ResponseOrError<dap::SourceResponse>
     {
-        auto source = this->GetSourceContent(req.sourceReference);
+        auto debuggableModule = this->m_Debugger.GetModule();
+        if (!debuggableModule) {
+            return dap::Error("No module is being debugged.");
+        }
+
+        SourceReference sourceReference = req.sourceReference;
+        if (req.source) {
+            if (req.source->sourceReference) {
+                sourceReference = *req.source->sourceReference;
+            } else if (req.source->path) {
+                sourceReference = debuggableModule->FindSourceReferenceForPath(req.source->path->c_str());
+            }
+        }
+
+        if (sourceReference == NULL_REFERENCE) {
+            return dap::Error("Could not find source.");
+        }
+
+        auto source = debuggableModule->GetSourceContent(sourceReference);
         if (!source) {
-            return dap::Error("Unknown source reference '%d'.", int(req.sourceReference));
+            return dap::Error("Unknown source reference '%d'.", int(sourceReference));
         }
 
         dap::SourceResponse res;
-        res.content = std::move(*source);
+        res.content = source->CString();
         return res;
     });
 

src/pulsar-debugger/types.cpp

@@ -1,5 +1,7 @@
 #include "pulsar-debugger/types.h"
 
+#include <filesystem>
+
 namespace PulsarDebugger
 {
 
@@ -143,4 +145,17 @@ std::optional<Pulsar::String> DebuggableModule::GetSourceContent(SourceReference
     return m_Module.SourceDebugSymbols[sourceReference].Source;
 }
 
+SourceReference DebuggableModule::FindSourceReferenceForPath(const char* path) const
+{
+    std::filesystem::path pathToSearch(path);
+    for (size_t uSourceReference = 0; uSourceReference < m_Module.SourceDebugSymbols.Size(); ++uSourceReference) {
+        std::filesystem::path candidatePath(m_Module.SourceDebugSymbols[uSourceReference].Path.CString());
+
+        std::error_code ec;
+        if (std::filesystem::equivalent(pathToSearch, candidatePath, ec) && !ec)
+            return static_cast<SourceReference>(uSourceReference);
+    }
+    return NULL_REFERENCE;
+}
+
 }