Fix issues with disabled breakpoints

Author: lionel-

crates/ark/src/console_annotate.rs

@@ -716,8 +716,11 @@ impl AnnotationRewriter<'_> {
         reason: InvalidReason,
     ) {
         for bp in self.breakpoints.iter_mut() {
-            let is_available =
-                !self.consumed.contains(&bp.id) && !matches!(bp.state, BreakpointState::Invalid(_));
+            let is_available = !self.consumed.contains(&bp.id) &&
+                !matches!(
+                    bp.state,
+                    BreakpointState::Invalid(_) | BreakpointState::Disabled
+                );
             if !is_available {
                 continue;
             }
@@ -898,6 +901,13 @@ pub unsafe extern "C-unwind" fn ps_annotate_source(code: SEXP, uri: SEXP) -> any
         dap_guard.notify_invalid_breakpoints(breakpoints);
     }
 
+    // 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) {
+        breakpoints.retain(|bp| !matches!(bp.state, BreakpointState::Disabled));
+    }
+
     Ok(RObject::try_from(annotated)?.sexp)
 }
 

crates/ark/src/dap/dap_server.rs

@@ -406,11 +406,15 @@ impl<R: Read, W: Write> DapServer<R, W> {
 
                 if let Some(old_bp) = old_by_line.remove(&line) {
                     // Breakpoint already exists at this line
-                    let new_state = match old_bp.state {
-                        // This breakpoint used to be verified, was disabled, and is now back online
-                        BreakpointState::Disabled => BreakpointState::Verified,
+                    let (new_state, injected) = match old_bp.state {
+                        // This breakpoint used to be verified, was disabled, and is now back
+                        // online. Restore to Verified immediately.
+                        BreakpointState::Disabled => (BreakpointState::Verified, old_bp.injected),
+                        // Invalid breakpoints are reset to Unverified so they can be
+                        // re-validated on next source.
+                        BreakpointState::Invalid(_) => (BreakpointState::Unverified, false),
                         // We preserve other states (verified or unverified)
-                        other => other,
+                        other => (other, old_bp.injected),
                     };
 
                     breakpoints.push(Breakpoint {
@@ -419,8 +423,7 @@ impl<R: Read, W: Write> DapServer<R, W> {
                         line: old_bp.line,
                         original_line: line,
                         state: new_state,
-                        // Preserve injected status from old breakpoint
-                        injected: old_bp.injected,
+                        injected,
                     });
                 } else {
                     // New breakpoints always start as Unverified, until they get evaluated once

crates/ark/src/interface.rs

@@ -101,6 +101,7 @@ use uuid::Uuid;
 use crate::console_annotate::annotate_input;
 use crate::console_debug::FrameInfoId;
 use crate::dap::dap::Breakpoint;
+use crate::dap::dap::BreakpointState;
 use crate::dap::dap::DapBackendEvent;
 use crate::dap::Dap;
 use crate::errors;
@@ -1464,6 +1465,16 @@ impl RMain {
                         dap_guard.notify_invalid_breakpoints(bps);
                     }
                 }
+
+                // 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(uri) = &uri {
+                    if let Some((_, bps)) = dap_guard.breakpoints.get_mut(uri) {
+                        bps.retain(|bp| !matches!(bp.state, BreakpointState::Disabled));
+                    }
+                }
+
                 drop(dap_guard);
 
                 // Evaluate first expression if there is one