Rename to is_debugging_stdin

Author: lionel-

crates/ark/src/console/console_repl.rs

@@ -869,15 +869,15 @@ impl Console {
                 return result;
             }
 
-            // In notebook mode, unexpected browser() or debug() calls (i.e.
-            // without an active debug session) are routed to stdin so the user
-            // can type debug commands in an input box rather than hanging.
+            // In notebook mode, `browser()` or `debug()` calls causing a
+            // browser prompt outside of an active debugging session are routed
+            // to stdin so the user can type debug commands in an input box.
             if self.session_mode == SessionMode::Notebook &&
                 !self.debug_dap.lock().unwrap().is_connected
             {
-                self.debug_dap.lock().unwrap().is_stopped_at_browser = true;
+                self.debug_dap.lock().unwrap().is_debugging_stdin = true;
                 let result = self.handle_input_request(&info, buf, buflen);
-                self.debug_dap.lock().unwrap().is_stopped_at_browser = false;
+                self.debug_dap.lock().unwrap().is_debugging_stdin = false;
                 return result;
             }
 
@@ -994,21 +994,17 @@ impl Console {
         // package. 50ms seems to be more in line with RStudio (posit-dev/positron#7235).
         let polled_events_rx = crossbeam::channel::tick(Duration::from_millis(50));
 
-        // This is the main kind of message from the frontend that we are expecting.
-        // We either wait for `input_reply` messages on StdIn, or for
-        // `execute_request` on Shell.
-        let (r_request_index, stdin_reply_index) = match wait_for {
-            WaitFor::ExecuteRequest => (Some(select.recv(&r_request_rx)), None),
-            WaitFor::InputReply => {
-                // In notebook mode, also listen for debug commands (e.g. Quit
-                // from the interrupt handler) while waiting for stdin input.
-                let r_request_index = if self.session_mode == SessionMode::Notebook {
-                    Some(select.recv(&r_request_rx))
-                } else {
-                    None
-                };
-                (r_request_index, Some(select.recv(&stdin_reply_rx)))
-            },
+        // This is the main kind of message from the frontend that we are
+        // expecting. We either wait for `input_reply` messages on StdIn, or for
+        // `execute_request` on Shell. We also listen for R requests, including
+        // while waiting on StdIn. Such requests are only expected in Notebook
+        // mode when debugging via StdIn. The interrupt handler may send us a
+        // Quit command to terminate the debugging session. For simplicity we
+        // listen for these requests unconditionally, including in Console sessions.
+        let r_request_index = select.recv(&r_request_rx);
+        let stdin_reply_index = match wait_for {
+            WaitFor::ExecuteRequest => None,
+            WaitFor::InputReply => Some(select.recv(&stdin_reply_rx)),
         };
 
         let kernel_request_index = select.recv(&kernel_request_rx);
@@ -1072,16 +1068,16 @@ impl Console {
 
             match oper.index() {
                 // We've got an execute request from the frontend
-                i if Some(i) == r_request_index => {
+                i if i == r_request_index => {
                     let req = oper.recv(&r_request_rx);
                     let Ok(req) = req else {
                         // The channel is disconnected and empty
                         return ConsoleResult::Disconnected;
                     };
 
-                    // During stdin-browser (notebook mode, waiting for input
-                    // at a browser prompt), the interrupt handler sends
-                    // DebugCommand(Quit) to exit the browser cleanly.
+                    // When debugging via StdIn in notebook mode, waiting for
+                    // input at a browser prompt, the interrupt handler may send
+                    // a Quit command to exit the browser cleanly.
                     if matches!(wait_for, WaitFor::InputReply) {
                         if let RRequest::DebugCommand(ref cmd) = req {
                             let input = crate::request::debug_request_command(cmd.clone());

crates/ark/src/control.rs

@@ -92,7 +92,7 @@ impl ControlHandler for Control {
         // debugging on interrupt is natural UX in that context.
         if matches!(self.session_mode, SessionMode::Notebook) {
             let dap = self.dap.lock().unwrap();
-            if dap.is_debugging || dap.is_stopped_at_browser {
+            if dap.is_debugging || dap.is_debugging_stdin {
                 drop(dap);
                 self.r_request_tx
                     .send(RRequest::DebugCommand(crate::request::DebugRequest::Quit))

crates/ark/src/dap/dap_state.rs

@@ -224,6 +224,13 @@ pub struct Dap {
     /// Whether the REPL is stopped with a browser prompt.
     pub is_debugging: bool,
 
+    /// Whether R is stopped at an unexpected `browser()` prompt in notebook
+    /// mode (no active debug session). Mutually exclusive with `is_debugging`.
+    /// Used by the interrupt handler to decide whether to send a "Q" command.
+    /// `id_debugging` and `is_stopped_at_browser` could be folded into a single
+    /// enum in the future.
+    pub is_debugging_stdin: bool,
+
     /// Whether the DAP server is connected to a client.
     pub is_connected: bool,
 
@@ -273,12 +280,6 @@ pub struct Dap {
     /// Whether an interrupt was sent to drop into the debugger
     pub(crate) is_interrupting_for_debugger: bool,
 
-    /// Whether R is stopped at a browser prompt in notebook mode
-    /// (either a debug session breakpoint or an unexpected browser()
-    /// routed to stdin). Used by the interrupt handler to decide
-    /// whether to send a "Q" command.
-    pub(crate) is_stopped_at_browser: bool,
-
     /// Channel for sending events to the comm frontend.
     comm_tx: Option<CommOutgoingTx>,
 
@@ -301,6 +302,7 @@ impl Dap {
     pub fn new_shared(r_request_tx: Sender<RRequest>) -> Arc<Mutex<Self>> {
         let state = Self {
             is_debugging: false,
+            is_debugging_stdin: false,
             is_connected: false,
             backend_events_tx: None,
             stack: None,
@@ -317,7 +319,6 @@ impl Dap {
             r_request_tx,
             shared_self: None,
             is_interrupting_for_debugger: false,
-            is_stopped_at_browser: false,
         };
 
         let shared = Arc::new(Mutex::new(state));
@@ -872,7 +873,7 @@ mod tests {
             comm_tx: None,
             iopub_tx: None,
             iopub_seq: 0,
-            is_stopped_at_browser: false,
+            is_debugging_stdin: false,
             r_request_tx,
             shared_self: None,
         };
@@ -986,7 +987,7 @@ mod tests {
             comm_tx: None,
             iopub_tx: None,
             iopub_seq: 0,
-            is_stopped_at_browser: false,
+            is_debugging_stdin: false,
             r_request_tx,
             shared_self: None,
         };