debugger: Remove fake adapter and un-gate GDB (#27557)

This is a clean-up PR in anticipation of introduction of Debugger
Registry. I wanna get rid of DebugAdapterKind (or rather, it being an
enum).
Release Notes:

- N/A

---------

Co-authored-by: Anthony Eid <hello@anthonyeid.me>
Co-authored-by: Anthony <anthony@zed.dev>

crates/debugger_ui/src/attach_modal.rs

@@ -3,8 +3,8 @@ use fuzzy::{StringMatch, StringMatchCandidate};
 use gpui::Subscription;
 use gpui::{DismissEvent, Entity, EventEmitter, Focusable, Render};
 use picker::{Picker, PickerDelegate};
-use project::debugger::attach_processes;
 
+use std::cell::LazyCell;
 use std::sync::Arc;
 use sysinfo::System;
 use ui::{prelude::*, Context, Tooltip};
@@ -13,10 +13,10 @@ use util::debug_panic;
 use workspace::ModalView;
 
 #[derive(Debug, Clone)]
-struct Candidate {
-    pid: u32,
-    name: String,
-    command: Vec<String>,
+pub(super) struct Candidate {
+    pub(super) pid: u32,
+    pub(super) name: SharedString,
+    pub(super) command: Vec<String>,
 }
 
 pub(crate) struct AttachModalDelegate {
@@ -24,16 +24,20 @@ pub(crate) struct AttachModalDelegate {
     matches: Vec<StringMatch>,
     placeholder_text: Arc<str>,
     project: Entity<project::Project>,
-    debug_config: task::DebugAdapterConfig,
-    candidates: Option<Vec<Candidate>>,
+    debug_config: task::DebugTaskDefinition,
+    candidates: Arc<[Candidate]>,
 }
 
 impl AttachModalDelegate {
-    pub fn new(project: Entity<project::Project>, debug_config: task::DebugAdapterConfig) -> Self {
+    fn new(
+        project: Entity<project::Project>,
+        debug_config: task::DebugTaskDefinition,
+        candidates: Arc<[Candidate]>,
+    ) -> Self {
         Self {
             project,
             debug_config,
-            candidates: None,
+            candidates,
             selected_index: 0,
             matches: Vec::default(),
             placeholder_text: Arc::from("Select the process you want to attach the debugger to"),
@@ -49,12 +53,56 @@ pub struct AttachModal {
 impl AttachModal {
     pub fn new(
         project: Entity<project::Project>,
-        debug_config: task::DebugAdapterConfig,
+        debug_config: task::DebugTaskDefinition,
         window: &mut Window,
         cx: &mut Context<Self>,
     ) -> Self {
+        let mut processes: Vec<_> = System::new_all()
+            .processes()
+            .values()
+            .map(|process| {
+                let name = process.name().to_string_lossy().into_owned();
+                Candidate {
+                    name: name.into(),
+                    pid: process.pid().as_u32(),
+                    command: process
+                        .cmd()
+                        .iter()
+                        .map(|s| s.to_string_lossy().to_string())
+                        .collect::<Vec<_>>(),
+                }
+            })
+            .collect();
+        processes.sort_by_key(|k| k.name.clone());
+        Self::with_processes(project, debug_config, processes, window, cx)
+    }
+
+    pub(super) fn with_processes(
+        project: Entity<project::Project>,
+        debug_config: task::DebugTaskDefinition,
+        processes: Vec<Candidate>,
+        window: &mut Window,
+        cx: &mut Context<Self>,
+    ) -> Self {
+        let adapter = project
+            .read(cx)
+            .debug_adapters()
+            .adapter(&debug_config.adapter);
+        let filter = LazyCell::new(|| adapter.map(|adapter| adapter.attach_processes_filter()));
+        let processes = processes
+            .into_iter()
+            .filter(|process| {
+                filter
+                    .as_ref()
+                    .map_or(false, |filter| filter.is_match(&process.name))
+            })
+            .collect();
         let picker = cx.new(|cx| {
-            Picker::uniform_list(AttachModalDelegate::new(project, debug_config), window, cx)
+            Picker::uniform_list(
+                AttachModalDelegate::new(project, debug_config, processes),
+                window,
+                cx,
+            )
         });
         Self {
             _subscription: cx.subscribe(&picker, |_, _, _, cx| {
@@ -116,32 +164,7 @@ impl PickerDelegate for AttachModalDelegate {
     ) -> gpui::Task<()> {
         cx.spawn(async move |this, cx| {
             let Some(processes) = this
-                .update(cx, |this, _| {
-                    if let Some(processes) = this.delegate.candidates.clone() {
-                        processes
-                    } else {
-                        let system = System::new_all();
-
-                        let processes =
-                            attach_processes(&this.delegate.debug_config.kind, &system.processes());
-                        let candidates = processes
-                            .into_iter()
-                            .map(|(pid, process)| Candidate {
-                                pid: pid.as_u32(),
-                                name: process.name().to_string_lossy().into_owned(),
-                                command: process
-                                    .cmd()
-                                    .iter()
-                                    .map(|s| s.to_string_lossy().to_string())
-                                    .collect::<Vec<_>>(),
-                            })
-                            .collect::<Vec<Candidate>>();
-
-                        let _ = this.delegate.candidates.insert(candidates.clone());
-
-                        candidates
-                    }
-                })
+                .update(cx, |this, _| this.delegate.candidates.clone())
                 .ok()
             else {
                 return;
@@ -176,7 +199,6 @@ impl PickerDelegate for AttachModalDelegate {
                 let delegate = &mut this.delegate;
 
                 delegate.matches = matches;
-                delegate.candidates = Some(processes);
 
                 if delegate.matches.is_empty() {
                     delegate.selected_index = 0;
@@ -195,7 +217,7 @@ impl PickerDelegate for AttachModalDelegate {
             .get(self.selected_index())
             .and_then(|current_match| {
                 let ix = current_match.candidate_id;
-                self.candidates.as_ref().map(|candidates| &candidates[ix])
+                self.candidates.get(ix)
             });
 
         let Some(candidate) = candidate else {
@@ -206,7 +228,7 @@ impl PickerDelegate for AttachModalDelegate {
             DebugRequestType::Attach(config) => {
                 config.process_id = Some(candidate.pid);
             }
-            DebugRequestType::Launch => {
+            DebugRequestType::Launch(_) => {
                 debug_panic!("Debugger attach modal used on launch debug config");
                 return;
             }
@@ -214,7 +236,13 @@ impl PickerDelegate for AttachModalDelegate {
 
         let config = self.debug_config.clone();
         self.project
-            .update(cx, |project, cx| project.start_debug_session(config, cx))
+            .update(cx, |project, cx| {
+                #[cfg(any(test, feature = "test-support"))]
+                let ret = project.fake_debug_session(config.request, None, false, cx);
+                #[cfg(not(any(test, feature = "test-support")))]
+                let ret = project.start_debug_session(config.into(), cx);
+                ret
+            })
             .detach_and_log_err(cx);
 
         cx.emit(DismissEvent);
@@ -222,7 +250,6 @@ impl PickerDelegate for AttachModalDelegate {
 
     fn dismissed(&mut self, _window: &mut Window, cx: &mut Context<Picker<Self>>) {
         self.selected_index = 0;
-        self.candidates.take();
 
         cx.emit(DismissEvent);
     }
@@ -234,9 +261,8 @@ impl PickerDelegate for AttachModalDelegate {
         _window: &mut Window,
         _: &mut Context<Picker<Self>>,
     ) -> Option<Self::ListItem> {
-        let candidates = self.candidates.as_ref()?;
         let hit = &self.matches[ix];
-        let candidate = &candidates.get(hit.candidate_id)?;
+        let candidate = self.candidates.get(hit.candidate_id)?;
 
         Some(
             ListItem::new(SharedString::from(format!("process-entry-{ix}")))
@@ -279,9 +305,8 @@ impl PickerDelegate for AttachModalDelegate {
     }
 }
 
-#[allow(dead_code)]
 #[cfg(any(test, feature = "test-support"))]
-pub(crate) fn process_names(modal: &AttachModal, cx: &mut Context<AttachModal>) -> Vec<String> {
+pub(crate) fn _process_names(modal: &AttachModal, cx: &mut Context<AttachModal>) -> Vec<String> {
     modal.picker.update(cx, |picker, _| {
         picker
             .delegate

crates/debugger_ui/src/debugger_panel.rs

@@ -3,8 +3,8 @@ use anyhow::{anyhow, Result};
 use collections::HashMap;
 use command_palette_hooks::CommandPaletteFilter;
 use dap::{
-    client::SessionId, debugger_settings::DebuggerSettings, ContinuedEvent, DebugAdapterConfig,
-    LoadedSourceEvent, ModuleEvent, OutputEvent, StoppedEvent, ThreadEvent,
+    client::SessionId, debugger_settings::DebuggerSettings, ContinuedEvent, LoadedSourceEvent,
+    ModuleEvent, OutputEvent, StoppedEvent, ThreadEvent,
 };
 use futures::{channel::mpsc, SinkExt as _};
 use gpui::{
@@ -19,6 +19,7 @@ use project::{
 use rpc::proto::{self};
 use settings::Settings;
 use std::{any::TypeId, path::PathBuf};
+use task::DebugTaskDefinition;
 use terminal_view::terminal_panel::TerminalPanel;
 use ui::prelude::*;
 use util::ResultExt;
@@ -52,7 +53,7 @@ pub struct DebugPanel {
     project: WeakEntity<Project>,
     workspace: WeakEntity<Workspace>,
     _subscriptions: Vec<Subscription>,
-    pub(crate) last_inert_config: Option<DebugAdapterConfig>,
+    pub(crate) last_inert_config: Option<DebugTaskDefinition>,
 }
 
 impl DebugPanel {

crates/debugger_ui/src/session.rs

@@ -6,7 +6,6 @@ mod starting;
 use std::time::Duration;
 
 use dap::client::SessionId;
-use dap::DebugAdapterConfig;
 use failed::FailedState;
 use gpui::{
     percentage, Animation, AnimationExt, AnyElement, App, Entity, EventEmitter, FocusHandle,
@@ -19,6 +18,7 @@ use project::Project;
 use rpc::proto::{self, PeerId};
 use running::RunningState;
 use starting::{StartingEvent, StartingState};
+use task::DebugTaskDefinition;
 use ui::{prelude::*, Indicator};
 use util::ResultExt;
 use workspace::{
@@ -73,7 +73,7 @@ impl DebugSession {
         project: Entity<Project>,
         workspace: WeakEntity<Workspace>,
         debug_panel: WeakEntity<DebugPanel>,
-        config: Option<DebugAdapterConfig>,
+        config: Option<DebugTaskDefinition>,
         window: &mut Window,
         cx: &mut App,
     ) -> Entity<Self> {
@@ -171,7 +171,7 @@ impl DebugSession {
             .flatten()
             .expect("worktree-less project");
         let Ok((new_session_id, task)) = dap_store.update(cx, |store, cx| {
-            store.new_session(config, &worktree, None, cx)
+            store.new_session(config.into(), &worktree, None, cx)
         }) else {
             return;
         };

crates/debugger_ui/src/session/inert.rs

@@ -1,10 +1,10 @@
 use std::path::PathBuf;
 
-use dap::{DebugAdapterConfig, DebugAdapterKind, DebugRequestType};
+use dap::DebugRequestType;
 use editor::{Editor, EditorElement, EditorStyle};
 use gpui::{App, AppContext, Entity, EventEmitter, FocusHandle, Focusable, TextStyle, WeakEntity};
 use settings::Settings as _;
-use task::TCPHost;
+use task::{DebugTaskDefinition, LaunchConfig, TCPHost};
 use theme::ThemeSettings;
 use ui::{
     div, h_flex, relative, v_flex, ActiveTheme as _, ButtonCommon, ButtonLike, Clickable, Context,
@@ -35,7 +35,7 @@ impl SpawnMode {
 impl From<DebugRequestType> for SpawnMode {
     fn from(request: DebugRequestType) -> Self {
         match request {
-            DebugRequestType::Launch => SpawnMode::Launch,
+            DebugRequestType::Launch(_) => SpawnMode::Launch,
             DebugRequestType::Attach(_) => SpawnMode::Attach,
         }
     }
@@ -55,18 +55,13 @@ impl InertState {
     pub(super) fn new(
         workspace: WeakEntity<Workspace>,
         default_cwd: &str,
-        debug_config: Option<DebugAdapterConfig>,
+        debug_config: Option<DebugTaskDefinition>,
         window: &mut Window,
         cx: &mut Context<Self>,
     ) -> Self {
-        let selected_debugger = debug_config.as_ref().and_then(|config| match config.kind {
-            DebugAdapterKind::Lldb => Some("LLDB".into()),
-            DebugAdapterKind::Go(_) => Some("Delve".into()),
-            DebugAdapterKind::Php(_) => Some("PHP".into()),
-            DebugAdapterKind::Javascript(_) => Some("JavaScript".into()),
-            DebugAdapterKind::Python(_) => Some("Debugpy".into()),
-            _ => None,
-        });
+        let selected_debugger = debug_config
+            .as_ref()
+            .map(|config| SharedString::from(config.adapter.clone()));
 
         let spawn_mode = debug_config
             .as_ref()
@@ -75,7 +70,10 @@ impl InertState {
 
         let program = debug_config
             .as_ref()
-            .and_then(|config| config.program.to_owned());
+            .and_then(|config| match &config.request {
+                DebugRequestType::Attach(_) => None,
+                DebugRequestType::Launch(launch_config) => Some(launch_config.program.clone()),
+            });
 
         let program_editor = cx.new(|cx| {
             let mut editor = Editor::single_line(window, cx);
@@ -88,7 +86,10 @@ impl InertState {
         });
 
         let cwd = debug_config
-            .and_then(|config| config.cwd.map(|cwd| cwd.to_owned()))
+            .and_then(|config| match &config.request {
+                DebugRequestType::Attach(_) => None,
+                DebugRequestType::Launch(launch_config) => launch_config.cwd.clone(),
+            })
             .unwrap_or_else(|| PathBuf::from(default_cwd));
 
         let cwd_editor = cx.new(|cx| {
@@ -116,7 +117,7 @@ impl Focusable for InertState {
 }
 
 pub(crate) enum InertEvent {
-    Spawned { config: DebugAdapterConfig },
+    Spawned { config: DebugTaskDefinition },
 }
 
 impl EventEmitter<InertEvent> for InertState {}
@@ -130,6 +131,7 @@ impl Render for InertState {
         cx: &mut ui::Context<'_, Self>,
     ) -> impl ui::IntoElement {
         let weak = cx.weak_entity();
+        let workspace = self.workspace.clone();
         let disable_buttons = self.selected_debugger.is_none();
         let spawn_button = ButtonLike::new_rounded_left("spawn-debug-session")
             .child(Label::new(self.spawn_mode.label()).size(LabelSize::Small))
@@ -137,21 +139,26 @@ impl Render for InertState {
                 if this.spawn_mode == SpawnMode::Launch {
                     let program = this.program_editor.read(cx).text(cx);
                     let cwd = PathBuf::from(this.cwd_editor.read(cx).text(cx));
-                    let kind =
-                        kind_for_label(this.selected_debugger.as_deref().unwrap_or_else(|| {
+                    let kind = this
+                        .selected_debugger
+                        .as_deref()
+                        .unwrap_or_else(|| {
                             unimplemented!(
                                 "Automatic selection of a debugger based on users project"
                             )
-                        }));
+                        })
+                        .to_string();
+
                     cx.emit(InertEvent::Spawned {
-                        config: DebugAdapterConfig {
+                        config: DebugTaskDefinition {
                             label: "hard coded".into(),
-                            kind,
-                            request: DebugRequestType::Launch,
-                            program: Some(program),
-                            cwd: Some(cwd),
+                            adapter: kind,
+                            request: DebugRequestType::Launch(LaunchConfig {
+                                program,
+                                cwd: Some(cwd),
+                            }),
+                            tcp_connection: Some(TCPHost::default()),
                             initialize_args: None,
-                            supports_attach: false,
                         },
                     });
                 } else {
@@ -159,6 +166,7 @@ impl Render for InertState {
                 }
             }))
             .disabled(disable_buttons);
+
         v_flex()
             .track_focus(&self.focus_handle)
             .size_full()
@@ -179,28 +187,36 @@ impl Render for InertState {
                                         .as_ref()
                                         .unwrap_or_else(|| &SELECT_DEBUGGER_LABEL)
                                         .clone(),
-                                    ContextMenu::build(window, cx, move |this, _, _| {
-                                        let setter_for_name = |name: &'static str| {
+                                    ContextMenu::build(window, cx, move |mut this, _, cx| {
+                                        let setter_for_name = |name: SharedString| {
                                             let weak = weak.clone();
                                             move |_: &mut Window, cx: &mut App| {
-                                                let name = name;
-                                                (&weak)
-                                                    .update(cx, move |this, _| {
-                                                        this.selected_debugger = Some(name.into());
-                                                    })
-                                                    .ok();
+                                                let name = name.clone();
+                                                weak.update(cx, move |this, cx| {
+                                                    this.selected_debugger = Some(name.clone());
+                                                    cx.notify();
+                                                })
+                                                .ok();
                                             }
                                         };
-                                        this.entry("GDB", None, setter_for_name("GDB"))
-                                            .entry("Delve", None, setter_for_name("Delve"))
-                                            .entry("LLDB", None, setter_for_name("LLDB"))
-                                            .entry("PHP", None, setter_for_name("PHP"))
-                                            .entry(
-                                                "JavaScript",
+                                        let available_adapters = workspace
+                                            .update(cx, |this, cx| {
+                                                this.project()
+                                                    .read(cx)
+                                                    .debug_adapters()
+                                                    .enumerate_adapters()
+                                            })
+                                            .ok()
+                                            .unwrap_or_default();
+
+                                        for adapter in available_adapters {
+                                            this = this.entry(
+                                                adapter.0.clone(),
                                                 None,
-                                                setter_for_name("JavaScript"),
-                                            )
-                                            .entry("Debugpy", None, setter_for_name("Debugpy"))
+                                                setter_for_name(adapter.0.clone()),
+                                            );
+                                        }
+                                        this
                                     }),
                                 )),
                             ),
@@ -265,18 +281,6 @@ impl Render for InertState {
     }
 }
 
-fn kind_for_label(label: &str) -> DebugAdapterKind {
-    match label {
-        "LLDB" => DebugAdapterKind::Lldb,
-        "Debugpy" => DebugAdapterKind::Python(TCPHost::default()),
-        "JavaScript" => DebugAdapterKind::Javascript(TCPHost::default()),
-        "PHP" => DebugAdapterKind::Php(TCPHost::default()),
-        "Delve" => DebugAdapterKind::Go(TCPHost::default()),
-        _ => {
-            unimplemented!()
-        } // Maybe we should set a toast notification here
-    }
-}
 impl InertState {
     fn render_editor(editor: &Entity<Editor>, cx: &Context<Self>) -> impl IntoElement {
         let settings = ThemeSettings::get_global(cx);
@@ -302,19 +306,20 @@ impl InertState {
     }
 
     fn attach(&self, window: &mut Window, cx: &mut Context<Self>) {
-        let cwd = PathBuf::from(self.cwd_editor.read(cx).text(cx));
-        let kind = kind_for_label(self.selected_debugger.as_deref().unwrap_or_else(|| {
-            unimplemented!("Automatic selection of a debugger based on users project")
-        }));
+        let kind = self
+            .selected_debugger
+            .as_deref()
+            .map(|s| s.to_string())
+            .unwrap_or_else(|| {
+                unimplemented!("Automatic selection of a debugger based on users project")
+            });
 
-        let config = DebugAdapterConfig {
+        let config = DebugTaskDefinition {
             label: "hard coded attach".into(),
-            kind,
+            adapter: kind,
             request: DebugRequestType::Attach(task::AttachConfig { process_id: None }),
-            program: None,
-            cwd: Some(cwd),
             initialize_args: None,
-            supports_attach: true,
+            tcp_connection: Some(TCPHost::default()),
         };
 
         let _ = self.workspace.update(cx, |workspace, cx| {

crates/debugger_ui/src/tests/attach_modal.rs

@@ -1,11 +1,11 @@
-use crate::*;
+use crate::{attach_modal::Candidate, *};
 use attach_modal::AttachModal;
-use dap::client::SessionId;
+use dap::{client::SessionId, FakeAdapter};
 use gpui::{BackgroundExecutor, TestAppContext, VisualTestContext};
 use menu::Confirm;
 use project::{FakeFs, Project};
 use serde_json::json;
-use task::AttachConfig;
+use task::{AttachConfig, DebugTaskDefinition, TCPHost};
 use tests::{init_test, init_test_workspace};
 
 #[gpui::test]
@@ -27,14 +27,12 @@ async fn test_direct_attach_to_process(executor: BackgroundExecutor, cx: &mut Te
     let cx = &mut VisualTestContext::from_window(*workspace, cx);
 
     let task = project.update(cx, |project, cx| {
-        project.start_debug_session(
-            dap::test_config(
-                dap::DebugRequestType::Attach(AttachConfig {
-                    process_id: Some(10),
-                }),
-                None,
-                None,
-            ),
+        project.fake_debug_session(
+            dap::DebugRequestType::Attach(AttachConfig {
+                process_id: Some(10),
+            }),
+            None,
+            false,
             cx,
         )
     });
@@ -83,13 +81,32 @@ async fn test_show_attach_modal_and_select_process(
     let attach_modal = workspace
         .update(cx, |workspace, window, cx| {
             workspace.toggle_modal(window, cx, |window, cx| {
-                AttachModal::new(
+                AttachModal::with_processes(
                     project.clone(),
-                    dap::test_config(
-                        dap::DebugRequestType::Attach(AttachConfig { process_id: None }),
-                        None,
-                        None,
-                    ),
+                    DebugTaskDefinition {
+                        adapter: FakeAdapter::ADAPTER_NAME.into(),
+                        request: dap::DebugRequestType::Attach(AttachConfig::default()),
+                        label: "attach example".into(),
+                        initialize_args: None,
+                        tcp_connection: Some(TCPHost::default()),
+                    },
+                    vec![
+                        Candidate {
+                            pid: 0,
+                            name: "fake-binary-1".into(),
+                            command: vec![],
+                        },
+                        Candidate {
+                            pid: 3,
+                            name: "non-fake-binary-1".into(),
+                            command: vec![],
+                        },
+                        Candidate {
+                            pid: 1,
+                            name: "fake-binary-2".into(),
+                            command: vec![],
+                        },
+                    ],
                     window,
                     cx,
                 )
@@ -105,10 +122,10 @@ async fn test_show_attach_modal_and_select_process(
     workspace
         .update(cx, |_, _, cx| {
             let names =
-                attach_modal.update(cx, |modal, cx| attach_modal::process_names(&modal, cx));
+                attach_modal.update(cx, |modal, cx| attach_modal::_process_names(&modal, cx));
 
-            // we filtered out all processes that are not the current process(zed itself)
-            assert_eq!(1, names.len());
+            // we filtered out all processes that are not starting with `fake-binary`
+            assert_eq!(2, names.len());
         })
         .unwrap();
 

crates/debugger_ui/src/tests/console.rs

@@ -3,6 +3,7 @@ use dap::requests::StackTrace;
 use gpui::{BackgroundExecutor, TestAppContext, VisualTestContext};
 use project::{FakeFs, Project};
 use serde_json::json;
+use task::LaunchConfig;
 use tests::{init_test, init_test_workspace};
 
 #[gpui::test]
@@ -29,8 +30,10 @@ async fn test_handle_output_event(executor: BackgroundExecutor, cx: &mut TestApp
         .unwrap();
 
     let task = project.update(cx, |project, cx| {
-        project.start_debug_session(
-            dap::test_config(dap::DebugRequestType::Launch, None, None),
+        project.fake_debug_session(
+            dap::DebugRequestType::Launch(LaunchConfig::default()),
+            None,
+            false,
             cx,
         )
     });

crates/debugger_ui/src/tests/debugger_panel.rs

@@ -5,8 +5,8 @@ use dap::{
         Continue, Disconnect, Launch, Next, RunInTerminal, SetBreakpoints, StackTrace,
         StartDebugging, StepBack, StepIn, StepOut, Threads,
     },
-    DebugRequestType, ErrorResponse, RunInTerminalRequestArguments, SourceBreakpoint,
-    StartDebuggingRequestArguments, StartDebuggingRequestArgumentsRequest,
+    ErrorResponse, RunInTerminalRequestArguments, SourceBreakpoint, StartDebuggingRequestArguments,
+    StartDebuggingRequestArgumentsRequest,
 };
 use editor::{
     actions::{self},
@@ -25,6 +25,7 @@ use std::{
         Arc,
     },
 };
+use task::LaunchConfig;
 use terminal_view::{terminal_panel::TerminalPanel, TerminalView};
 use tests::{active_debug_session_panel, init_test, init_test_workspace};
 use util::path;
@@ -49,7 +50,12 @@ async fn test_basic_show_debug_panel(executor: BackgroundExecutor, cx: &mut Test
     let cx = &mut VisualTestContext::from_window(*workspace, cx);
 
     let task = project.update(cx, |project, cx| {
-        project.start_debug_session(dap::test_config(DebugRequestType::Launch, None, None), cx)
+        project.fake_debug_session(
+            dap::DebugRequestType::Launch(LaunchConfig::default()),
+            None,
+            false,
+            cx,
+        )
     });
 
     let session = task.await.unwrap();
@@ -201,7 +207,12 @@ async fn test_we_can_only_have_one_panel_per_debug_session(
     let cx = &mut VisualTestContext::from_window(*workspace, cx);
 
     let task = project.update(cx, |project, cx| {
-        project.start_debug_session(dap::test_config(DebugRequestType::Launch, None, None), cx)
+        project.fake_debug_session(
+            dap::DebugRequestType::Launch(LaunchConfig::default()),
+            None,
+            false,
+            cx,
+        )
     });
 
     let session = task.await.unwrap();
@@ -385,7 +396,12 @@ async fn test_handle_successful_run_in_terminal_reverse_request(
     let cx = &mut VisualTestContext::from_window(*workspace, cx);
 
     let task = project.update(cx, |project, cx| {
-        project.start_debug_session(dap::test_config(DebugRequestType::Launch, None, None), cx)
+        project.fake_debug_session(
+            dap::DebugRequestType::Launch(LaunchConfig::default()),
+            None,
+            false,
+            cx,
+        )
     });
 
     let session = task.await.unwrap();
@@ -475,7 +491,12 @@ async fn test_handle_error_run_in_terminal_reverse_request(
     let cx = &mut VisualTestContext::from_window(*workspace, cx);
 
     let task = project.update(cx, |project, cx| {
-        project.start_debug_session(dap::test_config(DebugRequestType::Launch, None, None), cx)
+        project.fake_debug_session(
+            dap::DebugRequestType::Launch(LaunchConfig::default()),
+            None,
+            false,
+            cx,
+        )
     });
 
     let session = task.await.unwrap();
@@ -555,7 +576,12 @@ async fn test_handle_start_debugging_reverse_request(
     let cx = &mut VisualTestContext::from_window(*workspace, cx);
 
     let task = project.update(cx, |project, cx| {
-        project.start_debug_session(dap::test_config(DebugRequestType::Launch, None, None), cx)
+        project.fake_debug_session(
+            dap::DebugRequestType::Launch(LaunchConfig::default()),
+            None,
+            false,
+            cx,
+        )
     });
 
     let session = task.await.unwrap();
@@ -668,7 +694,12 @@ async fn test_shutdown_children_when_parent_session_shutdown(
     let cx = &mut VisualTestContext::from_window(*workspace, cx);
 
     let task = project.update(cx, |project, cx| {
-        project.start_debug_session(dap::test_config(DebugRequestType::Launch, None, None), cx)
+        project.fake_debug_session(
+            dap::DebugRequestType::Launch(LaunchConfig::default()),
+            None,
+            false,
+            cx,
+        )
     });
 
     let parent_session = task.await.unwrap();
@@ -776,7 +807,12 @@ async fn test_shutdown_parent_session_if_all_children_are_shutdown(
     let cx = &mut VisualTestContext::from_window(*workspace, cx);
 
     let task = project.update(cx, |project, cx| {
-        project.start_debug_session(dap::test_config(DebugRequestType::Launch, None, None), cx)
+        project.fake_debug_session(
+            dap::DebugRequestType::Launch(LaunchConfig::default()),
+            None,
+            false,
+            cx,
+        )
     });
 
     let parent_session = task.await.unwrap();
@@ -891,15 +927,13 @@ async fn test_debug_panel_item_thread_status_reset_on_failure(
     let cx = &mut VisualTestContext::from_window(*workspace, cx);
 
     let task = project.update(cx, |project, cx| {
-        project.start_debug_session(
-            dap::test_config(
-                DebugRequestType::Launch,
-                None,
-                Some(dap::Capabilities {
-                    supports_step_back: Some(true),
-                    ..Default::default()
-                }),
-            ),
+        project.fake_debug_session(
+            dap::DebugRequestType::Launch(LaunchConfig::default()),
+            Some(dap::Capabilities {
+                supports_step_back: Some(true),
+                ..Default::default()
+            }),
+            false,
             cx,
         )
     });
@@ -1122,7 +1156,12 @@ async fn test_send_breakpoints_when_editor_has_been_saved(
         .unwrap();
 
     let task = project.update(cx, |project, cx| {
-        project.start_debug_session(dap::test_config(DebugRequestType::Launch, None, None), cx)
+        project.fake_debug_session(
+            dap::DebugRequestType::Launch(LaunchConfig::default()),
+            None,
+            false,
+            cx,
+        )
     });
 
     let session = task.await.unwrap();
@@ -1347,7 +1386,12 @@ async fn test_unsetting_breakpoints_on_clear_breakpoint_action(
     });
 
     let task = project.update(cx, |project, cx| {
-        project.start_debug_session(dap::test_config(DebugRequestType::Launch, None, None), cx)
+        project.fake_debug_session(
+            dap::DebugRequestType::Launch(LaunchConfig::default()),
+            None,
+            false,
+            cx,
+        )
     });
 
     let session = task.await.unwrap();
@@ -1419,8 +1463,10 @@ async fn test_debug_session_is_shutdown_when_attach_and_launch_request_fails(
     let cx = &mut VisualTestContext::from_window(*workspace, cx);
 
     let task = project.update(cx, |project, cx| {
-        project.start_debug_session(
-            dap::test_config(DebugRequestType::Launch, Some(true), None),
+        project.fake_debug_session(
+            dap::DebugRequestType::Launch(LaunchConfig::default()),
+            None,
+            true,
             cx,
         )
     });

crates/debugger_ui/src/tests/module_list.rs

@@ -5,7 +5,7 @@ use crate::{
 };
 use dap::{
     requests::{Modules, StackTrace, Threads},
-    DebugRequestType, StoppedEvent,
+    StoppedEvent,
 };
 use gpui::{BackgroundExecutor, TestAppContext, VisualTestContext};
 use project::{FakeFs, Project};
@@ -13,6 +13,7 @@ use std::sync::{
     atomic::{AtomicBool, AtomicI32, Ordering},
     Arc,
 };
+use task::LaunchConfig;
 
 #[gpui::test]
 async fn test_module_list(executor: BackgroundExecutor, cx: &mut TestAppContext) {
@@ -30,15 +31,13 @@ async fn test_module_list(executor: BackgroundExecutor, cx: &mut TestAppContext)
     let cx = &mut VisualTestContext::from_window(*workspace, cx);
 
     let task = project.update(cx, |project, cx| {
-        project.start_debug_session(
-            dap::test_config(
-                DebugRequestType::Launch,
-                None,
-                Some(dap::Capabilities {
-                    supports_modules_request: Some(true),
-                    ..Default::default()
-                }),
-            ),
+        project.fake_debug_session(
+            dap::DebugRequestType::Launch(LaunchConfig::default()),
+            Some(dap::Capabilities {
+                supports_modules_request: Some(true),
+                ..Default::default()
+            }),
+            false,
             cx,
         )
     });

crates/debugger_ui/src/tests/stack_frame_list.rs

@@ -12,6 +12,7 @@ use gpui::{BackgroundExecutor, TestAppContext, VisualTestContext};
 use project::{FakeFs, Project};
 use serde_json::json;
 use std::sync::Arc;
+use task::LaunchConfig;
 use unindent::Unindent as _;
 use util::path;
 
@@ -52,8 +53,10 @@ async fn test_fetch_initial_stack_frames_and_go_to_stack_frame(
     let cx = &mut VisualTestContext::from_window(*workspace, cx);
 
     let task = project.update(cx, |project, cx| {
-        project.start_debug_session(
-            dap::test_config(dap::DebugRequestType::Launch, None, None),
+        project.fake_debug_session(
+            dap::DebugRequestType::Launch(LaunchConfig::default()),
+            None,
+            false,
             cx,
         )
     });
@@ -240,8 +243,10 @@ async fn test_select_stack_frame(executor: BackgroundExecutor, cx: &mut TestAppC
     let cx = &mut VisualTestContext::from_window(*workspace, cx);
 
     let task = project.update(cx, |project, cx| {
-        project.start_debug_session(
-            dap::test_config(dap::DebugRequestType::Launch, None, None),
+        project.fake_debug_session(
+            dap::DebugRequestType::Launch(LaunchConfig::default()),
+            None,
+            false,
             cx,
         )
     });
@@ -513,8 +518,10 @@ async fn test_collapsed_entries(executor: BackgroundExecutor, cx: &mut TestAppCo
     let cx = &mut VisualTestContext::from_window(*workspace, cx);
 
     let task = project.update(cx, |project, cx| {
-        project.start_debug_session(
-            dap::test_config(dap::DebugRequestType::Launch, None, None),
+        project.fake_debug_session(
+            dap::DebugRequestType::Launch(LaunchConfig::default()),
+            None,
+            false,
             cx,
         )
     });

crates/debugger_ui/src/tests/variable_list.rs

@@ -17,6 +17,7 @@ use gpui::{BackgroundExecutor, TestAppContext, VisualTestContext};
 use menu::{SelectFirst, SelectNext, SelectPrevious};
 use project::{FakeFs, Project};
 use serde_json::json;
+use task::LaunchConfig;
 use unindent::Unindent as _;
 use util::path;
 
@@ -56,8 +57,10 @@ async fn test_basic_fetch_initial_scope_and_variables(
     let cx = &mut VisualTestContext::from_window(*workspace, cx);
 
     let task = project.update(cx, |project, cx| {
-        project.start_debug_session(
-            dap::test_config(dap::DebugRequestType::Launch, None, None),
+        project.fake_debug_session(
+            dap::DebugRequestType::Launch(LaunchConfig::default()),
+            None,
+            false,
             cx,
         )
     });
@@ -283,8 +286,10 @@ async fn test_fetch_variables_for_multiple_scopes(
     let cx = &mut VisualTestContext::from_window(*workspace, cx);
 
     let task = project.update(cx, |project, cx| {
-        project.start_debug_session(
-            dap::test_config(dap::DebugRequestType::Launch, None, None),
+        project.fake_debug_session(
+            dap::DebugRequestType::Launch(LaunchConfig::default()),
+            None,
+            false,
             cx,
         )
     });
@@ -562,8 +567,10 @@ async fn test_keyboard_navigation(executor: BackgroundExecutor, cx: &mut TestApp
     let cx = &mut VisualTestContext::from_window(*workspace, cx);
 
     let task = project.update(cx, |project, cx| {
-        project.start_debug_session(
-            dap::test_config(dap::DebugRequestType::Launch, None, None),
+        project.fake_debug_session(
+            dap::DebugRequestType::Launch(LaunchConfig::default()),
+            None,
+            false,
             cx,
         )
     });
@@ -1362,8 +1369,10 @@ async fn test_variable_list_only_sends_requests_when_rendering(
     let cx = &mut VisualTestContext::from_window(*workspace, cx);
 
     let task = project.update(cx, |project, cx| {
-        project.start_debug_session(
-            dap::test_config(dap::DebugRequestType::Launch, None, None),
+        project.fake_debug_session(
+            dap::DebugRequestType::Launch(LaunchConfig::default()),
+            None,
+            false,
             cx,
         )
     });
@@ -1639,8 +1648,10 @@ async fn test_it_fetches_scopes_variables_when_you_select_a_stack_frame(
     let cx = &mut VisualTestContext::from_window(*workspace, cx);
 
     let task = project.update(cx, |project, cx| {
-        project.start_debug_session(
-            dap::test_config(dap::DebugRequestType::Launch, None, None),
+        project.fake_debug_session(
+            dap::DebugRequestType::Launch(LaunchConfig::default()),
+            None,
+            false,
             cx,
         )
     });