Remove request timeout from DAP (#30567)

Release Notes:

- N/A

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 futures::channel::oneshot;
-use gpui::{AppContext, AsyncApp, BackgroundExecutor};
+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! {
+        let response = callback_rx.await??;
-            response = callback_rx.fuse() => {
+        log::debug!(
-                log::debug!(
+            "Client {} received response for: `{}` sequence_id: {}",
-                    "Client {} received response for: `{}` sequence_id: {}",
+            self.id.0,
-                    self.id.0,
+            command,
-                    command,
+            sequence_id
-                    sequence_id
+        );
-                );
+        match response.success {
-
+            true => {
-                let response = response??;
+                if let Some(json) = response.body {
-                match response.success {
+                    Ok(serde_json::from_value(json)?)
-                    true => {
+                // Note: dap types configure themselves to return `None` when an empty object is received,
-                        if let Some(json) = response.body {
+                // which then fails here...
-                            Ok(serde_json::from_value(json)?)
+                } else if let Ok(result) =
-                        // Note: dap types configure themselves to return `None` when an empty object is received,
+                    serde_json::from_value(serde_json::Value::Object(Default::default()))
-                        // which then fails here...
+                {
-                        } else if let Ok(result) = serde_json::from_value(serde_json::Value::Object(Default::default())) {
+                    Ok(result)
-                            Ok(result)
+                } else {
-                        } else {
+                    Ok(serde_json::from_value(Default::default())?)
-                            Ok(serde_json::from_value(Default::default())?)
-                        }
-                    }
-                    false => Err(anyhow!("Request failed: {}", response.message.unwrap_or_default())),
                 }
             }
-
+            false => Err(anyhow!(
-            _ = timeout => {
+                "Request failed: {}",
-                self.transport_delegate.cancel_pending_request(&sequence_id).await;
+                response.message.unwrap_or_default()
-                log::error!("Cancelled DAP request for {command:?} id {sequence_id} which took over {DAP_REQUEST_TIMEOUT:?}");
+            )),
-                anyhow::bail!("DAP request timeout");
-            }
         }
     }
 

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