1use anyhow::Result;
 2use async_trait::async_trait;
 3use collections::FxHashMap;
 4use gpui::{App, BackgroundExecutor, Global, SharedString};
 5use language::LanguageName;
 6use parking_lot::RwLock;
 7use task::{
 8    AdapterSchema, AdapterSchemas, DebugRequest, DebugScenario, SpawnInTerminal, TaskTemplate,
 9};
10
11use crate::adapters::{DebugAdapter, DebugAdapterName};
12use std::{collections::BTreeMap, sync::Arc};
13
14/// Given a user build configuration, locator creates a fill-in debug target ([DebugScenario]) on behalf of the user.
15#[async_trait]
16pub trait DapLocator: Send + Sync {
17    fn name(&self) -> SharedString;
18    /// Determines whether this locator can generate debug target for given task.
19    async fn create_scenario(
20        &self,
21        build_config: &TaskTemplate,
22        resolved_label: &str,
23        adapter: &DebugAdapterName,
24    ) -> Option<DebugScenario>;
25
26    async fn run(
27        &self,
28        build_config: SpawnInTerminal,
29        executor: BackgroundExecutor,
30    ) -> Result<DebugRequest>;
31}
32
33#[derive(Default)]
34struct DapRegistryState {
35    adapters: BTreeMap<DebugAdapterName, Arc<dyn DebugAdapter>>,
36    locators: FxHashMap<SharedString, Arc<dyn DapLocator>>,
37}
38
39#[derive(Clone, Default)]
40/// Stores available debug adapters.
41pub struct DapRegistry(Arc<RwLock<DapRegistryState>>);
42impl Global for DapRegistry {}
43
44impl DapRegistry {
45    pub fn global(cx: &mut App) -> &mut Self {
46        cx.default_global::<Self>()
47    }
48
49    pub fn add_adapter(&self, adapter: Arc<dyn DebugAdapter>) {
50        let name = adapter.name();
51        let _previous_value = self.0.write().adapters.insert(name, adapter);
52    }
53
54    pub fn add_locator(&self, locator: Arc<dyn DapLocator>) {
55        self.0.write().locators.insert(locator.name(), locator);
56    }
57
58    pub fn remove_adapter(&self, name: &str) {
59        self.0.write().adapters.remove(name);
60    }
61
62    pub fn remove_locator(&self, locator: &str) {
63        self.0.write().locators.remove(locator);
64    }
65
66    pub fn adapter_language(&self, adapter_name: &str) -> Option<LanguageName> {
67        self.adapter(adapter_name)
68            .and_then(|adapter| adapter.adapter_language_name())
69    }
70
71    pub fn adapters_schema(&self) -> task::AdapterSchemas {
72        let mut schemas = vec![];
73
74        let adapters = &self.0.read().adapters;
75
76        for (name, adapter) in adapters.into_iter() {
77            schemas.push(AdapterSchema {
78                adapter: name.clone().into(),
79                schema: adapter.dap_schema(),
80            });
81        }
82
83        AdapterSchemas(schemas)
84    }
85
86    pub fn locators(&self) -> FxHashMap<SharedString, Arc<dyn DapLocator>> {
87        self.0.read().locators.clone()
88    }
89
90    pub fn adapter(&self, name: &str) -> Option<Arc<dyn DebugAdapter>> {
91        self.0.read().adapters.get(name).cloned()
92    }
93
94    pub fn enumerate_adapters<B: FromIterator<DebugAdapterName>>(&self) -> B {
95        self.0.read().adapters.keys().cloned().collect()
96    }
97}