3b87fce · helix · git.iko.soy

git.iko.soy/helix

on master help sign in

Print errors occurred in debug commands

3b87fceDmitry Sharshakov5 years ago

helix-term/src/commands.rs+120−75

compare with master

unifiedsplit

@@ -1910,6 +1910,40 @@ mod cmd {

1910 Ok(())

1911 }

1912

1913+ fn vsplit(

1914+ cx: &mut compositor::Context,

1915+ args: &[&str],

1916+ _event: PromptEvent,

1917+ ) -> anyhow::Result<()> {

1918+ let (_, doc) = current!(cx.editor);

1919+ let id = doc.id();

1920+

1921+ if let Some(path) = args.get(0) {

1922+ cx.editor.open(path.into(), Action::VerticalSplit)?;

1923+ } else {

1924+ cx.editor.switch(id, Action::VerticalSplit);

1925+ }

1926+

1927+ Ok(())

1928+ }

1929+

1930+ fn hsplit(

1931+ cx: &mut compositor::Context,

1932+ args: &[&str],

1933+ _event: PromptEvent,

1934+ ) -> anyhow::Result<()> {

1935+ let (_, doc) = current!(cx.editor);

1936+ let id = doc.id();

1937+

1938+ if let Some(path) = args.get(0) {

1939+ cx.editor.open(path.into(), Action::HorizontalSplit)?;

1940+ } else {

1941+ cx.editor.switch(id, Action::HorizontalSplit);

1942+ }

1943+

1944+ Ok(())

1945+ }

1946+

1913 fn debug_eval(

1947 fn debug_eval(

1914 cx: &mut compositor::Context,

1948 cx: &mut compositor::Context,

1915 args: &[&str],

1949 args: &[&str],

@@ -1985,60 +2019,14 @@ mod cmd {

1985 let breakpoints = breakpoints.clone();

2019 let breakpoints = breakpoints.clone();

1986

2020

1987 let request = debugger.set_breakpoints(path, breakpoints);

2021 let request = debugger.set_breakpoints(path, breakpoints);

1988− let _ = block_on(request).unwrap();

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

2023+ cx.editor

2024+ .set_error(format!("Failed to set breakpoints: {:?}", e));

2025+ }

1989 }

2026 }

1990 }

2027 }

1991 }

2028 }

1992

2029

1993− fn debug_breakpoint_condition(

1994− cx: &mut compositor::Context,

1995− args: &[&str],

1996− _event: PromptEvent,

1997− ) -> anyhow::Result<()> {

1998− let condition = args.join(" ");

1999− let condition = if condition.is_empty() {

2000− None

2001− } else {

2002− Some(condition)

2003− };

2004−

2005− edit_breakpoint_impl(cx, condition, None);

2006− Ok(())

2007− }

2008−

2009− fn vsplit(

2010− cx: &mut compositor::Context,

2011− args: &[&str],

2012− _event: PromptEvent,

2013− ) -> anyhow::Result<()> {

2014− let (_, doc) = current!(cx.editor);

2015− let id = doc.id();

2016−

2017− if let Some(path) = args.get(0) {

2018− cx.editor.open(path.into(), Action::VerticalSplit)?;

2019− } else {

2020− cx.editor.switch(id, Action::VerticalSplit);

2021− }

2022−

2023− Ok(())

2024− }

2025−

2026− fn hsplit(

2027− cx: &mut compositor::Context,

2028− args: &[&str],

2029− _event: PromptEvent,

2030− ) -> anyhow::Result<()> {

2031− let log_message = args.join(" ");

2032− let log_message = if log_message.is_empty() {

2033− None

2034− } else {

2035− Some(log_message)

2036− };

2037−

2038− edit_breakpoint_impl(cx, None, log_message);

2039− Ok(())

2040− }

2041−

2042 fn debug_start(

2030 fn debug_start(

2043 cx: &mut compositor::Context,

2031 cx: &mut compositor::Context,

2044 args: &[&str],

2032 args: &[&str],

@@ -2061,7 +2049,7 @@ mod cmd {

2061 let mut args = args.to_owned();

2049 let mut args = args.to_owned();

2062 let address = match args.len() {

2050 let address = match args.len() {

2063 0 => None,

2051 0 => None,

2064− _ => Some(args.remove(0).parse().unwrap()),

2052+ _ => Some(args.remove(0).parse()?),

2065 };

2053 };

2066 let name = match args.len() {

2054 let name = match args.len() {

2067 0 => None,

2055 0 => None,

@@ -2072,20 +2060,35 @@ mod cmd {

2072 Ok(())

2060 Ok(())

2073 }

2061 }

2074

2062

2075− fn debug_set_logpoint(

2063+ fn debug_breakpoint_condition(

2076 cx: &mut compositor::Context,

2064 cx: &mut compositor::Context,

2077 args: &[&str],

2065 args: &[&str],

2078 _event: PromptEvent,

2066 _event: PromptEvent,

2079 ) -> anyhow::Result<()> {

2067 ) -> anyhow::Result<()> {

2080− let (_, doc) = current!(cx.editor);

2068+ let condition = args.join(" ");

2081− let id = doc.id();

2069+ let condition = if condition.is_empty() {

2070+ None

2071+ } else {

2072+ Some(condition)

2073+ };

2082

2074

2083− if let Some(path) = args.get(0) {

2075+ edit_breakpoint_impl(cx, condition, None);

2084− cx.editor.open(path.into(), Action::HorizontalSplit)?;

2076+ Ok(())

2077+ }

2078+

2079+ fn debug_set_logpoint(

2080+ cx: &mut compositor::Context,

2081+ args: &[&str],

2082+ _event: PromptEvent,

2083+ ) -> anyhow::Result<()> {

2084+ let log_message = args.join(" ");

2085+ let log_message = if log_message.is_empty() {

2086+ None

2085 } else {

2087 } else {

2086− cx.editor.switch(id, Action::HorizontalSplit);

2088+ Some(log_message)

2087− }

2089+ };

2088

2090

2091+ edit_breakpoint_impl(cx, None, log_message);

2089 Ok(())

2092 Ok(())

2090 }

2093 }

2091

2094

@@ -4522,13 +4525,24 @@ fn dap_start_impl(

4522 }

4525 }

4523 };

4526 };

4524

4527

4525− let (mut debugger, events) = match socket {

4528+ let result = match socket {

4526− Some(socket) => block_on(Client::tcp(socket, 0)).unwrap(),

4529+ Some(socket) => block_on(Client::tcp(socket, 0)),

4527− None => block_on(Client::process(config.clone(), 0)).unwrap(),

4530+ None => block_on(Client::process(config.clone(), 0)),

4531+ };

4532+

4533+ let (mut debugger, events) = match result {

4534+ Ok(r) => r,

4535+ Err(e) => {

4536+ editor.set_error(format!("Failed to start debug session: {:?}", e));

4537+ return;

4538+ }

4528 };

4539 };

4529

4540

4530 let request = debugger.initialize(config.name.clone());

4541 let request = debugger.initialize(config.name.clone());

4531− let _ = block_on(request).unwrap();

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

4543+ editor.set_error(format!("Failed to initialize debug adapter: {:?}", e));

4544+ return;

4545+ }

4532

4546

4533 let start_config = match name {

4547 let start_config = match name {

4534 Some(name) => config.templates.iter().find(|t| t.name == name),

4548 Some(name) => config.templates.iter().find(|t| t.name == name),

@@ -4563,15 +4577,18 @@ fn dap_start_impl(

4563

4577

4564 let args = to_value(args).unwrap();

4578 let args = to_value(args).unwrap();

4565

4579

4566− // TODO gracefully handle errors from debugger

4567− match &start_config.request[..] {

4580+ let result = match &start_config.request[..] {

4568− "launch" => block_on(debugger.launch(args)).unwrap(),

4581+ "launch" => block_on(debugger.launch(args)),

4569− "attach" => block_on(debugger.attach(args)).unwrap(),

4582+ "attach" => block_on(debugger.attach(args)),

4570 _ => {

4583 _ => {

4571 editor.set_error("Unsupported request".to_string());

4584 editor.set_error("Unsupported request".to_string());

4572 return;

4585 return;

4573 }

4586 }

4574 };

4587 };

4588+ if let Err(e) = result {

4589+ editor.set_error(format!("Failed {} target: {:?}", start_config.request, e));

4590+ return;

4591+ }

4575

4592

4576 // TODO: either await "initialized" or buffer commands until event is received

4593 // TODO: either await "initialized" or buffer commands until event is received

4577 editor.debugger = Some(debugger);

4594 editor.debugger = Some(debugger);

@@ -4614,7 +4631,10 @@ fn dap_toggle_breakpoint(cx: &mut Context) {

4614 let breakpoints = breakpoints.clone();

4631 let breakpoints = breakpoints.clone();

4615

4632

4616 let request = debugger.set_breakpoints(path, breakpoints);

4633 let request = debugger.set_breakpoints(path, breakpoints);

4617− let _ = block_on(request).unwrap();

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

4635+ cx.editor

4636+ .set_error(format!("Failed to set breakpoints: {:?}", e));

4637+ }

4618 }

4638 }

4619}

4639}

4620

4640

@@ -4628,7 +4648,10 @@ fn dap_run(cx: &mut Context) {

4628 return;

4648 return;

4629 }

4649 }

4630 let request = debugger.configuration_done();

4650 let request = debugger.configuration_done();

4631− let _ = block_on(request).unwrap();

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

4652+ cx.editor.set_error(format!("Failed to run: {:?}", e));

4653+ return;

4654+ }

4632 debugger.is_running = true;

4655 debugger.is_running = true;

4633 }

4656 }

4634}

4657}

@@ -4644,7 +4667,10 @@ fn dap_continue(cx: &mut Context) {

4644 }

4667 }

4645

4668

4646 let request = debugger.continue_thread(debugger.stopped_thread.unwrap());

4669 let request = debugger.continue_thread(debugger.stopped_thread.unwrap());

4647− let _ = block_on(request).unwrap();

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

4671+ cx.editor.set_error(format!("Failed to continue: {:?}", e));

4672+ return;

4673+ }

4648 debugger.is_running = true;

4674 debugger.is_running = true;

4649 debugger.stack_pointer = None;

4675 debugger.stack_pointer = None;

4650 }

4676 }

@@ -4661,7 +4687,9 @@ fn dap_pause(cx: &mut Context) {

4661

4687

4662 // FIXME: correct number here

4688 // FIXME: correct number here

4663 let request = debugger.pause(0);

4689 let request = debugger.pause(0);

4664− let _ = block_on(request).unwrap();

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

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

4692+ }

4665 }

4693 }

4666}

4694}

4667

4695

@@ -4676,7 +4704,9 @@ fn dap_in(cx: &mut Context) {

4676 }

4704 }

4677

4705

4678 let request = debugger.step_in(debugger.stopped_thread.unwrap());

4706 let request = debugger.step_in(debugger.stopped_thread.unwrap());

4679− let _ = block_on(request).unwrap();

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

4708+ cx.editor.set_error(format!("Failed to step: {:?}", e));

4709+ }

4680 }

4710 }

4681}

4711}

4682

4712

@@ -4691,7 +4721,9 @@ fn dap_out(cx: &mut Context) {

4691 }

4721 }

4692

4722

4693 let request = debugger.step_out(debugger.stopped_thread.unwrap());

4723 let request = debugger.step_out(debugger.stopped_thread.unwrap());

4694− let _ = block_on(request).unwrap();

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

4725+ cx.editor.set_error(format!("Failed to step: {:?}", e));

4726+ }

4695 }

4727 }

4696}

4728}

4697

4729

@@ -4706,7 +4738,9 @@ fn dap_next(cx: &mut Context) {

4706 }

4738 }

4707

4739

4708 let request = debugger.next(debugger.stopped_thread.unwrap());

4740 let request = debugger.next(debugger.stopped_thread.unwrap());

4709− let _ = block_on(request).unwrap();

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

4742+ cx.editor.set_error(format!("Failed to step: {:?}", e));

4743+ }

4710 }

4744 }

4711}

4745}

4712

4746

@@ -4726,7 +4760,14 @@ fn dap_variables(cx: &mut Context) {

4726 }

4760 }

4727

4761

4728 let frame_id = debugger.stack_pointer.clone().unwrap().id;

4762 let frame_id = debugger.stack_pointer.clone().unwrap().id;

4729− let scopes = block_on(debugger.scopes(frame_id)).unwrap();

4763+ let scopes = match block_on(debugger.scopes(frame_id)) {

4764+ Ok(s) => s,

4765+ Err(e) => {

4766+ cx.editor

4767+ .set_error(format!("Failed to get scopes: {:?}", e));

4768+ return;

4769+ }

4770+ };

4730 let mut s = String::new();

4771 let mut s = String::new();

4731

4772

4732 for scope in scopes.iter() {

4773 for scope in scopes.iter() {

@@ -4752,7 +4793,11 @@ fn dap_terminate(cx: &mut Context) {

4752

4793

4753 if let Some(debugger) = &mut cx.editor.debugger {

4794 if let Some(debugger) = &mut cx.editor.debugger {

4754 let request = debugger.disconnect();

4795 let request = debugger.disconnect();

4755− let _ = block_on(request).unwrap();

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

4797+ cx.editor

4798+ .set_error(format!("Failed to disconnect: {:?}", e));

4799+ return;

4800+ }

4756 cx.editor.debugger = None;

4801 cx.editor.debugger = None;

4757 }

4802 }

4758}

4803}