debugger: Add inline value tests (#29815)

## Context

This PR improves the accuracy of our inline values for Rust/Python. It
does this by only adding inline value hints to the last valid use of a
variable and checking whether variables are valid within a given scope
or not.

We also added tests for Rust/Python inline values and inline values
refreshing when stepping in a debug session.

### Future tasks
1. Handle functions that have inner functions defined within them.
2. Add inline values to variables that were used in inner scopes but not
defined in them.
3. Move the inline value provider trait and impls to the language trait
(or somewhere else).
4. Use Semantic tokens as the first inline value provider and fall back
to tree sitter
5. add let some variable statement, for loops, and function inline value
hints to Rust.
6. Make writing tests more streamlined. 
6.1 We should be able to write a test by only passing in variables,
language, source file, expected result, and stop position to a function.
7. Write a test that has coverage for selecting different stack frames. 

co-authored-by: Remco Smits \<djsmits12@gmail.com\>

Release Notes:

- N/A

---------

Co-authored-by: Remco Smits <djsmits12@gmail.com>

crates/dap/Cargo.toml

@@ -36,7 +36,6 @@ gpui.workspace = true
 http_client.workspace = true
 language.workspace = true
 log.workspace = true
-lsp-types.workspace = true
 node_runtime.workspace = true
 parking_lot.workspace = true
 paths.workspace = true

crates/dap/src/adapters.rs

@@ -402,10 +402,6 @@ pub async fn fetch_latest_adapter_version_from_github(
     })
 }
 
-pub trait InlineValueProvider {
-    fn provide(&self, variables: Vec<(String, lsp_types::Range)>) -> Vec<lsp_types::InlineValue>;
-}
-
 #[async_trait(?Send)]
 pub trait DebugAdapter: 'static + Send + Sync {
     fn name(&self) -> DebugAdapterName;
@@ -417,10 +413,6 @@ pub trait DebugAdapter: 'static + Send + Sync {
         user_installed_path: Option<PathBuf>,
         cx: &mut AsyncApp,
     ) -> Result<DebugAdapterBinary>;
-
-    fn inline_value_provider(&self) -> Option<Box<dyn InlineValueProvider>> {
-        None
-    }
 }
 
 #[cfg(any(test, feature = "test-support"))]

crates/dap/src/dap.rs

@@ -1,6 +1,7 @@
 pub mod adapters;
 pub mod client;
 pub mod debugger_settings;
+pub mod inline_value;
 pub mod proto_conversions;
 mod registry;
 pub mod transport;

crates/dap/src/inline_value.rs

@@ -0,0 +1,277 @@
+use std::collections::{HashMap, HashSet};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum VariableLookupKind {
+    Variable,
+    Expression,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum VariableScope {
+    Local,
+    Global,
+}
+
+#[derive(Debug, Clone)]
+pub struct InlineValueLocation {
+    pub variable_name: String,
+    pub scope: VariableScope,
+    pub lookup: VariableLookupKind,
+    pub row: usize,
+    pub column: usize,
+}
+
+/// A trait for providing inline values for debugging purposes.
+///
+/// Implementors of this trait are responsible for analyzing a given node in the
+/// source code and extracting variable information, including their names,
+/// scopes, and positions. This information is used to display inline values
+/// during debugging sessions. Implementors must also handle variable scoping
+/// themselves by traversing the syntax tree upwards to determine whether a
+/// variable is local or global.
+pub trait InlineValueProvider {
+    /// Provides a list of inline value locations based on the given node and source code.
+    ///
+    /// # Parameters
+    /// - `node`: The root node of the active debug line. Implementors should traverse
+    ///   upwards from this node to gather variable information and determine their scope.
+    /// - `source`: The source code as a string slice, used to extract variable names.
+    /// - `max_row`: The maximum row to consider when collecting variables. Variables
+    ///   declared beyond this row should be ignored.
+    ///
+    /// # Returns
+    /// A vector of `InlineValueLocation` instances, each representing a variable's
+    /// name, scope, and the position of the inline value should be shown.
+    fn provide(
+        &self,
+        node: language::Node,
+        source: &str,
+        max_row: usize,
+    ) -> Vec<InlineValueLocation>;
+}
+
+pub struct RustInlineValueProvider;
+
+impl InlineValueProvider for RustInlineValueProvider {
+    fn provide(
+        &self,
+        mut node: language::Node,
+        source: &str,
+        max_row: usize,
+    ) -> Vec<InlineValueLocation> {
+        let mut variables = Vec::new();
+        let mut variable_names = HashSet::new();
+        let mut scope = VariableScope::Local;
+
+        loop {
+            let mut variable_names_in_scope = HashMap::new();
+            for child in node.named_children(&mut node.walk()) {
+                if child.start_position().row >= max_row {
+                    break;
+                }
+
+                if scope == VariableScope::Local && child.kind() == "let_declaration" {
+                    if let Some(identifier) = child.child_by_field_name("pattern") {
+                        let variable_name = source[identifier.byte_range()].to_string();
+
+                        if variable_names.contains(&variable_name) {
+                            continue;
+                        }
+
+                        if let Some(index) = variable_names_in_scope.get(&variable_name) {
+                            variables.remove(*index);
+                        }
+
+                        variable_names_in_scope.insert(variable_name.clone(), variables.len());
+                        variables.push(InlineValueLocation {
+                            variable_name,
+                            scope: VariableScope::Local,
+                            lookup: VariableLookupKind::Variable,
+                            row: identifier.end_position().row,
+                            column: identifier.end_position().column,
+                        });
+                    }
+                } else if child.kind() == "static_item" {
+                    if let Some(name) = child.child_by_field_name("name") {
+                        let variable_name = source[name.byte_range()].to_string();
+                        variables.push(InlineValueLocation {
+                            variable_name,
+                            scope: scope.clone(),
+                            lookup: VariableLookupKind::Expression,
+                            row: name.end_position().row,
+                            column: name.end_position().column,
+                        });
+                    }
+                }
+            }
+
+            variable_names.extend(variable_names_in_scope.keys().cloned());
+
+            if matches!(node.kind(), "function_item" | "closure_expression") {
+                scope = VariableScope::Global;
+            }
+
+            if let Some(parent) = node.parent() {
+                node = parent;
+            } else {
+                break;
+            }
+        }
+
+        variables
+    }
+}
+
+pub struct PythonInlineValueProvider;
+
+impl InlineValueProvider for PythonInlineValueProvider {
+    fn provide(
+        &self,
+        mut node: language::Node,
+        source: &str,
+        max_row: usize,
+    ) -> Vec<InlineValueLocation> {
+        let mut variables = Vec::new();
+        let mut variable_names = HashSet::new();
+        let mut scope = VariableScope::Local;
+
+        loop {
+            let mut variable_names_in_scope = HashMap::new();
+            for child in node.named_children(&mut node.walk()) {
+                if child.start_position().row >= max_row {
+                    break;
+                }
+
+                if scope == VariableScope::Local {
+                    match child.kind() {
+                        "expression_statement" => {
+                            if let Some(expr) = child.child(0) {
+                                if expr.kind() == "assignment" {
+                                    if let Some(param) = expr.child(0) {
+                                        let param_identifier = if param.kind() == "identifier" {
+                                            Some(param)
+                                        } else if param.kind() == "typed_parameter" {
+                                            param.child(0)
+                                        } else {
+                                            None
+                                        };
+
+                                        if let Some(identifier) = param_identifier {
+                                            if identifier.kind() == "identifier" {
+                                                let variable_name =
+                                                    source[identifier.byte_range()].to_string();
+
+                                                if variable_names.contains(&variable_name) {
+                                                    continue;
+                                                }
+
+                                                if let Some(index) =
+                                                    variable_names_in_scope.get(&variable_name)
+                                                {
+                                                    variables.remove(*index);
+                                                }
+
+                                                variable_names_in_scope
+                                                    .insert(variable_name.clone(), variables.len());
+                                                variables.push(InlineValueLocation {
+                                                    variable_name,
+                                                    scope: VariableScope::Local,
+                                                    lookup: VariableLookupKind::Variable,
+                                                    row: identifier.end_position().row,
+                                                    column: identifier.end_position().column,
+                                                });
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        "function_definition" => {
+                            if let Some(params) = child.child_by_field_name("parameters") {
+                                for param in params.named_children(&mut params.walk()) {
+                                    let param_identifier = if param.kind() == "identifier" {
+                                        Some(param)
+                                    } else if param.kind() == "typed_parameter" {
+                                        param.child(0)
+                                    } else {
+                                        None
+                                    };
+
+                                    if let Some(identifier) = param_identifier {
+                                        if identifier.kind() == "identifier" {
+                                            let variable_name =
+                                                source[identifier.byte_range()].to_string();
+
+                                            if variable_names.contains(&variable_name) {
+                                                continue;
+                                            }
+
+                                            if let Some(index) =
+                                                variable_names_in_scope.get(&variable_name)
+                                            {
+                                                variables.remove(*index);
+                                            }
+
+                                            variable_names_in_scope
+                                                .insert(variable_name.clone(), variables.len());
+                                            variables.push(InlineValueLocation {
+                                                variable_name,
+                                                scope: VariableScope::Local,
+                                                lookup: VariableLookupKind::Variable,
+                                                row: identifier.end_position().row,
+                                                column: identifier.end_position().column,
+                                            });
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        "for_statement" => {
+                            if let Some(target) = child.child_by_field_name("left") {
+                                if target.kind() == "identifier" {
+                                    let variable_name = source[target.byte_range()].to_string();
+
+                                    if variable_names.contains(&variable_name) {
+                                        continue;
+                                    }
+
+                                    if let Some(index) = variable_names_in_scope.get(&variable_name)
+                                    {
+                                        variables.remove(*index);
+                                    }
+
+                                    variable_names_in_scope
+                                        .insert(variable_name.clone(), variables.len());
+                                    variables.push(InlineValueLocation {
+                                        variable_name,
+                                        scope: VariableScope::Local,
+                                        lookup: VariableLookupKind::Variable,
+                                        row: target.end_position().row,
+                                        column: target.end_position().column,
+                                    });
+                                }
+                            }
+                        }
+                        _ => {}
+                    }
+                }
+            }
+
+            variable_names.extend(variable_names_in_scope.keys().cloned());
+
+            if matches!(node.kind(), "function_definition" | "module")
+                && node.range().end_point.row < max_row
+            {
+                scope = VariableScope::Global;
+            }
+
+            if let Some(parent) = node.parent() {
+                node = parent;
+            } else {
+                break;
+            }
+        }
+
+        variables
+    }
+}

crates/dap/src/registry.rs

@@ -5,7 +5,10 @@ use gpui::{App, Global, SharedString};
 use parking_lot::RwLock;
 use task::{DebugRequest, DebugScenario, SpawnInTerminal, TaskTemplate};
 
-use crate::adapters::{DebugAdapter, DebugAdapterName};
+use crate::{
+    adapters::{DebugAdapter, DebugAdapterName},
+    inline_value::InlineValueProvider,
+};
 use std::{collections::BTreeMap, sync::Arc};
 
 /// Given a user build configuration, locator creates a fill-in debug target ([DebugRequest]) on behalf of the user.
@@ -22,6 +25,7 @@ pub trait DapLocator: Send + Sync {
 struct DapRegistryState {
     adapters: BTreeMap<DebugAdapterName, Arc<dyn DebugAdapter>>,
     locators: FxHashMap<SharedString, Arc<dyn DapLocator>>,
+    inline_value_providers: FxHashMap<String, Arc<dyn InlineValueProvider>>,
 }
 
 #[derive(Clone, Default)]
@@ -58,6 +62,22 @@ impl DapRegistry {
         );
     }
 
+    pub fn add_inline_value_provider(
+        &self,
+        language: String,
+        provider: Arc<dyn InlineValueProvider>,
+    ) {
+        let _previous_value = self
+            .0
+            .write()
+            .inline_value_providers
+            .insert(language, provider);
+        debug_assert!(
+            _previous_value.is_none(),
+            "Attempted to insert a new inline value provider when one is already registered"
+        );
+    }
+
     pub fn locators(&self) -> FxHashMap<SharedString, Arc<dyn DapLocator>> {
         self.0.read().locators.clone()
     }
@@ -66,6 +86,10 @@ impl DapRegistry {
         self.0.read().adapters.get(name).cloned()
     }
 
+    pub fn inline_value_provider(&self, language: &str) -> Option<Arc<dyn InlineValueProvider>> {
+        self.0.read().inline_value_providers.get(language).cloned()
+    }
+
     pub fn enumerate_adapters(&self) -> Vec<DebugAdapterName> {
         self.0.read().adapters.keys().cloned().collect()
     }