Set up Rust debugger code runner tasks (zed-industries#27571)

## Summary 
This PR starts the process of adding debug task locators to Zed's
debugger system. A task locator is a secondary resolution phase that
allows a debug task to run a command before starting a debug session and
then uses the output of the run command to configure itself.

Locators are most applicable when debugging a compiled language but will
be helpful for any language as well.

## Architecture

At a high level, this works by adding a debug task queue to `Workspace`.
Which add's a debug configuration associated with a `TaskId` whenever a
resolved task with a debug config is added to `TaskInventory`'s queue.
Then, when the `SpawnInTerminal` task finishes running, it emits its
task_id and the result of the ran task.

When a ran task exits successfully, `Workspace` tells `Project` to start
a debug session using its stored debug config, then `DapStore` queries
the `LocatorStore` to configure the debug configuration if it has a
valid locator argument.

Release Notes:

- N/A

Author: Anthony-Eid

crates/dap_adapters/src/go.rs

@@ -1,4 +1,3 @@
-use anyhow::bail;
 use gpui::AsyncApp;
 use std::{ffi::OsStr, path::PathBuf};
 use task::DebugTaskDefinition;
@@ -63,9 +62,7 @@ impl DebugAdapter for GoDebugAdapter {
             .and_then(|p| p.to_str().map(|p| p.to_string()))
             .ok_or(anyhow!("Dlv not found in path"))?;
 
-        let Some(tcp_connection) = config.tcp_connection.clone() else {
-            bail!("Go Debug Adapter expects tcp connection arguments to be provided");
-        };
+        let tcp_connection = config.tcp_connection.clone().unwrap_or_default();
         let (host, port, timeout) = crate::configure_tcp_connection(tcp_connection).await?;
 
         Ok(DebugAdapterBinary {

crates/dap_adapters/src/javascript.rs

@@ -78,11 +78,7 @@ impl DebugAdapter for JsDebugAdapter {
             .ok_or_else(|| anyhow!("Couldn't find JavaScript dap directory"))?
         };
 
-        let Some(tcp_connection) = config.tcp_connection.clone() else {
-            anyhow::bail!(
-                "Javascript Debug Adapter expects tcp connection arguments to be provided"
-            );
-        };
+        let tcp_connection = config.tcp_connection.clone().unwrap_or_default();
         let (host, port, timeout) = crate::configure_tcp_connection(tcp_connection).await?;
 
         Ok(DebugAdapterBinary {

crates/dap_adapters/src/php.rs

@@ -1,5 +1,4 @@
 use adapters::latest_github_release;
-use anyhow::bail;
 use dap::adapters::TcpArguments;
 use gpui::AsyncApp;
 use std::path::PathBuf;
@@ -69,9 +68,7 @@ impl DebugAdapter for PhpDebugAdapter {
             .ok_or_else(|| anyhow!("Couldn't find PHP dap directory"))?
         };
 
-        let Some(tcp_connection) = config.tcp_connection.clone() else {
-            bail!("PHP Debug Adapter expects tcp connection arguments to be provided");
-        };
+        let tcp_connection = config.tcp_connection.clone().unwrap_or_default();
         let (host, port, timeout) = crate::configure_tcp_connection(tcp_connection).await?;
 
         Ok(DebugAdapterBinary {

crates/dap_adapters/src/python.rs

@@ -1,5 +1,4 @@
 use crate::*;
-use anyhow::bail;
 use dap::DebugRequestType;
 use gpui::AsyncApp;
 use std::{ffi::OsStr, path::PathBuf};
@@ -70,9 +69,7 @@ impl DebugAdapter for PythonDebugAdapter {
         cx: &mut AsyncApp,
     ) -> Result<DebugAdapterBinary> {
         const BINARY_NAMES: [&str; 3] = ["python3", "python", "py"];
-        let Some(tcp_connection) = config.tcp_connection.clone() else {
-            bail!("Python Debug Adapter expects tcp connection arguments to be provided");
-        };
+        let tcp_connection = config.tcp_connection.clone().unwrap_or_default();
         let (host, port, timeout) = crate::configure_tcp_connection(tcp_connection).await?;
 
         let debugpy_dir = if let Some(user_installed_path) = user_installed_path {

crates/debugger_ui/src/session/inert.rs

@@ -159,6 +159,8 @@ impl Render for InertState {
                             }),
                             tcp_connection: Some(TCPHost::default()),
                             initialize_args: None,
+                            args: Default::default(),
+                            locator: None,
                         },
                     });
                 } else {
@@ -319,6 +321,8 @@ impl InertState {
             adapter: kind,
             request: DebugRequestType::Attach(task::AttachConfig { process_id: None }),
             initialize_args: None,
+            args: Default::default(),
+            locator: None,
             tcp_connection: Some(TCPHost::default()),
         };
 

crates/debugger_ui/src/tests/attach_modal.rs

@@ -89,6 +89,8 @@ async fn test_show_attach_modal_and_select_process(
                         label: "attach example".into(),
                         initialize_args: None,
                         tcp_connection: Some(TCPHost::default()),
+                        locator: None,
+                        args: Default::default(),
                     },
                     vec![
                         Candidate {

crates/editor/src/editor.rs

@@ -4850,6 +4850,7 @@ impl Editor {
             } else {
                 return None;
             };
+
         let action_ix = action.item_ix.unwrap_or(actions_menu.selected_item);
         let action = actions_menu.actions.get(action_ix)?;
         let title = action.label();
@@ -4858,17 +4859,48 @@ impl Editor {
 
         match action {
             CodeActionsItem::Task(task_source_kind, resolved_task) => {
-                workspace.update(cx, |workspace, cx| {
-                    workspace::tasks::schedule_resolved_task(
-                        workspace,
-                        task_source_kind,
-                        resolved_task,
-                        false,
-                        cx,
-                    );
+                match resolved_task.task_type() {
+                    task::TaskType::Script => workspace.update(cx, |workspace, cx| {
+                        workspace::tasks::schedule_resolved_task(
+                            workspace,
+                            task_source_kind,
+                            resolved_task,
+                            false,
+                            cx,
+                        );
 
-                    Some(Task::ready(Ok(())))
-                })
+                        Some(Task::ready(Ok(())))
+                    }),
+                    task::TaskType::Debug(debug_args) => {
+                        if debug_args.locator.is_some() {
+                            workspace.update(cx, |workspace, cx| {
+                                workspace::tasks::schedule_resolved_task(
+                                    workspace,
+                                    task_source_kind,
+                                    resolved_task,
+                                    false,
+                                    cx,
+                                );
+                            });
+
+                            return Some(Task::ready(Ok(())));
+                        }
+
+                        if let Some(project) = self.project.as_ref() {
+                            project
+                                .update(cx, |project, cx| {
+                                    project.start_debug_session(
+                                        resolved_task.resolved_debug_adapter_config().unwrap(),
+                                        cx,
+                                    )
+                                })
+                                .detach_and_log_err(cx);
+                            Some(Task::ready(Ok(())))
+                        } else {
+                            Some(Task::ready(Ok(())))
+                        }
+                    }
+                }
             }
             CodeActionsItem::CodeAction {
                 excerpt_id,
@@ -8600,7 +8632,7 @@ impl Editor {
         let line_len = snapshot.buffer_snapshot.line_len(MultiBufferRow(row));
         let anchor_end = snapshot
             .buffer_snapshot
-            .anchor_before(Point::new(row, line_len));
+            .anchor_after(Point::new(row, line_len));
 
         let bp = self
             .breakpoint_store

crates/languages/src/rust.rs

@@ -17,7 +17,7 @@ use std::{
     path::{Path, PathBuf},
     sync::{Arc, LazyLock},
 };
-use task::{TaskTemplate, TaskTemplates, TaskVariables, VariableName};
+use task::{TaskTemplate, TaskTemplates, TaskType, TaskVariables, VariableName};
 use util::{fs::remove_matching, maybe, ResultExt};
 
 use crate::language_settings::language_settings;
@@ -574,11 +574,16 @@ impl ContextProvider for RustContextProvider {
             .variables
             .get(CUSTOM_TARGET_DIR)
             .cloned();
-        let run_task_args = if let Some(package_to_run) = package_to_run {
+        let run_task_args = if let Some(package_to_run) = package_to_run.clone() {
             vec!["run".into(), "-p".into(), package_to_run]
         } else {
             vec!["run".into()]
         };
+        let debug_task_args = if let Some(package_to_run) = package_to_run {
+            vec!["build".into(), "-p".into(), package_to_run]
+        } else {
+            vec!["build".into()]
+        };
         let mut task_templates = vec![
             TaskTemplate {
                 label: format!(
@@ -620,6 +625,31 @@ impl ContextProvider for RustContextProvider {
                 cwd: Some("$ZED_DIRNAME".to_owned()),
                 ..TaskTemplate::default()
             },
+            TaskTemplate {
+                label: format!(
+                    "Debug Test '{}' (package: {})",
+                    RUST_TEST_NAME_TASK_VARIABLE.template_value(),
+                    RUST_PACKAGE_TASK_VARIABLE.template_value(),
+                ),
+                task_type: TaskType::Debug(task::DebugArgs {
+                    adapter: "LLDB".to_owned(),
+                    request: task::DebugArgsRequest::Launch,
+                    locator: Some("cargo".into()),
+                    tcp_connection: None,
+                    initialize_args: None,
+                }),
+                command: "cargo".into(),
+                args: vec![
+                    "test".into(),
+                    "-p".into(),
+                    RUST_PACKAGE_TASK_VARIABLE.template_value(),
+                    RUST_TEST_NAME_TASK_VARIABLE.template_value(),
+                    "--no-run".into(),
+                ],
+                tags: vec!["rust-test".to_owned()],
+                cwd: Some("$ZED_DIRNAME".to_owned()),
+                ..TaskTemplate::default()
+            },
             TaskTemplate {
                 label: format!(
                     "Doc test '{}' (package: {})",
@@ -697,6 +727,21 @@ impl ContextProvider for RustContextProvider {
                 cwd: Some("$ZED_DIRNAME".to_owned()),
                 ..TaskTemplate::default()
             },
+            TaskTemplate {
+                label: "Debug".into(),
+                cwd: Some("$ZED_DIRNAME".to_owned()),
+                command: "cargo".into(),
+                task_type: TaskType::Debug(task::DebugArgs {
+                    request: task::DebugArgsRequest::Launch,
+                    adapter: "LLDB".to_owned(),
+                    initialize_args: None,
+                    locator: Some("cargo".into()),
+                    tcp_connection: None,
+                }),
+                args: debug_task_args,
+                tags: vec!["rust-main".to_owned()],
+                ..TaskTemplate::default()
+            },
             TaskTemplate {
                 label: "Clean".into(),
                 command: "cargo".into(),

crates/project/src/debugger.rs

@@ -14,4 +14,5 @@
 pub mod breakpoint_store;
 pub mod dap_command;
 pub mod dap_store;
+mod locator_store;
 pub mod session;

crates/project/src/debugger/breakpoint_store.rs

@@ -12,7 +12,7 @@ use rpc::{
     AnyProtoClient, TypedEnvelope,
 };
 use std::{hash::Hash, ops::Range, path::Path, sync::Arc};
-use text::{Point, PointUtf16};
+use text::PointUtf16;
 
 use crate::{buffer_store::BufferStore, worktree_store::WorktreeStore, Project, ProjectPath};
 
@@ -494,7 +494,7 @@ impl BreakpointStore {
                         this.update(cx, |_, cx| BreakpointsInFile::new(buffer, cx))?;
 
                     for bp in bps {
-                        let position = snapshot.anchor_after(Point::new(bp.row, 0));
+                        let position = snapshot.anchor_after(PointUtf16::new(bp.row, 0));
                         breakpoints_for_file.breakpoints.push((
                             position,
                             Breakpoint {

crates/project/src/debugger/dap_store.rs

@@ -1,11 +1,6 @@
 use super::{
     breakpoint_store::BreakpointStore,
-    // Will need to uncomment this once we implement rpc message handler again
-    // dap_command::{
-    //     ContinueCommand, DapCommand, DisconnectCommand, NextCommand, PauseCommand, RestartCommand,
-    //     RestartStackFrameCommand, StepBackCommand, StepCommand, StepInCommand, StepOutCommand,
-    //     TerminateCommand, TerminateThreadsCommand, VariablesCommand,
-    // },
+    locator_store::LocatorStore,
     session::{self, Session},
 };
 use crate::{debugger, worktree_store::WorktreeStore, ProjectEnvironment};
@@ -87,6 +82,7 @@ pub struct LocalDapStore {
     language_registry: Arc<LanguageRegistry>,
     debug_adapters: Arc<DapRegistry>,
     toolchain_store: Arc<dyn LanguageToolchainStore>,
+    locator_store: Arc<LocatorStore>,
     start_debugging_tx: futures::channel::mpsc::UnboundedSender<(SessionId, Message)>,
     _start_debugging_task: Task<()>,
 }
@@ -179,6 +175,7 @@ impl DapStore {
                 debug_adapters,
                 start_debugging_tx,
                 _start_debugging_task,
+                locator_store: Arc::from(LocatorStore::new()),
                 next_session_id: Default::default(),
             }),
             downstream_client: None,
@@ -324,7 +321,7 @@ impl DapStore {
 
     pub fn new_session(
         &mut self,
-        config: DebugAdapterConfig,
+        mut config: DebugAdapterConfig,
         worktree: &Entity<Worktree>,
         parent_session: Option<Entity<Session>>,
         cx: &mut Context<Self>,
@@ -354,22 +351,39 @@ impl DapStore {
         }
 
         let (initialized_tx, initialized_rx) = oneshot::channel();
+        let locator_store = local_store.locator_store.clone();
+        let debug_adapters = local_store.debug_adapters.clone();
 
-        let start_client_task = Session::local(
-            self.breakpoint_store.clone(),
-            session_id,
-            parent_session,
-            delegate,
-            config,
-            local_store.start_debugging_tx.clone(),
-            initialized_tx,
-            local_store.debug_adapters.clone(),
-            cx,
-        );
+        let start_debugging_tx = local_store.start_debugging_tx.clone();
+
+        let task = cx.spawn(async move |this, cx| {
+            if config.locator.is_some() {
+                locator_store.resolve_debug_config(&mut config).await?;
+            }
+
+            let start_client_task = this.update(cx, |this, cx| {
+                Session::local(
+                    this.breakpoint_store.clone(),
+                    session_id,
+                    parent_session,
+                    delegate,
+                    config,
+                    start_debugging_tx.clone(),
+                    initialized_tx,
+                    debug_adapters,
+                    cx,
+                )
+            })?;
+
+            this.update(cx, |_, cx| {
+                create_new_session(session_id, initialized_rx, start_client_task, cx)
+            })?
+            .await
+        });
 
-        let task = create_new_session(session_id, initialized_rx, start_client_task, cx);
         (session_id, task)
     }
+
     #[cfg(any(test, feature = "test-support"))]
     pub fn new_fake_session(
         &mut self,
@@ -456,7 +470,10 @@ impl DapStore {
             request: DebugRequestDisposition::ReverseRequest(args),
             initialize_args: config.initialize_args.clone(),
             tcp_connection: config.tcp_connection.clone(),
+            locator: None,
+            args: Default::default(),
         };
+
         #[cfg(any(test, feature = "test-support"))]
         let new_session_task = {
             let caps = parent_session.read(cx).capabilities.clone();