Keep track of verbatim URL for outward DAP messages

Author: lionel-

crates/ark/src/console/console_annotate.rs

@@ -940,9 +940,10 @@ pub unsafe extern "C-unwind" fn ps_annotate_source(
     // If there are no breakpoints for this file, return NULL to signal no
     // annotation needed. Scope the mutable borrow so we can re-borrow after.
     let annotated = {
-        let Some((_, breakpoints)) = dap_guard.breakpoints.get_mut(&uri_id) else {
+        let Some(entry) = dap_guard.breakpoints.get_mut(&uri_id) else {
             return Ok(harp::r_null());
         };
+        let breakpoints = &mut entry.breakpoints;
         if breakpoints.is_empty() {
             return Ok(harp::r_null());
         }
@@ -960,8 +961,10 @@ pub unsafe extern "C-unwind" fn ps_annotate_source(
     // Remove disabled breakpoints. Their verification state is now stale since
     // they weren't injected during this annotation. If the user re-enables
     // them, they'll be treated as new unverified breakpoints.
-    if let Some((_, breakpoints)) = dap_guard.breakpoints.get_mut(&uri_id) {
-        breakpoints.retain(|bp| !matches!(bp.state, BreakpointState::Disabled));
+    if let Some(entry) = dap_guard.breakpoints.get_mut(&uri_id) {
+        entry
+            .breakpoints
+            .retain(|bp| !matches!(bp.state, BreakpointState::Disabled));
     }
 
     Ok(RObject::from(annotated).sexp)

crates/ark/src/console/console_repl.rs

@@ -1534,7 +1534,7 @@ impl Console {
                 let breakpoints = uri_id
                     .as_ref()
                     .and_then(|uri_id| dap_guard.breakpoints.get_mut(uri_id))
-                    .map(|(_, v)| v.as_mut_slice());
+                    .map(|entry| entry.breakpoints.as_mut_slice());
 
                 match PendingInputs::read(&code, loc, breakpoints) {
                     Ok(ParseResult::Success(inputs)) => {

crates/ark/src/dap/dap_jupyter_handler.rs

@@ -186,12 +186,13 @@ impl DapJupyterHandler {
         let breakpoints: Vec<serde_json::Value> = state
             .breakpoints
             .iter()
-            .map(|(uri, (_, bps))| {
-                let source = uri
-                    .as_url()
-                    .to_file_path()
-                    .map_or_else(|_| uri.to_string(), |p| p.to_string_lossy().into_owned());
-                let source_breakpoints: Vec<serde_json::Value> = bps
+            .map(|(_, entry)| {
+                // Echo the verbatim path the frontend sent rather than the
+                // normalized key, so it sees back its own bytes (e.g. its
+                // Windows drive-letter casing).
+                let source = entry.verbatim_path.clone();
+                let source_breakpoints: Vec<serde_json::Value> = entry
+                    .breakpoints
                     .iter()
                     .filter(|bp| !matches!(bp.state, BreakpointState::Disabled))
                     .map(|bp| {

crates/ark/src/dap/dap_server.rs

@@ -36,6 +36,7 @@ use stdext::result::ResultExt;
 use stdext::spawn;
 
 use super::dap_state::Breakpoint;
+use super::dap_state::BreakpointEntry;
 use super::dap_state::BreakpointState;
 use super::dap_state::Dap;
 use super::dap_state::DapBackendEvent;
@@ -293,7 +294,7 @@ impl DapHandler {
         // changed after a reconnection, the breakpoints are no longer valid.
         let doc_hash = blake3::hash(doc_content.as_bytes());
         let doc_changed = match &old_breakpoints {
-            Some((existing_hash, _)) => existing_hash != &doc_hash,
+            Some(entry) => entry.hash != doc_hash,
             None => true,
         };
 
@@ -322,7 +323,7 @@ impl DapHandler {
             log::trace!("DAP: Document unchanged for {uri}, preserving breakpoint states");
 
             // Unwrap Safety: `doc_changed` is false, so `old_breakpoints` is Some
-            let (_, old_breakpoints) = old_breakpoints.unwrap();
+            let old_breakpoints = old_breakpoints.unwrap().breakpoints;
             // Use original_line for lookup since that's what the frontend sends back
             let mut old_by_line: HashMap<u32, Breakpoint> = old_breakpoints
                 .into_iter()
@@ -426,7 +427,11 @@ impl DapHandler {
             })
             .collect();
 
-        state.breakpoints.insert(uri, (doc_hash, new_breakpoints));
+        state.breakpoints.insert(uri, BreakpointEntry {
+            verbatim_path: path.clone(),
+            hash: doc_hash,
+            breakpoints: new_breakpoints,
+        });
 
         drop(state);
 
@@ -1009,6 +1014,14 @@ fn into_dap_frame(frame: &FrameInfo, fallback_sources: &HashMap<String, String>)
     // Retrieve either `path` or `source_reference` depending on the `source` type.
     // In the `Text` case, a `source_reference` should always exist because we loaded
     // the map with all possible text values in `start_debug()`.
+    //
+    // We report R's view of the path (the srcref filename), not the verbatim
+    // path the frontend sent for a breakpoint. A breakpoint's `verbatim_path` can
+    // differ (e.g. a symlinked path that R resolved through `normalizePath()`),
+    // and we could match a frame back to it through `BreakpointMap`'s canonical
+    // index. But that would only reach files that happen to have a breakpoint,
+    // so a frame's path would flip form depending on whether a breakpoint is
+    // set. Using R's path keeps every frame consistent regardless.
     let path = match source {
         FrameSource::File(path) => Some(path),
         FrameSource::Text(source) => fallback_sources.get(&source).cloned().or_else(|| {