1use anyhow::Result;
  2use async_trait::async_trait;
  3use collections::FxHashMap;
  4use gpui::{App, Global, SharedString};
  5use language::LanguageName;
  6use parking_lot::RwLock;
  7use task::{
  8    AdapterSchema, AdapterSchemas, DebugRequest, DebugScenario, SpawnInTerminal, TaskTemplate,
  9};
 10
 11use crate::{
 12    adapters::{DebugAdapter, DebugAdapterName},
 13    inline_value::InlineValueProvider,
 14};
 15use std::{collections::BTreeMap, sync::Arc};
 16
 17/// Given a user build configuration, locator creates a fill-in debug target ([DebugScenario]) on behalf of the user.
 18#[async_trait]
 19pub trait DapLocator: Send + Sync {
 20    fn name(&self) -> SharedString;
 21    /// Determines whether this locator can generate debug target for given task.
 22    async fn create_scenario(
 23        &self,
 24        build_config: &TaskTemplate,
 25        resolved_label: &str,
 26        adapter: &DebugAdapterName,
 27    ) -> Option<DebugScenario>;
 28
 29    async fn run(&self, build_config: SpawnInTerminal) -> Result<DebugRequest>;
 30}
 31
 32#[derive(Default)]
 33struct DapRegistryState {
 34    adapters: BTreeMap<DebugAdapterName, Arc<dyn DebugAdapter>>,
 35    locators: FxHashMap<SharedString, Arc<dyn DapLocator>>,
 36    inline_value_providers: FxHashMap<String, Arc<dyn InlineValueProvider>>,
 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    pub fn add_locator(&self, locator: Arc<dyn DapLocator>) {
 54        self.0.write().locators.insert(locator.name(), locator);
 55    }
 56
 57    pub fn remove_adapter(&self, name: &str) {
 58        self.0.write().adapters.remove(name);
 59    }
 60
 61    pub fn remove_locator(&self, locator: &str) {
 62        self.0.write().locators.remove(locator);
 63    }
 64
 65    pub fn adapter_language(&self, adapter_name: &str) -> Option<LanguageName> {
 66        self.adapter(adapter_name)
 67            .and_then(|adapter| adapter.adapter_language_name())
 68    }
 69
 70    pub async fn adapters_schema(&self) -> task::AdapterSchemas {
 71        let mut schemas = AdapterSchemas(vec![]);
 72
 73        let adapters = self.0.read().adapters.clone();
 74
 75        for (name, adapter) in adapters.into_iter() {
 76            schemas.0.push(AdapterSchema {
 77                adapter: name.into(),
 78                schema: adapter.dap_schema(),
 79            });
 80        }
 81
 82        schemas
 83    }
 84
 85    pub fn add_inline_value_provider(
 86        &self,
 87        language: String,
 88        provider: Arc<dyn InlineValueProvider>,
 89    ) {
 90        let _previous_value = self
 91            .0
 92            .write()
 93            .inline_value_providers
 94            .insert(language, provider);
 95        debug_assert!(
 96            _previous_value.is_none(),
 97            "Attempted to insert a new inline value provider when one is already registered"
 98        );
 99    }
100
101    pub fn locators(&self) -> FxHashMap<SharedString, Arc<dyn DapLocator>> {
102        self.0.read().locators.clone()
103    }
104
105    pub fn adapter(&self, name: &str) -> Option<Arc<dyn DebugAdapter>> {
106        self.0.read().adapters.get(name).cloned()
107    }
108
109    pub fn inline_value_provider(&self, language: &str) -> Option<Arc<dyn InlineValueProvider>> {
110        self.0.read().inline_value_providers.get(language).cloned()
111    }
112
113    pub fn enumerate_adapters(&self) -> Vec<DebugAdapterName> {
114        self.0.read().adapters.keys().cloned().collect()
115    }
116}