Remove RMain::initializing flag

And use `RMain::is_r_initialized()` instead

Author: lionel-

crates/ark/src/interface.rs

@@ -156,7 +156,6 @@ static R_INIT: once_cell::sync::OnceCell<()> = once_cell::sync::OnceCell::new();
 static mut R_MAIN: Option<RMain> = None;
 
 pub struct RMain {
-    initializing: bool,
     kernel_init_tx: Bus<KernelInfo>,
 
     /// Whether we are running in Console, Notebook, or Background mode.
@@ -406,17 +405,15 @@ impl RMain {
 
             // Set up the global error handler (after support function initialization)
             errors::initialize();
-        }
 
-        // Now that R has started (emitting any startup messages), and now that we have set
-        // up all hooks and handlers, officially finish the R initialization process to
-        // unblock the kernel-info request and also allow the LSP to start.
-        RMain::with_mut(|main| {
-            log::info!(
-                "R has started and ark handlers have been registered, completing initialization."
-            );
-            main.complete_initialization();
-        });
+            // Now that R has started (emitting any startup messages), and now that we have set
+            // up all hooks and handlers, officially finish the R initialization process to
+            // unblock the kernel-info request and also allow the LSP to start.
+            RMain::with_mut(|main| {
+                log::info!("R has started and ark handlers have been registered, completing initialization.");
+                main.complete_initialization();
+            });
+        }
 
         // Now that R has started and libr and ark have fully initialized, run site and user
         // level R profiles, in that order
@@ -431,6 +428,34 @@ impl RMain {
         crate::sys::interface::run_r();
     }
 
+    /// Completes the kernel's initialization.
+    /// Unlike `RMain::start()`, this has access to `R_MAIN`'s state, such as
+    /// the kernel-info banner.
+    /// SAFETY: Can only be called from the R thread, and only once.
+    pub unsafe fn complete_initialization(&mut self) {
+        let version = unsafe {
+            let version = Rf_findVarInFrame(R_BaseNamespace, r_symbol!("R.version.string"));
+            RObject::new(version).to::<String>().unwrap()
+        };
+
+        // Initial input and continuation prompts
+        let input_prompt: String = harp::get_option("prompt").try_into().unwrap();
+        let continuation_prompt: String = harp::get_option("continue").try_into().unwrap();
+
+        let kernel_info = KernelInfo {
+            version: version.clone(),
+            banner: self.banner_output.clone(),
+            input_prompt: Some(input_prompt),
+            continuation_prompt: Some(continuation_prompt),
+        };
+
+        log::info!("Sending kernel info: {version}");
+        self.kernel_init_tx.broadcast(kernel_info);
+
+        // Thread-safe initialisation flag for R
+        R_INIT.set(()).expect("`R_INIT` can only be set once");
+    }
+
     pub fn new(
         kernel: Arc<Mutex<Kernel>>,
         tasks_interrupt_rx: Receiver<RTask>,
@@ -445,7 +470,6 @@ impl RMain {
         session_mode: SessionMode,
     ) -> Self {
         Self {
-            initializing: true,
             r_request_rx,
             comm_manager_tx,
             stdin_request_tx,
@@ -474,14 +498,23 @@ impl RMain {
 
     /// Wait for complete R initialization
     ///
-    /// Wait for R being ready to take input (i.e. `ReadConsole` was called).
-    /// Resolves as the same time as the `Bus<KernelInfo>` init channel does.
+    /// Wait for R being ready to evaluate R code. Resolves as the same time as
+    /// the `Bus<KernelInfo>` init channel does.
     ///
     /// Thread-safe.
     pub fn wait_r_initialized() {
         R_INIT.wait();
     }
 
+    /// Has R completed initialization
+    ///
+    /// I.e. is it ready to evaluate R code.
+    ///
+    /// Thread-safe.
+    pub fn is_r_initialized() -> bool {
+        R_INIT.get().is_some()
+    }
+
     /// Has the `RMain` singleton completed initialization.
     ///
     /// This can return true when R might still not have finished starting up.
@@ -545,38 +578,6 @@ impl RMain {
         thread.id() == unsafe { R_MAIN_THREAD_ID.unwrap() }
     }
 
-    /// Completes the kernel's initialization
-    pub fn complete_initialization(&mut self) {
-        if self.initializing {
-            let version = unsafe {
-                let version = Rf_findVarInFrame(R_BaseNamespace, r_symbol!("R.version.string"));
-                RObject::new(version).to::<String>().unwrap()
-            };
-
-            // Initial input and continuation prompts
-            let input_prompt: String = harp::get_option("prompt").try_into().unwrap();
-            let continuation_prompt: String = harp::get_option("continue").try_into().unwrap();
-
-            let kernel_info = KernelInfo {
-                version: version.clone(),
-                banner: self.banner_output.clone(),
-                input_prompt: Some(input_prompt),
-                continuation_prompt: Some(continuation_prompt),
-            };
-
-            log::info!("Sending kernel info: {version}");
-            self.kernel_init_tx.broadcast(kernel_info);
-
-            // Internal initialisation flag, should only be used on the R thread
-            self.initializing = false;
-
-            // Used as thread-safe initialisation flag
-            R_INIT.set(()).unwrap();
-        } else {
-            log::warn!("Initialization already complete!");
-        }
-    }
-
     /// Provides read-only access to `iopub_tx`
     pub fn get_iopub_tx(&self) -> &Sender<IOPubMessage> {
         &self.iopub_tx
@@ -1323,7 +1324,7 @@ This is a Positron limitation we plan to fix. In the meantime, you can:
             Stream::Stderr
         };
 
-        if self.initializing {
+        if !RMain::is_r_initialized() {
             // During init, consider all output to be part of the startup banner
             self.banner_output.push_str(&content);
             return;