Merge pull request #359 from posit-dev/feature/read-console-scopes

Send console scopes from `ReadConsole`

Author: lionel-

crates/ark/src/interface.rs

@@ -56,6 +56,8 @@ use crossbeam::channel::Receiver;
 use crossbeam::channel::Sender;
 use crossbeam::channel::TryRecvError;
 use crossbeam::select;
+use harp::environment::Environment;
+use harp::environment::R_ENVS;
 use harp::exec::geterrmessage;
 use harp::exec::r_check_stack;
 use harp::exec::r_sandbox;
@@ -90,6 +92,7 @@ use serde_json::json;
 use stdext::result::ResultOrLog;
 use stdext::*;
 use tokio::runtime::Runtime;
+use tokio::sync::mpsc::UnboundedSender as TokioUnboundedSender;
 
 use crate::dap::dap::DapBackendEvent;
 use crate::dap::dap_r_main::RMainDap;
@@ -99,6 +102,8 @@ use crate::help::message::HelpReply;
 use crate::help::message::HelpRequest;
 use crate::kernel::Kernel;
 use crate::lsp::backend::Backend;
+use crate::lsp::backend::ConsoleInputs;
+use crate::lsp::backend::LspEvent;
 use crate::lsp::events::EVENTS;
 use crate::modules;
 use crate::plots::graphics_device;
@@ -271,6 +276,9 @@ pub struct RMain {
     lsp_runtime: Arc<Runtime>,
     lsp_backend: Option<Backend>,
 
+    /// Event channel for notifying the LSP. In principle, could be a Jupyter comm.
+    lsp_events_tx: Option<TokioUnboundedSender<LspEvent>>,
+
     dap: RMainDap,
 
     /// Whether or not R itself is actively busy.
@@ -376,6 +384,7 @@ impl RMain {
             help_rx: None,
             lsp_runtime,
             lsp_backend: None,
+            lsp_events_tx: None,
             dap: RMainDap::new(dap),
             is_busy: false,
             old_show_error_messages: None,
@@ -573,6 +582,23 @@ impl RMain {
             }
         }
 
+        // In the future we'll also send browser information, see
+        // https://github.com/posit-dev/positron/issues/3001. Currently this is
+        // a push model where we send the console inputs at each round. In the
+        // future, a pull model would be better, this way the LSP can manage a
+        // cache of inputs and we don't need to retraverse the environments as
+        // often. We'd still push a `DidChangeConsoleInputs` notification from
+        // here, but only containing high-level information such as `search()`
+        // contents and `ls(rho)`.
+        if !info.browser && !info.incomplete && !info.input_request {
+            match console_inputs() {
+                Ok(inputs) => {
+                    self.send_lsp(LspEvent::DidChangeConsoleInputs(inputs));
+                },
+                Err(err) => log::error!("Can't retrieve console inputs: {err:?}"),
+            }
+        }
+
         // Signal prompt
         EVENTS.console_prompt.emit(());
 
@@ -1055,8 +1081,19 @@ impl RMain {
         self.lsp_backend.as_ref()
     }
 
-    pub fn set_lsp_backend(&mut self, backend: Backend) {
+    fn send_lsp(&self, event: LspEvent) {
+        if let Some(ref tx) = self.lsp_events_tx {
+            tx.send(event).unwrap();
+        }
+    }
+
+    pub fn set_lsp_backend(
+        &mut self,
+        backend: Backend,
+        lsp_events_tx: TokioUnboundedSender<LspEvent>,
+    ) {
         self.lsp_backend = Some(backend);
+        self.lsp_events_tx = Some(lsp_events_tx);
     }
 
     pub fn call_frontend_method(&self, request: UiFrontendRequest) -> anyhow::Result<RObject> {
@@ -1254,6 +1291,25 @@ fn to_html(frame: SEXP) -> Result<String> {
     }
 }
 
+// Inputs generated by `ReadConsole` for the LSP
+pub(crate) fn console_inputs() -> anyhow::Result<ConsoleInputs> {
+    // TODO: Should send the debug environment if debugging:
+    // https://github.com/posit-dev/positron/issues/3001
+    let env = Environment::new(R_ENVS.global.into());
+    let scopes = env.ancestors().map(|e| e.names()).collect();
+
+    // Get the set of installed packages
+    let installed_packages: Vec<String> = RFunction::new("base", ".packages")
+        .param("all.available", true)
+        .call()?
+        .try_into()?;
+
+    Ok(ConsoleInputs {
+        console_scopes: scopes,
+        installed_packages,
+    })
+}
+
 // --- Frontend methods ---
 // These functions are hooked up as R frontend methods. They call into our
 // global `RMain` singleton.

crates/ark/src/lsp/backend.rs

@@ -18,6 +18,7 @@ use stdext::result::ResultOrLog;
 use stdext::*;
 use tokio::net::TcpListener;
 use tokio::runtime::Runtime;
+use tokio::sync::mpsc::unbounded_channel as tokio_unbounded_channel;
 use tower_lsp::jsonrpc::Result;
 use tower_lsp::lsp_types::request::GotoImplementationParams;
 use tower_lsp::lsp_types::request::GotoImplementationResponse;
@@ -61,6 +62,11 @@ macro_rules! backend_trace {
 
 }
 
+#[derive(Debug)]
+pub enum LspEvent {
+    DidChangeConsoleInputs(ConsoleInputs),
+}
+
 #[derive(Clone, Debug)]
 pub struct Backend {
     /// LSP client, use this for direct interaction with the client.
@@ -73,6 +79,21 @@ pub struct Backend {
     pub indexer_state_manager: IndexerStateManager,
 }
 
+/// Information sent from the kernel to the LSP after each top-level evaluation.
+#[derive(Debug)]
+pub struct ConsoleInputs {
+    /// List of console scopes, from innermost (global or debug) to outermost
+    /// scope. Currently the scopes are vectors of symbol names. TODO: In the
+    /// future, we should send structural information like search path, and let
+    /// the LSP query us for the contents so that the LSP can cache the
+    /// information.
+    pub console_scopes: Vec<Vec<String>>,
+
+    /// Packages currently installed in the library path. TODO: Should send
+    /// library paths instead and inspect and cache package information in the LSP.
+    pub installed_packages: Vec<String>,
+}
+
 impl Backend {
     pub fn with_document<T, F>(&self, path: &Path, mut callback: F) -> anyhow::Result<T>
     where
@@ -571,10 +592,31 @@ pub fn start_lsp(runtime: Arc<Runtime>, address: String, conn_init_tx: Sender<bo
                 state: WorldState {
                     documents: Arc::new(DashMap::new()),
                     workspace: Arc::new(Mutex::new(Workspace::default())),
+                    console_scopes: Arc::new(Mutex::new(vec![])),
+                    installed_packages: Arc::new(Mutex::new(vec![])),
                 },
                 indexer_state_manager: IndexerStateManager::new(),
             };
 
+            let (events_tx, mut events_rx) = tokio_unbounded_channel::<LspEvent>();
+
+            // LSP event loop. To be integrated in our synchronising dispatcher
+            // once implemented.
+            tokio::spawn({
+                let backend = backend.clone();
+                async move {
+                    loop {
+                        match events_rx.recv().await.unwrap() {
+                            LspEvent::DidChangeConsoleInputs(inputs) => {
+                                *backend.state.console_scopes.lock() = inputs.console_scopes;
+                                *backend.state.installed_packages.lock() =
+                                    inputs.installed_packages;
+                            },
+                        }
+                    }
+                }
+            });
+
             // Forward `backend` along to `RMain`.
             // This also updates an outdated `backend` after a reconnect.
             // `RMain` should be initialized by now, since the caller of this
@@ -585,7 +627,7 @@ pub fn start_lsp(runtime: Arc<Runtime>, address: String, conn_init_tx: Sender<bo
                 let backend = backend.clone();
                 move || {
                     let main = RMain::get_mut();
-                    main.set_lsp_backend(backend);
+                    main.set_lsp_backend(backend, events_tx);
                 }
             });
 

crates/ark/src/lsp/completions/completion_item.rs

@@ -10,16 +10,16 @@ use std::fs::DirEntry;
 use anyhow::bail;
 use anyhow::Result;
 use harp::r_symbol;
+use harp::utils::is_symbol_valid;
 use harp::utils::r_env_binding_is_active;
 use harp::utils::r_envir_name;
 use harp::utils::r_formals;
 use harp::utils::r_promise_force_with_rollback;
 use harp::utils::r_promise_is_forced;
 use harp::utils::r_promise_is_lazy_load_binding;
-use harp::utils::r_symbol_quote;
-use harp::utils::r_symbol_quote_invalid;
-use harp::utils::r_symbol_valid;
 use harp::utils::r_typeof;
+use harp::utils::sym_quote;
+use harp::utils::sym_quote_invalid;
 use libr::R_UnboundValue;
 use libr::Rf_findVarInFrame;
 use libr::Rf_isFunction;
@@ -178,7 +178,7 @@ pub(super) fn completion_item_from_function<T: AsRef<str>>(
     let detail = format!("{}({})", name, parameters.joined(", "));
     item.detail = Some(detail);
 
-    let insert_text = r_symbol_quote_invalid(name);
+    let insert_text = sym_quote_invalid(name);
     item.insert_text_format = Some(InsertTextFormat::SNIPPET);
     item.insert_text = Some(format!("{insert_text}($0)"));
 
@@ -211,8 +211,8 @@ pub(super) unsafe fn completion_item_from_data_variable(
 
     if enquote {
         item.insert_text = Some(format!("\"{}\"", name));
-    } else if !r_symbol_valid(name) {
-        item.insert_text = Some(r_symbol_quote(name));
+    } else if !is_symbol_valid(name) {
+        item.insert_text = Some(sym_quote(name));
     }
 
     item.detail = Some(owner.to_string());
@@ -253,8 +253,8 @@ pub(super) unsafe fn completion_item_from_object(
     item.detail = Some("(Object)".to_string());
     item.kind = Some(CompletionItemKind::STRUCT);
 
-    if !r_symbol_valid(name) {
-        item.insert_text = Some(r_symbol_quote(name));
+    if !is_symbol_valid(name) {
+        item.insert_text = Some(sym_quote(name));
     }
 
     Ok(item)
@@ -293,8 +293,8 @@ pub(super) unsafe fn completion_item_from_promise(
     item.detail = Some("Promise".to_string());
     item.kind = Some(CompletionItemKind::STRUCT);
 
-    if !r_symbol_valid(name) {
-        item.insert_text = Some(r_symbol_quote(name));
+    if !is_symbol_valid(name) {
+        item.insert_text = Some(sym_quote(name));
     }
 
     Ok(item)
@@ -310,8 +310,8 @@ pub(super) fn completion_item_from_active_binding(name: &str) -> Result<Completi
     item.detail = Some("Active binding".to_string());
     item.kind = Some(CompletionItemKind::STRUCT);
 
-    if !r_symbol_valid(name) {
-        item.insert_text = Some(r_symbol_quote(name));
+    if !is_symbol_valid(name) {
+        item.insert_text = Some(sym_quote(name));
     }
 
     Ok(item)
@@ -433,7 +433,7 @@ pub(super) fn completion_item_from_parameter(
         function: callee.to_string(),
     };
 
-    let parameter = r_symbol_quote_invalid(parameter);
+    let parameter = sym_quote_invalid(parameter);
 
     // We want to display to the user the name with the `=`
     let label = parameter.clone() + " = ";

crates/ark/src/lsp/completions/sources/unique/custom.rs

@@ -9,7 +9,7 @@ use anyhow::Result;
 use harp::exec::RFunction;
 use harp::exec::RFunctionExt;
 use harp::object::RObject;
-use harp::utils::r_symbol_quote_invalid;
+use harp::utils::sym_quote_invalid;
 use harp::utils::r_typeof;
 use libr::R_NilValue;
 use libr::VECSXP;
@@ -183,7 +183,7 @@ pub fn completions_from_custom_source_impl(
                 if enquote && !node.is_string() {
                     item.insert_text = Some(format!("\"{value}\""));
                 } else {
-                    let mut insert_text = r_symbol_quote_invalid(value.as_str());
+                    let mut insert_text = sym_quote_invalid(value.as_str());
 
                     if !append.is_empty() {
                         insert_text = format!("{insert_text}{append}");