Add option to show .Last.value in the Variables pane (#794)

* include .Last.value

* move to update check

* make it configurable

* impl inspection

* better error handling

* tests or it didn't happen

* prevent tests from relying on global state

* code review feedback

* make it possible to change setting on the fly

* Update crates/ark/src/variables/r_variables.rs

Co-authored-by: Davis Vaughan <[email protected]>

---------

Co-authored-by: Davis Vaughan <[email protected]>

Author: jmcphers

crates/ark/src/variables/r_variables.rs

@@ -1,7 +1,7 @@
 //
 // r_variables.rs
 //
-// Copyright (C) 2023-2024 by Posit Software, PBC
+// Copyright (C) 2023-2025 by Posit Software, PBC
 //
 //
 
@@ -26,6 +26,7 @@ use harp::environment::Environment;
 use harp::environment::EnvironmentFilter;
 use harp::exec::RFunction;
 use harp::exec::RFunctionExt;
+use harp::get_option;
 use harp::object::RObject;
 use harp::utils::r_assert_type;
 use harp::vector::CharacterVector;
@@ -42,6 +43,17 @@ use crate::r_task;
 use crate::thread::RThreadSafe;
 use crate::variables::variable::PositronVariable;
 
+/// Enumeration of treatments for the .Last.value variable
+pub enum LastValue {
+    /// Always show the .Last.value variable in the Variables pane. This is used
+    /// by tests to show the value without changing the global option.
+    Always,
+
+    /// Use the value of the global option `positron.show_last_value` to
+    /// determine whether to show the .Last.value variable
+    UseOption,
+}
+
 /**
  * The R Variables handler provides the server side of Positron's Variables panel, and is
  * responsible for creating and updating the list of variables.
@@ -66,6 +78,14 @@ pub struct RVariables {
     /// thread. Tracked in https://github.com/posit-dev/positron/issues/1812
     current_bindings: RThreadSafe<Vec<Binding>>,
     version: u64,
+
+    /// Whether to always show the .Last.value in the Variables pane, regardless
+    /// of the value of positron.show_last_value
+    show_last_value: LastValue,
+
+    /// Whether we are currently showing the .Last.value variable in the Variables
+    /// pane.
+    showing_last_value: bool,
 }
 
 impl RVariables {
@@ -76,6 +96,23 @@ impl RVariables {
      * - `comm`: A channel used to send messages to the frontend
      */
     pub fn start(env: RObject, comm: CommSocket, comm_manager_tx: Sender<CommManagerEvent>) {
+        // Start with default settings
+        Self::start_with_config(env, comm, comm_manager_tx, LastValue::UseOption);
+    }
+
+    /**
+     * Creates a new RVariables instance with specific configuration.
+     *
+     * - `env`: An R environment to scan for variables, typically R_GlobalEnv
+     * - `comm`: A channel used to send messages to the frontend
+     * - `show_last_value`: Whether to include .Last.value in the variables list
+     */
+    pub fn start_with_config(
+        env: RObject,
+        comm: CommSocket,
+        comm_manager_tx: Sender<CommManagerEvent>,
+        show_last_value: LastValue,
+    ) {
         // Validate that the RObject we were passed is actually an environment
         if let Err(err) = r_assert_type(env.sexp, &[ENVSXP]) {
             log::warn!(
@@ -99,6 +136,8 @@ impl RVariables {
                 env,
                 current_bindings,
                 version: 0,
+                show_last_value,
+                showing_last_value: false,
             };
             environment.execution_thread();
         });
@@ -196,6 +235,14 @@ impl RVariables {
         r_task(|| {
             self.update_bindings(self.bindings());
 
+            // If the special .Last.value variable is enabled, add it to the
+            // list. This is a special R value that doesn't have its own
+            // binding.
+            if let Some(last_value) = self.last_value() {
+                self.showing_last_value = true;
+                variables.push(last_value.var());
+            }
+
             for binding in self.current_bindings.get() {
                 variables.push(PositronVariable::new(binding).var());
             }
@@ -357,6 +404,45 @@ impl RVariables {
         }
     }
 
+    /// Gets the value of the special variable '.Last.value' (the value of the
+    /// last expression evaluated at the top level), if enabled.
+    ///
+    /// Returns None in all other cases.
+    fn last_value(&self) -> Option<PositronVariable> {
+        // Check the cached value first
+        let show_last_value = match self.show_last_value {
+            LastValue::Always => true,
+            LastValue::UseOption => {
+                // If we aren't always showing the last value, update from the
+                // global option
+                let use_last_value = get_option("positron.show_last_value");
+                match use_last_value.get_bool(0) {
+                    Ok(Some(true)) => true,
+                    _ => false,
+                }
+            },
+        };
+
+        if show_last_value {
+            match harp::environment::last_value() {
+                Ok(last_robj) => Some(PositronVariable::from(
+                    String::from(".Last.value"),
+                    String::from(".Last.value"),
+                    last_robj.sexp,
+                )),
+                Err(err) => {
+                    // This isn't a critical error but would also be very
+                    // unexpected.
+                    log::error!("Environment: Could not evaluate .Last.value ({err:?})");
+                    None
+                },
+            }
+        } else {
+            // Last value display is disabled
+            None
+        }
+    }
+
     #[tracing::instrument(level = "trace", skip_all)]
     fn update(&mut self, request_id: Option<String>) {
         let mut assigned: Vec<Variable> = vec![];
@@ -371,6 +457,18 @@ impl RVariables {
             let mut new_iter = new_bindings.get().iter();
             let mut new_next = new_iter.next();
 
+            // Track the last value if the user has requested it. Treat this
+            // value as assigned every time we update the Variables list.
+            if let Some(last_value) = self.last_value() {
+                self.showing_last_value = true;
+                assigned.push(last_value.var());
+            } else if self.showing_last_value {
+                // If we are no longer showing the last value, remove it from
+                // the list of assigned variables
+                self.showing_last_value = false;
+                removed.push(".Last.value".to_string());
+            }
+
             loop {
                 match (old_next, new_next) {
                     // nothing more to do

crates/ark/src/variables/variable.rs

@@ -1,7 +1,7 @@
 //
 // variable.rs
 //
-// Copyright (C) 2023 by Posit Software, PBC
+// Copyright (C) 2023-2025 by Posit Software, PBC
 //
 //
 
@@ -651,7 +651,7 @@ impl PositronVariable {
     /**
      * Create a new Variable from an R object
      */
-    fn from(access_key: String, display_name: String, x: SEXP) -> Self {
+    pub fn from(access_key: String, display_name: String, x: SEXP) -> Self {
         let WorkspaceVariableDisplayValue {
             display_value,
             is_truncated,
@@ -1069,6 +1069,13 @@ impl PositronVariable {
         // Concrete nodes are objects that are treated as is. Accessing an element from them
         // might result in special node types.
 
+        // Check for the special access key `.Last.value`; we can only get the
+        // value for this object by evaluating it in R
+        if access_key == ".Last.value" {
+            let last_robj = harp::environment::last_value()?;
+            return Ok(EnvironmentVariableNode::Concrete { object: last_robj });
+        }
+
         // First try to get child using a generic method
         // When building the children list of nodes that use a custom `get_children` method, the access_key is
         // formatted as "custom-{index}-{length(name)}-{name}". If the access_key has this format, we call the custom `get_child_at`,