aaa1450 · helix · git.iko.soy

git.iko.soy/helix

fix write-quit with auto format

write-quit will now save all files successfully even when there is auto formatting

commitaaa145067833c41686b7cdde9fb999018735bc04 authorSkyler Hawthorne <skyler@dead10ck.com> dateMon 11 Jul 2022, 23:38 (4 years ago) parentc941858

6 files changed+85−36

compare with master

unifiedsplit

helix-term/src/application.rs+5−1 helix-term/src/commands.rs+11−8 helix-term/src/commands/dap.rs+14−11 helix-term/src/commands/typed.rs+10−7 helix-term/src/job.rs+41−6 helix-term/src/ui/editor.rs+4−3

helix-term/src/application.rs+5−1

@@ -971,7 +971,11 @@ impl Application {

971971 // want to try to run as much cleanup as we can, regardless of

972972 // errors along the way

973973

974− let mut result = match self.jobs.finish().await {

974+ let mut result = match self

975+ .jobs

976+ .finish(Some(&mut self.editor), Some(&mut self.compositor))

977+ .await

978+ {

975979 Ok(_) => Ok(()),

976980 Err(err) => {

977981 log::error!("Error executing job: {}", err);

helix-term/src/commands.rs+11−8

@@ -47,6 +47,7 @@ use movement::Movement;

4747use crate::{

4848 args,

4949 compositor::{self, Component, Compositor},

50+ job::Callback,

5051 keymap::ReverseKeymap,

5152 ui::{self, overlay::overlayed, FilePicker, Picker, Popup, Prompt, PromptEvent},

5253};

@@ -107,10 +108,11 @@ impl<'a> Context<'a> {

107108 let callback = Box::pin(async move {

108109 let json = call.await?;

109110 let response = serde_json::from_value(json)?;

110− let call: job::Callback =

111− Box::new(move |editor: &mut Editor, compositor: &mut Compositor| {

111+ let call: job::Callback = Callback::EditorCompositor(Box::new(

112+ move |editor: &mut Editor, compositor: &mut Compositor| {

112113 callback(editor, compositor, response)

113− });

114+ },

115+ ));

114116 Ok(call)

115117 });

116118 self.jobs.callback(callback);

@@ -1925,8 +1927,8 @@ fn global_search(cx: &mut Context) {

19251927 let show_picker = async move {

19261928 let all_matches: Vec<FileResult> =

19271929 UnboundedReceiverStream::new(all_matches_rx).collect().await;

1928− let call: job::Callback =

1929− Box::new(move |editor: &mut Editor, compositor: &mut Compositor| {

1930+ let call: job::Callback = Callback::EditorCompositor(Box::new(

1931+ move |editor: &mut Editor, compositor: &mut Compositor| {

19301932 if all_matches.is_empty() {

19311933 editor.set_status("No matches found");

19321934 return;

@@ -1962,7 +1964,8 @@ fn global_search(cx: &mut Context) {

19621964 },

19631965 );

19641966 compositor.push(Box::new(overlayed(picker)));

1965− });

1967+ },

1968+ ));

19661969 Ok(call)

19671970 };

19681971 cx.jobs.callback(show_picker);

@@ -2516,7 +2519,7 @@ async fn make_format_callback(

25162519 write: Option<(Option<PathBuf>, bool)>,

25172520) -> anyhow::Result<job::Callback> {

25182521 let format = format.await?;

2519− let call: job::Callback = Box::new(move |editor, _compositor| {

2522+ let call: job::Callback = Callback::EditorCompositor(Box::new(move |editor, _compositor| {

25202523 if !editor.documents.contains_key(&doc_id) {

25212524 return;

25222525 }

@@ -2546,7 +2549,7 @@ async fn make_format_callback(

25462549 } else {

25472550 log::info!("discarded formatting changes because the document changed");

25482551 }

2549− });

2552+ }));

25502553

25512554 Ok(call)

25522555}

helix-term/src/commands/dap.rs+14−11

@@ -118,11 +118,14 @@ fn dap_callback<T, F>(

118118 let callback = Box::pin(async move {

119119 let json = call.await?;

120120 let response = serde_json::from_value(json)?;

121− let call: Callback = Box::new(move |editor: &mut Editor, compositor: &mut Compositor| {

122− callback(editor, compositor, response)

123− });

121+ let call: Callback = Callback::EditorCompositor(Box::new(

122+ move |editor: &mut Editor, compositor: &mut Compositor| {

123+ callback(editor, compositor, response)

124+ },

125+ ));

124126 Ok(call)

125127 });

128+

126129 jobs.callback(callback);

127130}

128131

@@ -274,10 +277,10 @@ pub fn dap_launch(cx: &mut Context) {

274277 let completions = template.completion.clone();

275278 let name = template.name.clone();

276279 let callback = Box::pin(async move {

277− let call: Callback = Box::new(move |_editor, compositor| {

280+ let call: Callback = Callback::Compositor(Box::new(move |compositor| {

278281 let prompt = debug_parameter_prompt(completions, name, Vec::new());

279282 compositor.push(Box::new(prompt));

280− });

283+ }));

281284 Ok(call)

282285 });

283286 cx.jobs.callback(callback);

@@ -332,10 +335,10 @@ fn debug_parameter_prompt(

332335 let config_name = config_name.clone();

333336 let params = params.clone();

334337 let callback = Box::pin(async move {

335− let call: Callback = Box::new(move |_editor, compositor| {

338+ let call: Callback = Callback::Compositor(Box::new(move |compositor| {

336339 let prompt = debug_parameter_prompt(completions, config_name, params);

337340 compositor.push(Box::new(prompt));

338− });

341+ }));

339342 Ok(call)

340343 });

341344 cx.jobs.callback(callback);

@@ -582,7 +585,7 @@ pub fn dap_edit_condition(cx: &mut Context) {

582585 None => return,

583586 };

584587 let callback = Box::pin(async move {

585− let call: Callback = Box::new(move |editor, compositor| {

588+ let call: Callback = Callback::EditorCompositor(Box::new(move |editor, compositor| {

586589 let mut prompt = Prompt::new(

587590 "condition:".into(),

588591 None,

@@ -610,7 +613,7 @@ pub fn dap_edit_condition(cx: &mut Context) {

610613 prompt.insert_str(&condition, editor)

611614 }

612615 compositor.push(Box::new(prompt));

613− });

616+ }));

614617 Ok(call)

615618 });

616619 cx.jobs.callback(callback);

@@ -624,7 +627,7 @@ pub fn dap_edit_log(cx: &mut Context) {

624627 None => return,

625628 };

626629 let callback = Box::pin(async move {

627− let call: Callback = Box::new(move |editor, compositor| {

630+ let call: Callback = Callback::EditorCompositor(Box::new(move |editor, compositor| {

628631 let mut prompt = Prompt::new(

629632 "log-message:".into(),

630633 None,

@@ -651,7 +654,7 @@ pub fn dap_edit_log(cx: &mut Context) {

651654 prompt.insert_str(&log_message, editor);

652655 }

653656 compositor.push(Box::new(prompt));

654− });

657+ }));

655658 Ok(call)

656659 });

657660 cx.jobs.callback(callback);

helix-term/src/commands/typed.rs+10−7

@@ -519,9 +519,10 @@ fn write_quit(

519519

520520 write_impl(cx, args.first(), false)?;

521521

522+ tokio::task::block_in_place(|| helix_lsp::block_on(cx.jobs.finish(Some(cx.editor), None)))?;

523+

522524 let doc = doc_mut!(cx.editor);

523525

524− tokio::task::block_in_place(|| helix_lsp::block_on(cx.jobs.finish()))?;

525526 tokio::task::block_in_place(|| helix_lsp::block_on(doc.try_flush_saves()))

526527 .map(|result| result.map(|_| ()))

527528 .unwrap_or(Ok(()))?;

@@ -1491,12 +1492,13 @@ fn tree_sitter_subtree(

14911492 let contents = format!("```tsq\n{}\n```", selected_node.to_sexp());

14921493

14931494 let callback = async move {

1494− let call: job::Callback =

1495− Box::new(move |editor: &mut Editor, compositor: &mut Compositor| {

1495+ let call: job::Callback = Callback::EditorCompositor(Box::new(

1496+ move |editor: &mut Editor, compositor: &mut Compositor| {

14961497 let contents = ui::Markdown::new(contents, editor.syn_loader.clone());

14971498 let popup = Popup::new("hover", contents).auto_close(true);

14981499 compositor.replace_or_push("hover", popup);

1499− });

1500+ },

1501+ ));

15001502 Ok(call)

15011503 };

15021504

@@ -1604,8 +1606,8 @@ fn run_shell_command(

16041606

16051607 if !output.is_empty() {

16061608 let callback = async move {

1607− let call: job::Callback =

1608− Box::new(move |editor: &mut Editor, compositor: &mut Compositor| {

1609+ let call: job::Callback = Callback::EditorCompositor(Box::new(

1610+ move |editor: &mut Editor, compositor: &mut Compositor| {

16091611 let contents = ui::Markdown::new(

16101612 format!("```sh\n{}\n```", output),

16111613 editor.syn_loader.clone(),

@@ -1614,7 +1616,8 @@ fn run_shell_command(

16141616 helix_core::Position::new(editor.cursor().0.unwrap_or_default().row, 2),

16151617 ));

16161618 compositor.replace_or_push("shell", popup);

1617− });

1619+ },

1620+ ));

16181621 Ok(call)

16191622 };

16201623

helix-term/src/job.rs+41−6

@@ -5,7 +5,12 @@ use crate::compositor::Compositor;

55use futures_util::future::{BoxFuture, Future, FutureExt};

66use futures_util::stream::{FuturesUnordered, StreamExt};

8−pub type Callback = Box<dyn FnOnce(&mut Editor, &mut Compositor) + Send>;

8+pub enum Callback {

9+ EditorCompositor(Box<dyn FnOnce(&mut Editor, &mut Compositor) + Send>),

10+ Editor(Box<dyn FnOnce(&mut Editor) + Send>),

11+ Compositor(Box<dyn FnOnce(&mut Compositor) + Send>),

12+}

13+

914pub type JobFuture = BoxFuture<'static, anyhow::Result<Option<Callback>>>;

1015

1116pub struct Job {

@@ -68,9 +73,11 @@ impl Jobs {

6873 ) {

6974 match call {

7075 Ok(None) => {}

71− Ok(Some(call)) => {

72− call(editor, compositor);

73− }

76+ Ok(Some(call)) => match call {

77+ Callback::EditorCompositor(call) => call(editor, compositor),

78+ Callback::Editor(call) => call(editor),

79+ Callback::Compositor(call) => call(compositor),

80+ },

7481 Err(e) => {

7582 editor.set_error(format!("Async job failed: {}", e));

7683 }

@@ -93,13 +100,41 @@ impl Jobs {

93100 }

94101

95102 /// Blocks until all the jobs that need to be waited on are done.

96− pub async fn finish(&mut self) -> anyhow::Result<()> {

103+ pub async fn finish(

104+ &mut self,

105+ mut editor: Option<&mut Editor>,

106+ mut compositor: Option<&mut Compositor>,

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

97108 log::debug!("waiting on jobs...");

98109 let mut wait_futures = std::mem::take(&mut self.wait_futures);

99110 while let (Some(job), tail) = wait_futures.into_future().await {

100111 match job {

101− Ok(_) => {

112+ Ok(callback) => {

102113 wait_futures = tail;

114+

115+ if let Some(callback) = callback {

116+ // clippy doesn't realize this is an error without the derefs

117+ #[allow(clippy::needless_option_as_deref)]

118+ match callback {

119+ Callback::EditorCompositor(call)

120+ if editor.is_some() && compositor.is_some() =>

121+ {

122+ call(

123+ editor.as_deref_mut().unwrap(),

124+ compositor.as_deref_mut().unwrap(),

125+ )

126+ }

127+ Callback::Editor(call) if editor.is_some() => {

128+ call(editor.as_deref_mut().unwrap())

129+ }

130+ Callback::Compositor(call) if compositor.is_some() => {

131+ call(compositor.as_deref_mut().unwrap())

132+ }

133+

134+ // skip callbacks for which we don't have the necessary references

135+ _ => (),

136+ }

137+ }

103138 }

104139 Err(e) => {

105140 self.wait_futures = tail;

helix-term/src/ui/editor.rs+4−3

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

11use crate::{

22 commands,

33 compositor::{Component, Context, Event, EventResult},

4− job, key,

4+ job::{self, Callback},

5+ key,

56 keymap::{KeymapResult, Keymaps},

67 ui::{Completion, ProgressSpinners},

78};

@@ -944,9 +945,9 @@ impl EditorView {

944945

945946 // TODO: Use an on_mode_change hook to remove signature help

946947 cxt.jobs.callback(async {

947− let call: job::Callback = Box::new(|_editor, compositor| {

948+ let call: job::Callback = Callback::Compositor(Box::new(|compositor| {

948949 compositor.remove(SignatureHelp::ID);

949− });

950+ }));

950951 Ok(call)

951952 });

952953 }