42f9718 · helix · git.iko.soy

git.iko.soy/helix

on master help sign in

dap: Extract thread_picker, make pause explicitly select a thread

42f9718Blaž Hrastnik5 years ago

helix-dap/src/client.rs+1

compare with master

unifiedsplit

@@ -80,6 +80,7 @@ impl Client {

80 //

81 breakpoints: HashMap::new(),

82 stack_frames: HashMap::new(),

83+ thread_states: HashMap::new(),

83 thread_id: None,

84 thread_id: None,

84 active_frame: None,

85 active_frame: None,

85 is_running: false,

86 is_running: false,

helix-term/src/application.rs+4−4

@@ -258,7 +258,7 @@ impl Application {

258 pub async fn handle_debugger_message(&mut self, payload: helix_dap::Payload) {

259 use crate::commands::dap::{resume_application, select_thread_id};

260 use helix_dap::{events, Event};

261− let mut debugger = match self.editor.debugger.as_mut() {

261+ let debugger = match self.editor.debugger.as_mut() {

262 Some(debugger) => debugger,

263 None => return,

264 };

@@ -274,12 +274,12 @@ impl Application {

274 ..

275 }) => {

276 if let Some(thread_id) = thread_id {

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

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

278+

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

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

279 select_thread_id(&mut self.editor, thread_id, false).await;

280 select_thread_id(&mut self.editor, thread_id, false).await;

280 }

281 }

281

282

282−

283 let scope = match thread_id {

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

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

@@ -305,7 +305,7 @@ impl Application {

305 }

306 }

307 Event::Thread(_) => {

308− // TODO: update thread_states, make threads request

308+ // TODO: update thread_states, make threads request

309 }

310 Event::Output(events::Output {

311 category, output, ..

helix-term/src/commands/dap.rs+41−41

@@ -1,7 +1,7 @@

1use super::{align_view, Align, Context, Editor};

2use crate::ui::Picker;

3use helix_core::Selection;

4−use helix_dap::Client;

4+use helix_dap::{self as dap, Client};

5use helix_lsp::block_on;

7use serde_json::{to_value, Value};

@@ -20,7 +20,9 @@ pub fn dap_pos_to_pos(doc: &helix_core::Rope, line: usize, column: usize) -> Opt

21pub fn resume_application(debugger: &mut Client) {

22 if let Some(thread_id) = debugger.thread_id {

23+ debugger

24+ .thread_states

23− debugger.thread_states.insert(thread_id, "running".to_string());

25+ .insert(thread_id, "running".to_string());

24 debugger.stack_frames.remove(&thread_id);

26 debugger.stack_frames.remove(&thread_id);

25 }

27 }

26 debugger.active_frame = None;

28 debugger.active_frame = None;

@@ -80,7 +82,32 @@ pub fn jump_to_stack_frame(editor: &mut Editor, frame: &helix_dap::StackFrame) {

80 align_view(doc, view, Align::Center);

82 align_view(doc, view, Align::Center);

81}

83}

85+fn thread_picker(cx: &mut Context, callback_fn: impl Fn(&mut Editor, &dap::Thread) + 'static) {

86+ let debugger = match &mut cx.editor.debugger {

87+ Some(debugger) => debugger,

88+ None => return,

89+ };

90+

91+ let threads = match block_on(debugger.threads()) {

92+ Ok(threads) => threads,

93+ Err(e) => {

94+ cx.editor

95+ .set_error(format!("Failed to retrieve threads: {:?}", e));

96+ return;

97+ }

98+ };

99+

100+ let picker = Picker::new(

101+ true,

102+ threads,

103+ |thread| thread.name.clone().into(),

104+ move |editor, thread, _action| callback_fn(editor, thread),

105+ );

106+ cx.push_layer(Box::new(picker))

107+}

108+

83−// DAP

109+// -- DAP

110+

84pub fn dap_start_impl(

111pub fn dap_start_impl(

85 editor: &mut Editor,

112 editor: &mut Editor,

86 name: Option<&str>,

113 name: Option<&str>,

@@ -312,23 +339,17 @@ pub fn dap_continue(cx: &mut Context) {

312}

339}

313

340

314pub fn dap_pause(cx: &mut Context) {

341pub fn dap_pause(cx: &mut Context) {

342+ thread_picker(cx, |editor, thread| {

315− let debugger = match &mut cx.editor.debugger {

343+ let debugger = match &mut editor.debugger {

316 Some(debugger) => debugger,

344 Some(debugger) => debugger,

317 None => return,

345 None => return,

318 };

346 };

319−

347+ let request = debugger.pause(thread.id);

320− // TODO: this should instead open a picker to pause a selected thread

348+ // NOTE: we don't need to set active thread id here because DAP will emit a "stopped" event

321−

322− if !debugger.is_running {

323− cx.editor.set_status("Debuggee is not running".to_owned());

324− return;

325− }

326−

327− // FIXME: correct number here

328− let request = debugger.pause(0);

329− if let Err(e) = block_on(request) {

349+ if let Err(e) = block_on(request) {

330− cx.editor.set_error(format!("Failed to pause: {:?}", e));

350+ editor.set_error(format!("Failed to pause: {:?}", e));

351+ }

331− }

352+ })

332}

353}

333

354

334pub fn dap_step_in(cx: &mut Context) {

355pub fn dap_step_in(cx: &mut Context) {

@@ -456,28 +477,7 @@ pub fn dap_terminate(cx: &mut Context) {

456}

477}

457

478

458pub fn dap_switch_thread(cx: &mut Context) {

479pub fn dap_switch_thread(cx: &mut Context) {

459− let debugger = match &mut cx.editor.debugger {

460− Some(debugger) => debugger,

461− None => return,

462− };

463−

464− let request = debugger.threads();

465− let threads = match block_on(request) {

466− Ok(threads) => threads,

467− Err(e) => {

468− cx.editor

469− .set_error(format!("Failed to retrieve threads: {:?}", e));

470− return;

471− }

472− };

473−

474− let picker = Picker::new(

475− true,

476− threads,

477− |thread| thread.name.clone().into(),

478− |editor, thread, _action| {

480+ thread_picker(cx, |editor, thread| {

479− block_on(select_thread_id(editor, thread.id, true));

481+ block_on(select_thread_id(editor, thread.id, true));

480− },

482+ })

481− );

482− cx.push_layer(Box::new(picker))

483}