Move events into dap session

crates/dap/src/client.rs

@@ -128,7 +128,7 @@ impl DebugAdapterClient {
         client_id: DebugAdapterClientId,
         server_rx: Receiver<Message>,
         client_tx: Sender<Message>,
-        mut event_handler: F,
+        mut message_handler: F,
         cx: &mut AsyncApp,
     ) -> Result<()>
     where
@@ -144,9 +144,9 @@ impl DebugAdapterClient {
                 Message::Event(ev) => {
                     log::debug!("Client {} received event `{}`", client_id.0, &ev);
 
-                    cx.update(|cx| event_handler(Message::Event(ev), cx))
+                    cx.update(|cx| message_handler(Message::Event(ev), cx))
                 }
-                Message::Request(req) => cx.update(|cx| event_handler(Message::Request(req), cx)),
+                Message::Request(req) => cx.update(|cx| message_handler(Message::Request(req), cx)),
                 Message::Response(response) => {
                     log::debug!("Received response after request timeout: {:#?}", response);
 

crates/project/src/debugger/dap_session.rs

@@ -9,6 +9,8 @@ use collections::{BTreeMap, HashMap, IndexMap};
 use dap::client::{DebugAdapterClient, DebugAdapterClientId};
 use dap::requests::Request;
 use dap::{
+    messages::{self, Events, Message},
+    requests::{RunInTerminal, StartDebugging},
     Capabilities, ContinueArguments, EvaluateArgumentsContext, Module, Source, SteppingGranularity,
 };
 use futures::{future::Shared, FutureExt};
@@ -965,6 +967,40 @@ impl DebugSession {
         }
     }
 
+    fn handle_dap_event(&mut self, client_id: DebugAdapterClientId, event: Box<Events>) {}
+
+    fn handle_start_debugging_request(
+        &mut self,
+        client_id: DebugAdapterClientId,
+        request: messages::Request,
+    ) {
+    }
+
+    fn handle_run_in_terminal_request(
+        &mut self,
+        client_id: DebugAdapterClientId,
+        request: messages::Request,
+    ) {
+    }
+
+    pub(crate) fn handle_dap_message(&mut self, client_id: DebugAdapterClientId, message: Message) {
+        match message {
+            Message::Event(event) => {
+                self.handle_dap_event(client_id, event);
+            }
+            Message::Request(request) => {
+                if StartDebugging::COMMAND == request.command {
+                    self.handle_start_debugging_request(client_id, request);
+                } else if RunInTerminal::COMMAND == request.command {
+                    self.handle_run_in_terminal_request(client_id, request);
+                } else {
+                    debug_assert!(false, "Encountered unexpected command type");
+                }
+            }
+            _ => unreachable!(),
+        }
+    }
+
     pub fn ignore_breakpoints(&self) -> bool {
         self.ignore_breakpoints
     }

crates/project/src/debugger/dap_store.rs

@@ -527,7 +527,7 @@ impl DapStore {
 
     fn start_client_internal(
         &mut self,
-        session_id: DebugSessionId,
+        session: Entity<DebugSession>,
         delegate: DapAdapterDelegate,
         config: DebugAdapterConfig,
         cx: &mut Context<Self>,
@@ -537,6 +537,7 @@ impl DapStore {
         };
 
         let client_id = local_store.next_client_id();
+        let session = session.downgrade();
 
         cx.spawn(|this, mut cx| async move {
             let adapter = build_adapter(&config.kind).await?;
@@ -585,15 +586,10 @@ impl DapStore {
             client
                 .start(
                     {
-                        let dap_store = this.clone();
                         move |message, cx| {
-                            dap_store
-                                .update(cx, |_, cx| {
-                                    cx.emit(DapStoreEvent::DebugClientEvent {
-                                        session_id,
-                                        client_id,
-                                        message,
-                                    })
+                            session
+                                .update(cx, |session, cx| {
+                                    session.handle_dap_message(client_id, message);
                                 })
                                 .log_err();
                         }
@@ -629,13 +625,11 @@ impl DapStore {
             }),
         );
 
-        let session_id = local_store.next_session_id();
-        let start_client_task =
-            self.start_client_internal(session_id, delegate, config.clone(), cx);
+        let session =
+            cx.new(|_| DebugSession::new_local(local_store.next_session_id(), config.clone()));
+        let start_client_task = self.start_client_internal(session.clone(), delegate, config, cx);
 
         cx.spawn(|this, mut cx| async move {
-            let session = cx.new(|_| DebugSession::new_local(session_id, config))?;
-
             let client = match start_client_task.await {
                 Ok(client) => client,
                 Err(error) => {
@@ -654,6 +648,7 @@ impl DapStore {
                 });
 
                 let client_id = client.id();
+                let session_id = session.read(cx).id();
 
                 store.client_by_session.insert(client_id, session_id);
                 store.sessions.insert(session_id, session.clone());