+use serde_json::json;

+ 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 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

+

+ // 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);

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

+ debugger

+ .thread_states

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

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

+ debugger.resume_application();

+ }

+ Event::Thread(_) => {

+ // TODO: update thread_states, make threads request

+ 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(_) => {

+ // 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 restart_args = if let Some(terminated) = terminated {

+ terminated.restart

+ } else {

+ None

+ };

+

+ let disconnect_args = Some(DisconnectArguments {

+ restart: Some(restart_args.is_some()),

+ 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_args {

+ Some(restart_args) => {

+ 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(restart_args).await

+ } else {

+ debugger.attach(restart_args).await

+ };

+

+ if let Err(err) = relaunch_resp {

+ self.set_error(format!(

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

+ err

+ ));

+ }

+ None => {

+ self.debugger = None;

+ self.set_status(

+ "Terminated debugging session and disconnected debugger.",

+ );

+ }

+ 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,

+ }))

+ }

+ Err(err) => Err(err),

+ };

+ if let Some(debugger) = self.debugger.as_mut() {

+ debugger

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

+ .await

+ .ok();

+ }