Detect being in the browser state when multiline input is sent to R one line at a time (#795)

Co-authored-by: Lionel Henry <[email protected]>

Author: DavisVaughan

crates/ark/src/interface.rs

@@ -707,7 +707,7 @@ impl RMain {
         buflen: c_int,
         _hist: c_int,
     ) -> ConsoleResult {
-        let info = Self::prompt_info(prompt);
+        let info = self.prompt_info(prompt);
         log::trace!("R prompt: {}", info.input_prompt);
 
         // Upon entering read-console, finalize any debug call text that we were capturing.
@@ -918,20 +918,27 @@ impl RMain {
     // We prefer to panic if there is an error while trying to determine the
     // prompt type because any confusion here is prone to put the frontend in a
     // bad state (e.g. causing freezes)
-    fn prompt_info(prompt_c: *const c_char) -> PromptInfo {
+    fn prompt_info(&self, prompt_c: *const c_char) -> PromptInfo {
         let n_frame = harp::session::r_n_frame().unwrap();
         log::trace!("prompt_info(): n_frame = '{n_frame}'");
 
         let prompt_slice = unsafe { CStr::from_ptr(prompt_c) };
         let prompt = prompt_slice.to_string_lossy().into_owned();
 
+        let continuation_prompt: String = harp::get_option("continue").try_into().unwrap();
+        let matches_continuation = prompt == continuation_prompt;
+
         // Detect browser prompt by matching the prompt string
         // https://github.com/posit-dev/positron/issues/4742.
         // There are ways to break this detection, for instance setting
         // `options(prompt =, continue = ` to something that looks like
         // a browser prompt, or doing the same with `readline()`. We have
         // chosen to not support these edge cases.
-        let browser = RE_DEBUG_PROMPT.is_match(&prompt);
+        // Additionally, we send code to R one line at a time, so even if we are debugging
+        // it can look like we are in a continuation state. To try and detect that, we
+        // detect if we matched the continuation prompt while the DAP is active.
+        let browser =
+            RE_DEBUG_PROMPT.is_match(&prompt) || (self.dap.is_debugging() && matches_continuation);
 
         // If there are frames on the stack and we're not in a browser prompt,
         // this means some user code is requesting input, e.g. via `readline()`
@@ -941,8 +948,6 @@ impl RMain {
         // we're in a user request, e.g. `readline("+ ")`. To guard against
         // this, we check that we are at top-level (call stack is empty or we
         // have a debug prompt).
-        let continuation_prompt: String = harp::get_option("continue").try_into().unwrap();
-        let matches_continuation = prompt == continuation_prompt;
         let top_level = n_frame == 0 || browser;
         let incomplete = matches_continuation && top_level;
 

crates/ark/tests/kernel.rs

@@ -250,6 +250,58 @@ fn test_execute_request_browser_incomplete() {
     assert_eq!(frontend.recv_shell_execute_reply(), input.execution_count);
 }
 
+// Test that a multiline input in the browser doesn't throw off our prompt info
+// detection logic https://github.com/posit-dev/positron/issues/5928
+#[test]
+fn test_execute_request_browser_multiline() {
+    let frontend = DummyArkFrontend::lock();
+
+    // Wrap in a function to get a frame on the stack so we aren't at top level.
+    // Careful to not send any newlines after `fn()`, as that advances the debugger!
+    let code = "
+fn <- function() {
+  browser()
+}
+fn()";
+    frontend.send_execute_request(code, ExecuteRequestOptions::default());
+    frontend.recv_iopub_busy();
+
+    let input = frontend.recv_iopub_execute_input();
+    assert_eq!(input.code, code);
+
+    // We aren't at top level, so this comes as an iopub stream
+    frontend.recv_iopub_stream_stdout("Called from: fn()\n");
+    frontend.recv_iopub_idle();
+
+    assert_eq!(frontend.recv_shell_execute_reply(), input.execution_count);
+
+    // Execute a multiline statement while paused in the debugger
+    let code = "1 +
+        1";
+    frontend.send_execute_request(code, ExecuteRequestOptions::default());
+    frontend.recv_iopub_busy();
+
+    let input = frontend.recv_iopub_execute_input();
+    assert_eq!(input.code, code);
+
+    // Also received as iopub stream because we aren't at top level, we are in the debugger
+    frontend.recv_iopub_stream_stdout("[1] 2\n");
+    frontend.recv_iopub_idle();
+
+    assert_eq!(frontend.recv_shell_execute_reply(), input.execution_count);
+
+    let code = "Q";
+    frontend.send_execute_request(code, ExecuteRequestOptions::default());
+    frontend.recv_iopub_busy();
+
+    let input = frontend.recv_iopub_execute_input();
+    assert_eq!(input.code, code);
+
+    frontend.recv_iopub_idle();
+
+    assert_eq!(frontend.recv_shell_execute_reply(), input.execution_count);
+}
+
 #[test]
 fn test_execute_request_browser_stdin() {
     let frontend = DummyArkFrontend::lock();