fc1fc264ec
## Context To support inline values a language will have to implement their own provider trait that walks through tree sitter nodes. This is overly complicated, hard to accurately implement for each language, and lacks proper extension support. This PR switches to a singular inline provider that uses a language's `debugger.scm` query field to capture variables and scopes. The inline provider is able to use this information to generate inlays that take scope into account and work with any language that defines a debugger query file. ### Todos - [x] Implement a utility test function to easily test inline values - [x] Generate inline values based on captures - [x] Reimplement Python, Rust, and Go support - [x] Take scope into account when iterating through variable captures - [x] Add tests for Go inline values - [x] Remove old inline provider code and trait implementations Release Notes: - debugger: Generate inline values based on a language debugger.scm file
92 lines
2.8 KiB
Rust
92 lines
2.8 KiB
Rust
use anyhow::Result;
|
|
use async_trait::async_trait;
|
|
use collections::FxHashMap;
|
|
use gpui::{App, Global, SharedString};
|
|
use language::LanguageName;
|
|
use parking_lot::RwLock;
|
|
use task::{
|
|
AdapterSchema, AdapterSchemas, DebugRequest, DebugScenario, SpawnInTerminal, TaskTemplate,
|
|
};
|
|
|
|
use crate::adapters::{DebugAdapter, DebugAdapterName};
|
|
use std::{collections::BTreeMap, sync::Arc};
|
|
|
|
/// Given a user build configuration, locator creates a fill-in debug target ([DebugScenario]) on behalf of the user.
|
|
#[async_trait]
|
|
pub trait DapLocator: Send + Sync {
|
|
fn name(&self) -> SharedString;
|
|
/// Determines whether this locator can generate debug target for given task.
|
|
async fn create_scenario(
|
|
&self,
|
|
build_config: &TaskTemplate,
|
|
resolved_label: &str,
|
|
adapter: &DebugAdapterName,
|
|
) -> Option<DebugScenario>;
|
|
|
|
async fn run(&self, build_config: SpawnInTerminal) -> Result<DebugRequest>;
|
|
}
|
|
|
|
#[derive(Default)]
|
|
struct DapRegistryState {
|
|
adapters: BTreeMap<DebugAdapterName, Arc<dyn DebugAdapter>>,
|
|
locators: FxHashMap<SharedString, Arc<dyn DapLocator>>,
|
|
}
|
|
|
|
#[derive(Clone, Default)]
|
|
/// Stores available debug adapters.
|
|
pub struct DapRegistry(Arc<RwLock<DapRegistryState>>);
|
|
impl Global for DapRegistry {}
|
|
|
|
impl DapRegistry {
|
|
pub fn global(cx: &mut App) -> &mut Self {
|
|
cx.default_global::<Self>()
|
|
}
|
|
|
|
pub fn add_adapter(&self, adapter: Arc<dyn DebugAdapter>) {
|
|
let name = adapter.name();
|
|
let _previous_value = self.0.write().adapters.insert(name, adapter);
|
|
}
|
|
pub fn add_locator(&self, locator: Arc<dyn DapLocator>) {
|
|
self.0.write().locators.insert(locator.name(), locator);
|
|
}
|
|
|
|
pub fn remove_adapter(&self, name: &str) {
|
|
self.0.write().adapters.remove(name);
|
|
}
|
|
|
|
pub fn remove_locator(&self, locator: &str) {
|
|
self.0.write().locators.remove(locator);
|
|
}
|
|
|
|
pub fn adapter_language(&self, adapter_name: &str) -> Option<LanguageName> {
|
|
self.adapter(adapter_name)
|
|
.and_then(|adapter| adapter.adapter_language_name())
|
|
}
|
|
|
|
pub async fn adapters_schema(&self) -> task::AdapterSchemas {
|
|
let mut schemas = AdapterSchemas(vec![]);
|
|
|
|
let adapters = self.0.read().adapters.clone();
|
|
|
|
for (name, adapter) in adapters.into_iter() {
|
|
schemas.0.push(AdapterSchema {
|
|
adapter: name.into(),
|
|
schema: adapter.dap_schema(),
|
|
});
|
|
}
|
|
|
|
schemas
|
|
}
|
|
|
|
pub fn locators(&self) -> FxHashMap<SharedString, Arc<dyn DapLocator>> {
|
|
self.0.read().locators.clone()
|
|
}
|
|
|
|
pub fn adapter(&self, name: &str) -> Option<Arc<dyn DebugAdapter>> {
|
|
self.0.read().adapters.get(name).cloned()
|
|
}
|
|
|
|
pub fn enumerate_adapters(&self) -> Vec<DebugAdapterName> {
|
|
self.0.read().adapters.keys().cloned().collect()
|
|
}
|
|
}
|