WIP and merge

crates/debug_adapter_extension/Cargo.toml

@@ -12,6 +12,7 @@ dap.workspace = true
 extension.workspace = true
 gpui.workspace = true
 serde_json.workspace = true
+util.workspace = true
 task.workspace = true
 workspace-hack = { version = "0.1", path = "../../tooling/workspace-hack" }
 

crates/debug_adapter_extension/src/debug_adapter_extension.rs

@@ -1,11 +1,15 @@
 mod extension_dap_adapter;
+mod extension_locator_adapter;
 
-use std::sync::Arc;
+use std::{path::Path, sync::Arc};
 
 use dap::DapRegistry;
 use extension::{ExtensionDebugAdapterProviderProxy, ExtensionHostProxy};
 use extension_dap_adapter::ExtensionDapAdapter;
 use gpui::App;
+use util::ResultExt;
+
+use crate::extension_locator_adapter::ExtensionLocatorAdapter;
 
 pub fn init(extension_host_proxy: Arc<ExtensionHostProxy>, cx: &mut App) {
     let language_server_registry_proxy = DebugAdapterRegistryProxy::new(cx);
@@ -30,11 +34,33 @@ impl ExtensionDebugAdapterProviderProxy for DebugAdapterRegistryProxy {
         &self,
         extension: Arc<dyn extension::Extension>,
         debug_adapter_name: Arc<str>,
+        schema_path: &Path,
+    ) {
+        if let Some(adapter) =
+            ExtensionDapAdapter::new(extension, debug_adapter_name, schema_path).log_err()
+        {
+            self.debug_adapter_registry.add_adapter(Arc::new(adapter));
+        }
+    }
+
+    fn register_debug_locator(
+        &self,
+        extension: Arc<dyn extension::Extension>,
+        locator_name: Arc<str>,
     ) {
         self.debug_adapter_registry
-            .add_adapter(Arc::new(ExtensionDapAdapter::new(
+            .add_locator(Arc::new(ExtensionLocatorAdapter::new(
                 extension,
-                debug_adapter_name,
+                locator_name,
             )));
     }
+
+    fn unregister_debug_adapter(&self, debug_adapter_name: Arc<str>) {
+        self.debug_adapter_registry
+            .remove_adapter(&debug_adapter_name);
+    }
+
+    fn unregister_debug_locator(&self, locator_name: Arc<str>) {
+        self.debug_adapter_registry.remove_locator(&locator_name);
+    }
 }

crates/debug_adapter_extension/src/extension_dap_adapter.rs

@@ -1,9 +1,16 @@
-use std::{path::PathBuf, sync::Arc};
+use std::{
+    path::{Path, PathBuf},
+    str::FromStr,
+    sync::Arc,
+};
 
-use anyhow::Result;
+use anyhow::{Context, Result};
 use async_trait::async_trait;
-use dap::adapters::{
-    DapDelegate, DebugAdapter, DebugAdapterBinary, DebugAdapterName, DebugTaskDefinition,
+use dap::{
+    StartDebuggingRequestArgumentsRequest,
+    adapters::{
+        DapDelegate, DebugAdapter, DebugAdapterBinary, DebugAdapterName, DebugTaskDefinition,
+    },
 };
 use extension::{Extension, WorktreeDelegate};
 use gpui::AsyncApp;
@@ -12,17 +19,28 @@ use task::{DebugScenario, ZedDebugConfig};
 pub(crate) struct ExtensionDapAdapter {
     extension: Arc<dyn Extension>,
     debug_adapter_name: Arc<str>,
+    schema: serde_json::Value,
 }
 
 impl ExtensionDapAdapter {
     pub(crate) fn new(
         extension: Arc<dyn extension::Extension>,
         debug_adapter_name: Arc<str>,
-    ) -> Self {
-        Self {
+        schema_path: &Path,
+    ) -> Result<Self> {
+        let schema = std::fs::read_to_string(&schema_path).with_context(|| {
+            format!(
+                "Failed to read debug adapter schema for {debug_adapter_name} (from path: `{schema_path:?}`)"
+            )
+        })?;
+        let schema = serde_json::Value::from_str(&schema).with_context(|| {
+            format!("Debug adapter schema for {debug_adapter_name} is not a valid JSON")
+        })?;
+        Ok(Self {
             extension,
             debug_adapter_name,
-        }
+            schema,
+        })
     }
 }
 
@@ -61,8 +79,8 @@ impl DebugAdapter for ExtensionDapAdapter {
         self.debug_adapter_name.as_ref().into()
     }
 
-    async fn dap_schema(&self) -> serde_json::Value {
-        self.extension.get_dap_schema().await.unwrap_or_default()
+    fn dap_schema(&self) -> serde_json::Value {
+        self.schema.clone()
     }
 
     async fn get_binary(
@@ -70,6 +88,8 @@ impl DebugAdapter for ExtensionDapAdapter {
         delegate: &Arc<dyn DapDelegate>,
         config: &DebugTaskDefinition,
         user_installed_path: Option<PathBuf>,
+        // TODO support user args in the extension API
+        _user_args: Option<Vec<String>>,
         _cx: &mut AsyncApp,
     ) -> Result<DebugAdapterBinary> {
         self.extension
@@ -82,7 +102,16 @@ impl DebugAdapter for ExtensionDapAdapter {
             .await
     }
 
-    fn config_from_zed_format(&self, _zed_scenario: ZedDebugConfig) -> Result<DebugScenario> {
-        Err(anyhow::anyhow!("DAP extensions are not implemented yet"))
+    async fn config_from_zed_format(&self, zed_scenario: ZedDebugConfig) -> Result<DebugScenario> {
+        self.extension.dap_config_to_scenario(zed_scenario).await
+    }
+
+    async fn request_kind(
+        &self,
+        config: &serde_json::Value,
+    ) -> Result<StartDebuggingRequestArgumentsRequest> {
+        self.extension
+            .dap_request_kind(self.debug_adapter_name.clone(), config.clone())
+            .await
     }
 }

crates/debug_adapter_extension/src/extension_locator_adapter.rs

@@ -0,0 +1,50 @@
+use anyhow::Result;
+use async_trait::async_trait;
+use dap::{DapLocator, DebugRequest, adapters::DebugAdapterName};
+use extension::Extension;
+use gpui::SharedString;
+use std::sync::Arc;
+use task::{DebugScenario, SpawnInTerminal, TaskTemplate};
+
+pub(crate) struct ExtensionLocatorAdapter {
+    extension: Arc<dyn Extension>,
+    locator_name: SharedString,
+}
+
+impl ExtensionLocatorAdapter {
+    pub(crate) fn new(extension: Arc<dyn extension::Extension>, locator_name: Arc<str>) -> Self {
+        Self {
+            extension,
+            locator_name: SharedString::from(locator_name),
+        }
+    }
+}
+
+#[async_trait]
+impl DapLocator for ExtensionLocatorAdapter {
+    fn name(&self) -> SharedString {
+        self.locator_name.clone()
+    }
+    /// 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> {
+        self.extension
+            .dap_locator_create_scenario(
+                self.locator_name.as_ref().to_owned(),
+                build_config.clone(),
+                resolved_label.to_owned(),
+                adapter.0.as_ref().to_owned(),
+            )
+            .await
+            .ok()
+            .flatten()
+    }
+
+    async fn run(&self, _build_config: SpawnInTerminal) -> Result<DebugRequest> {
+        Err(anyhow::anyhow!("Not implemented"))
+    }
+}