-use helix_dap::{

- self as dap, registry::DebugAdapterId, Client, ConnectionType, Payload, Request, ThreadId,

-};

-use log::{error, warn};

-use serde_json::{json, Value};

- let Some(debugger) = $editor.debug_adapters.get_active_client_mut() else {

- return;

- };

- debugger

- let frame = debugger.stack_frames[&thread_id].first().cloned();

- pub async fn handle_debugger_message(

- &mut self,

- id: DebugAdapterId,

- payload: helix_dap::Payload,

- ) -> bool {

- Payload::Event(event) => {

- let event = match Event::parse(&event.event, event.body) {

- Ok(event) => event,

- Err(dap::Error::Unhandled) => {

- log::info!("Discarding unknown DAP event '{}'", event.event);

- return false;

- }

- Err(err) => {

- log::warn!("Discarding invalid DAP event '{}': {err}", event.event);

- return false;

- }

- };

- match event {

- Event::Stopped(events::StoppedBody {

- thread_id,

- description,

- text,

- reason,

- all_threads_stopped,

- ..

- }) => {

- let debugger = match self.debug_adapters.get_client_mut(id) {

- Some(debugger) => debugger,

- None => return false,

- };

-

- let all_threads_stopped = all_threads_stopped.unwrap_or_default();

-

- if all_threads_stopped {

- if let Ok(response) =

- debugger.request::<dap::requests::Threads>(()).await

- {

- for thread in response.threads {

- fetch_stack_trace(debugger, thread.id).await;

- }

- select_thread_id(self, thread_id.unwrap_or_default(), false).await;

- } else if let Some(thread_id) = thread_id {

- debugger.thread_states.insert(thread_id, reason.clone()); // TODO: dap uses "type" || "reason" here

-

- fetch_stack_trace(debugger, thread_id).await;

- // whichever thread stops is made "current" (if no previously selected thread).

- select_thread_id(self, thread_id, false).await;

- let scope = match thread_id {

- Some(id) => format!("Thread {}", id),

- None => "Target".to_owned(),

- };

- let mut status = format!("{} stopped because of {}", scope, reason);

- if let Some(desc) = description {

- write!(status, " {}", desc).unwrap();

- }

- if let Some(text) = text {

- write!(status, " {}", text).unwrap();

- }

- if all_threads_stopped {

- status.push_str(" (all threads stopped)");

- }

- self.set_status(status);

- self.debug_adapters.set_active_client(id);

- Event::Continued(events::ContinuedBody { thread_id, .. }) => {

- let debugger = match self.debug_adapters.get_client_mut(id) {

- Some(debugger) => debugger,

- None => return false,

- };

-

- debugger

- .thread_states

- .insert(thread_id, "running".to_owned());

- if debugger.thread_id == Some(thread_id) {

- debugger.resume_application();

- }

- Event::Thread(thread) => {

- self.set_status(format!("Thread {}: {}", thread.thread_id, thread.reason));

- let debugger = match self.debug_adapters.get_client_mut(id) {

- Some(debugger) => debugger,

- None => return false,

- };

-

- debugger.thread_id = Some(thread.thread_id);

- // set the stack frame for the thread

- Event::Breakpoint(events::BreakpointBody { reason, breakpoint }) => {

- match &reason[..] {

- "new" => {

- if let Some(source) = breakpoint.source {

- self.breakpoints

- .entry(source.path.unwrap()) // TODO: no unwraps

- .or_default()

- .push(Breakpoint {

- id: breakpoint.id,

- verified: breakpoint.verified,

- message: breakpoint.message,

- line: breakpoint.line.unwrap().saturating_sub(1), // TODO: no unwrap

- column: breakpoint.column,

- ..Default::default()

- });

- }

- "changed" => {

- for breakpoints in self.breakpoints.values_mut() {

- if let Some(i) =

- breakpoints.iter().position(|b| b.id == breakpoint.id)

- {

- breakpoints[i].verified = breakpoint.verified;

- breakpoints[i].message = breakpoint

- .message

- .clone()

- .or_else(|| breakpoints[i].message.take());

- breakpoints[i].line =

- breakpoint.line.map_or(breakpoints[i].line, |line| {

- line.saturating_sub(1)

- });

- breakpoints[i].column =

- breakpoint.column.or(breakpoints[i].column);

- }

- "removed" => {

- for breakpoints in self.breakpoints.values_mut() {

- if let Some(i) =

- breakpoints.iter().position(|b| b.id == breakpoint.id)

- {

- breakpoints.remove(i);

- }

- reason => {

- warn!("Unknown breakpoint event: {}", reason);

- }

- Event::Output(events::OutputBody {

- category, output, ..

- }) => {

- let prefix = match category {

- Some(category) => {

- if &category == "telemetry" {

- return false;

- }

- format!("Debug ({}):", category)

- None => "Debug:".to_owned(),

- };

- log::info!("{}", output);

- self.set_status(format!("{} {}", prefix, output));

- Event::Initialized(_) => {

- self.set_status("Debugger initialized...");

- let debugger = match self.debug_adapters.get_client_mut(id) {

- Some(debugger) => debugger,

- None => return false,

- };

-

- // send existing breakpoints

- for (path, breakpoints) in &mut self.breakpoints {

- // TODO: call futures in parallel, await all

- let _ = breakpoints_changed(debugger, path.clone(), breakpoints);

- }

- // TODO: fetch breakpoints (in case we're attaching)

- if debugger.configuration_done().await.is_ok() {

- self.set_status("Debugged application started");

- }; // TODO: do we need to handle error?

- Event::Terminated(terminated) => {

- let debugger = match self.debug_adapters.get_client_mut(id) {

- Some(debugger) => debugger,

- None => return false,

- };

-

- let restart_arg = if let Some(terminated) = terminated {

- terminated.restart

- } else {

- None

- };

-

- let restart_bool = restart_arg

- .as_ref()

- .and_then(|v| v.as_bool())

- .unwrap_or(false);

- let disconnect_args = Some(DisconnectArguments {

- restart: Some(restart_bool),

- terminate_debuggee: None,

- suspend_debuggee: None,

- });

-

- if let Err(err) = debugger.disconnect(disconnect_args).await {

- self.set_error(format!(

- "Cannot disconnect debugger upon terminated event receival {:?}",

- err

- ));

- return false;

- }

- match restart_arg {

- Some(Value::Bool(false)) | None => {

- self.debug_adapters.remove_client(id);

- self.debug_adapters.unset_active_client();

- self.set_status(

- "Terminated debugging session and disconnected debugger.",

- );

-

- // Go through all breakpoints and set verfified to false

- // this should update the UI to show the breakpoints are no longer connected

- for breakpoints in self.breakpoints.values_mut() {

- for breakpoint in breakpoints.iter_mut() {

- breakpoint.verified = false;

- }

- }

- }

- Some(val) => {

- log::info!("Attempting to restart debug session.");

- let connection_type = match debugger.connection_type() {

- Some(connection_type) => connection_type,

- None => {

- self.set_error("No starting request found, to be used in restarting the debugging session.");

- return false;

- }

- };

-

- let relaunch_resp = if let ConnectionType::Launch = connection_type

- {

- debugger.launch(val).await

- } else {

- debugger.attach(val).await

- };

-

- if let Err(err) = relaunch_resp {

- self.set_error(format!(

- "Failed to restart debugging session: {:?}",

- err

- ));

- }

- Event::Exited(resp) => {

- let exit_code = resp.exit_code;

- if exit_code != 0 {

- self.set_error(format!(

- "Debuggee failed to exit successfully (exit code: {exit_code})."

- ));

- ev => {

- log::warn!("Unhandled event {:?}", ev);

- return false; // return early to skip render

- }

- Payload::Request(request) => {

- let reply = match Request::parse(&request.command, request.arguments) {

- Ok(Request::RunInTerminal(arguments)) => {

- let config = self.config();

- let Some(config) = config.terminal.as_ref() else {

- };

-

- let process = match std::process::Command::new(&config.command)

- .args(&config.args)

- .arg(arguments.args.join(" "))

- .spawn()

- {

- Ok(process) => process,

- Err(err) => {

- self.set_error(format!(

- "Error starting external terminal: {}",

- err

- ));

- return true;

- }

- };

-

- Ok(json!(dap::requests::RunInTerminalResponse {

- process_id: Some(process.id()),

- shell_process_id: None,

- }))

- }

- Ok(Request::StartDebugging(arguments)) => {

- let debugger = match self.debug_adapters.get_client_mut(id) {

- Some(debugger) => debugger,

- None => {

- self.set_error("No active debugger found.");

- return true;

- }

- };

- // Currently we only support starting a child debugger if the parent is using the TCP transport

- let socket = match debugger.socket {

- Some(socket) => socket,

- None => {

- self.set_error("Child debugger can only be started if the parent debugger is using TCP transport.");

- return true;

- }

- };

-

- let config = match debugger.config.clone() {

- Some(config) => config,

- None => {

- error!("No configuration found for the debugger.");

- return true;

- }

- };

-

- let result = self.debug_adapters.start_client(Some(socket), &config);

-

- let client_id = match result {

- Ok(child) => child,

- Err(err) => {

- self.set_error(format!(

- "Failed to create child debugger: {:?}",

- err

- ));

- return true;

- }

- };

-

- let client = match self.debug_adapters.get_client_mut(client_id) {

- Some(child) => child,

- None => {

- self.set_error("Failed to get child debugger.");

- return true;

- }

- };

-

- let relaunch_resp = if let ConnectionType::Launch = arguments.request {

- client.launch(arguments.configuration).await

- } else {

- client.attach(arguments.configuration).await

- };

- if let Err(err) = relaunch_resp {

- self.set_error(format!("Failed to start debugging session: {:?}", err));

-

- Ok(json!({

- "success": true,

- }))

- }

- Err(err) => Err(err),

- };

-

- if let Some(debugger) = self.debug_adapters.get_client_mut(id) {

- debugger

- .reply(request.seq, &request.command, reply)

- .await

- .ok();

- }