Prevent calling readline() or menu() from error handler

From R's perspective, the handler runs _after_ the error was emitted.
That's why the user is able to see the error message before the recover
prompt. From our perspective though, we have to run the handler _before_
emitting the error, because all executed code needs to nested in an
execution request so that we can properly match output to a prompt on
the frontend side. The Jupyter protocol does not really support orphan
side effects (streams, input requests).

Author: lionel-

crates/ark/src/interface.rs

@@ -906,6 +906,20 @@ impl RMain {
         }
 
         if let Some(exception) = self.take_exception() {
+            // We might get an input request if `readline()` or `menu()` is
+            // called in `options(error = )`. We respond to this with an error
+            // as this is not supported by Ark.
+            if matches!(info.kind, PromptKind::InputRequest) {
+                // Reset error so we can handle it when we recurse here after
+                // the error aborts the readline. Note it's better to first emit
+                // the R invalid input request error, and then handle
+                // `exception` within the context of a new `ReadConsole`
+                // instance, so that we emit the proper execution prompts as
+                // part of the response, and not the readline prompt.
+                self.last_error = Some(exception);
+                return self.handle_invalid_input_request_after_error();
+            }
+
             // Clear any pending inputs, if any
             self.pending_inputs = None;
 
@@ -1482,6 +1496,18 @@ impl RMain {
         return ConsoleResult::Error(message);
     }
 
+    fn handle_invalid_input_request_after_error(&self) -> ConsoleResult {
+        log::warn!("Detected invalid `input_request` after error (probably from `getOption('error')`). Preparing to throw an R error.");
+
+        let message = vec![
+            "Can't request input from the user at this time.",
+            "Are you calling `readline()` or `menu()` from `options(error = )`?",
+        ]
+        .join("\n");
+
+        return ConsoleResult::Error(message);
+    }
+
     fn start_debug(&mut self, debug_preserve_focus: bool) {
         match self.dap.stack_info() {
             Ok(stack) => {

crates/ark/tests/kernel.rs

@@ -824,7 +824,6 @@ fn test_env_vars() {
 fn test_execute_request_error_handler_failure() {
     let frontend = DummyArkFrontend::lock();
 
-    // Define the functions and set the error handler
     let code = r#"
 f <- function() g()
 g <- function() h()
@@ -855,6 +854,44 @@ ouch
     );
 }
 
+#[test]
+fn test_execute_request_error_handler_readline() {
+    let frontend = DummyArkFrontend::lock();
+
+    let code = r#"
+f <- function() g()
+g <- function() h()
+h <- function() stop("foo")
+options(error = function() menu("ouch"))
+"#;
+    frontend.execute_request_invisibly(code);
+
+    frontend.send_execute_request("f()", ExecuteRequestOptions::default());
+    frontend.recv_iopub_busy();
+    let input = frontend.recv_iopub_execute_input();
+    assert_eq!(input.code, "f()");
+
+    frontend.recv_iopub_stream_stdout("Enter an item from the menu, or 0 to exit\n");
+
+    frontend.recv_iopub_stream_stderr(
+        r#"The `getOption("error")` handler failed.
+This option was unset to avoid cascading errors.
+Caused by:
+Can't request input from the user at this time.
+Are you calling `readline()` or `menu()` from `options(error = )`?
+"#,
+    );
+
+    assert!(frontend.recv_iopub_execute_error().contains("foo"));
+    frontend.recv_iopub_idle();
+
+    assert_eq!(
+        frontend.recv_shell_execute_reply_exception(),
+        input.execution_count
+    );
+}
+
+#[test]
 /// Install a SIGINT handler for shutdown tests. This overrides the test runner
 /// handler so it doesn't cancel our test.
 fn install_sigint_handler() {