From 81dcc12c6291c6ad59f4a2f633d391be1049dd3e Mon Sep 17 00:00:00 2001
From: Conrad Irwin <conrad.irwin@gmail.com>
Date: Tue, 13 May 2025 14:25:52 +0200
Subject: [PATCH] Remove request timeout from DAP (#30567)

Release Notes:

- N/A
---
 crates/dap/src/client.rs    | 66 ++++++++++++++-----------------------
 crates/dap/src/transport.rs |  5 ---
 2 files changed, 25 insertions(+), 46 deletions(-)

diff --git a/crates/dap/src/client.rs b/crates/dap/src/client.rs
index 869b352edf2cd506d0d6e3f626c8224ae1505ad0..b0fe116699f71ade60b6f99580b236c706a89d02 100644
--- a/crates/dap/src/client.rs
+++ b/crates/dap/src/client.rs
@@ -7,21 +7,14 @@ use dap_types::{
     messages::{Message, Response},
     requests::Request,
 };
-use futures::{FutureExt as _, channel::oneshot, select};
-use gpui::{AppContext, AsyncApp, BackgroundExecutor};
+use futures::channel::oneshot;
+use gpui::{AppContext, AsyncApp};
 use smol::channel::{Receiver, Sender};
 use std::{
     hash::Hash,
     sync::atomic::{AtomicU64, Ordering},
-    time::Duration,
 };
 
-#[cfg(any(test, feature = "test-support"))]
-const DAP_REQUEST_TIMEOUT: Duration = Duration::from_secs(2);
-
-#[cfg(not(any(test, feature = "test-support")))]
-const DAP_REQUEST_TIMEOUT: Duration = Duration::from_secs(12);
-
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
 #[repr(transparent)]
 pub struct SessionId(pub u32);
@@ -41,7 +34,6 @@ pub struct DebugAdapterClient {
     id: SessionId,
     sequence_count: AtomicU64,
     binary: DebugAdapterBinary,
-    executor: BackgroundExecutor,
     transport_delegate: TransportDelegate,
 }
 
@@ -61,7 +53,6 @@ impl DebugAdapterClient {
             binary,
             transport_delegate,
             sequence_count: AtomicU64::new(1),
-            executor: cx.background_executor().clone(),
         };
         log::info!("Successfully connected to debug adapter");
 
@@ -173,40 +164,33 @@ impl DebugAdapterClient {
 
         self.send_message(Message::Request(request)).await?;
 
-        let mut timeout = self.executor.timer(DAP_REQUEST_TIMEOUT).fuse();
         let command = R::COMMAND.to_string();
 
-        select! {
-            response = callback_rx.fuse() => {
-                log::debug!(
-                    "Client {} received response for: `{}` sequence_id: {}",
-                    self.id.0,
-                    command,
-                    sequence_id
-                );
-
-                let response = response??;
-                match response.success {
-                    true => {
-                        if let Some(json) = response.body {
-                            Ok(serde_json::from_value(json)?)
-                        // Note: dap types configure themselves to return `None` when an empty object is received,
-                        // which then fails here...
-                        } else if let Ok(result) = serde_json::from_value(serde_json::Value::Object(Default::default())) {
-                            Ok(result)
-                        } else {
-                            Ok(serde_json::from_value(Default::default())?)
-                        }
-                    }
-                    false => Err(anyhow!("Request failed: {}", response.message.unwrap_or_default())),
+        let response = callback_rx.await??;
+        log::debug!(
+            "Client {} received response for: `{}` sequence_id: {}",
+            self.id.0,
+            command,
+            sequence_id
+        );
+        match response.success {
+            true => {
+                if let Some(json) = response.body {
+                    Ok(serde_json::from_value(json)?)
+                // Note: dap types configure themselves to return `None` when an empty object is received,
+                // which then fails here...
+                } else if let Ok(result) =
+                    serde_json::from_value(serde_json::Value::Object(Default::default()))
+                {
+                    Ok(result)
+                } else {
+                    Ok(serde_json::from_value(Default::default())?)
                 }
             }
-
-            _ = timeout => {
-                self.transport_delegate.cancel_pending_request(&sequence_id).await;
-                log::error!("Cancelled DAP request for {command:?} id {sequence_id} which took over {DAP_REQUEST_TIMEOUT:?}");
-                anyhow::bail!("DAP request timeout");
-            }
+            false => Err(anyhow!(
+                "Request failed: {}",
+                response.message.unwrap_or_default()
+            )),
         }
     }
 
diff --git a/crates/dap/src/transport.rs b/crates/dap/src/transport.rs
index 336367a7a8574caf8f638eceef5035911d923539..c38bca8dc6bf20868d37fb4bcaad77857600535a 100644
--- a/crates/dap/src/transport.rs
+++ b/crates/dap/src/transport.rs
@@ -224,11 +224,6 @@ impl TransportDelegate {
         pending_requests.insert(sequence_id, request);
     }
 
-    pub(crate) async fn cancel_pending_request(&self, sequence_id: &u64) {
-        let mut pending_requests = self.pending_requests.lock().await;
-        pending_requests.remove(sequence_id);
-    }
-
     pub(crate) async fn send_message(&self, message: Message) -> Result<()> {
         if let Some(server_tx) = self.server_tx.lock().await.as_ref() {
             server_tx