Re-request workspace symbols on keypress in picker

helix-term/src/commands/lsp.rs

@@ -1,3 +1,4 @@
+use futures_util::FutureExt;
 use helix_lsp::{
     block_on,
     lsp::{self, DiagnosticSeverity, NumberOrString},
@@ -14,7 +15,8 @@ use helix_view::{apply_transaction, editor::Action, theme::Style};
 use crate::{
     compositor::{self, Compositor},
     ui::{
-        self, lsp::SignatureHelp, overlay::overlayed, FileLocation, FilePicker, Popup, PromptEvent,
+        self, lsp::SignatureHelp, overlay::overlayed, DynamicPicker, FileLocation, FilePicker,
+        Popup, PromptEvent,
     },
 };
 
@@ -365,10 +367,36 @@ pub fn workspace_symbol_picker(cx: &mut Context) {
     cx.callback(
         future,
         move |_editor, compositor, response: Option<Vec<lsp::SymbolInformation>>| {
-            if let Some(symbols) = response {
-                let picker = sym_picker(symbols, current_url, offset_encoding);
-                compositor.push(Box::new(overlayed(picker)))
-            }
+            let symbols = match response {
+                Some(s) => s,
+                None => return,
+            };
+            let picker = sym_picker(symbols, current_url, offset_encoding);
+            let get_symbols = |query: String, editor: &mut Editor| {
+                let doc = doc!(editor);
+                let language_server = match doc.language_server() {
+                    Some(s) => s,
+                    None => {
+                        // This should not generally happen since the picker will not
+                        // even open in the first place if there is no server.
+                        return async move { Err(anyhow::anyhow!("LSP not active")) }.boxed();
+                    }
+                };
+                let symbol_request = language_server.workspace_symbols(query);
+
+                let future = async move {
+                    let json = symbol_request.await?;
+                    let response: Option<Vec<lsp::SymbolInformation>> =
+                        serde_json::from_value(json)?;
+
+                    response.ok_or_else(|| {
+                        anyhow::anyhow!("No response for workspace symbols from language server")
+                    })
+                };
+                future.boxed()
+            };
+            let dyn_picker = DynamicPicker::new(picker, Box::new(get_symbols));
+            compositor.push(Box::new(overlayed(dyn_picker)))
         },
     )
 }

helix-term/src/ui/mod.rs

@@ -19,7 +19,7 @@ pub use completion::Completion;
 pub use editor::EditorView;
 pub use markdown::Markdown;
 pub use menu::Menu;
-pub use picker::{FileLocation, FilePicker, Picker};
+pub use picker::{DynamicPicker, FileLocation, FilePicker, Picker};
 pub use popup::Popup;
 pub use prompt::{Prompt, PromptEvent};
 pub use spinner::{ProgressSpinners, Spinner};

helix-term/src/ui/overlay.rs

@@ -69,4 +69,8 @@ impl<T: Component + 'static> Component for Overlay<T> {
         let dimensions = (self.calc_child_size)(area);
         self.content.cursor(dimensions, ctx)
     }
+
+    fn id(&self) -> Option<&'static str> {
+        self.content.id()
+    }
 }

helix-term/src/ui/picker.rs

@@ -3,6 +3,7 @@ use crate::{
     ctrl, key, shift,
     ui::{self, fuzzy_match::FuzzyQuery, EditorView},
 };
+use futures_util::future::BoxFuture;
 use tui::{
     buffer::Buffer as Surface,
     widgets::{Block, BorderType, Borders},
@@ -27,7 +28,7 @@ use helix_view::{
     Document, Editor,
 };
 
-use super::menu::Item;
+use super::{menu::Item, overlay::Overlay};
 
 pub const MIN_AREA_WIDTH_FOR_PREVIEW: u16 = 72;
 /// Biggest file size to preview in bytes
@@ -405,31 +406,38 @@ impl<T: Item> Picker<T> {
             self.matches
                 .sort_unstable_by_key(|(_, score)| Reverse(*score));
         } else {
-            let query = FuzzyQuery::new(pattern);
-            self.matches.clear();
-            self.matches.extend(
-                self.options
-                    .iter()
-                    .enumerate()
-                    .filter_map(|(index, option)| {
-                        let text = option.filter_text(&self.editor_data);
-
-                        query
-                            .fuzzy_match(&text, &self.matcher)
-                            .map(|score| (index, score))
-                    }),
-            );
-            self.matches
-                .sort_unstable_by_key(|(_, score)| Reverse(*score));
+            self.force_score();
         }
 
         log::debug!("picker score {:?}", Instant::now().duration_since(now));
 
         // reset cursor position
         self.cursor = 0;
+        let pattern = self.prompt.line();
         self.previous_pattern.clone_from(pattern);
     }
 
+    pub fn force_score(&mut self) {
+        let pattern = self.prompt.line();
+
+        let query = FuzzyQuery::new(pattern);
+        self.matches.clear();
+        self.matches.extend(
+            self.options
+                .iter()
+                .enumerate()
+                .filter_map(|(index, option)| {
+                    let text = option.filter_text(&self.editor_data);
+
+                    query
+                        .fuzzy_match(&text, &self.matcher)
+                        .map(|score| (index, score))
+                }),
+        );
+        self.matches
+            .sort_unstable_by_key(|(_, score)| Reverse(*score));
+    }
+
     /// Move the cursor by a number of lines, either down (`Forward`) or up (`Backward`)
     pub fn move_by(&mut self, amount: usize, direction: Direction) {
         let len = self.matches.len();
@@ -677,3 +685,73 @@ impl<T: Item + 'static> Component for Picker<T> {
         self.prompt.cursor(area, editor)
     }
 }
+
+/// Returns a new list of options to replace the contents of the picker
+/// when called with the current picker query,
+pub type DynQueryCallback<T> =
+    Box<dyn Fn(String, &mut Editor) -> BoxFuture<'static, anyhow::Result<Vec<T>>>>;
+
+/// A picker that updates its contents via a callback whenever the
+/// query string changes. Useful for live grep, workspace symbols, etc.
+pub struct DynamicPicker<T: ui::menu::Item + Send> {
+    file_picker: FilePicker<T>,
+    query_callback: DynQueryCallback<T>,
+}
+
+impl<T: ui::menu::Item + Send> DynamicPicker<T> {
+    pub const ID: &'static str = "dynamic-picker";
+
+    pub fn new(file_picker: FilePicker<T>, query_callback: DynQueryCallback<T>) -> Self {
+        Self {
+            file_picker,
+            query_callback,
+        }
+    }
+}
+
+impl<T: Item + Send + 'static> Component for DynamicPicker<T> {
+    fn render(&mut self, area: Rect, surface: &mut Surface, cx: &mut Context) {
+        self.file_picker.render(area, surface, cx);
+    }
+
+    fn handle_event(&mut self, event: &Event, cx: &mut Context) -> EventResult {
+        let prev_query = self.file_picker.picker.prompt.line().to_owned();
+        let event_result = self.file_picker.handle_event(event, cx);
+        let current_query = self.file_picker.picker.prompt.line();
+
+        if *current_query == prev_query || matches!(event_result, EventResult::Ignored(_)) {
+            return event_result;
+        }
+
+        let new_options = (self.query_callback)(current_query.to_owned(), cx.editor);
+
+        cx.jobs.callback(async move {
+            let new_options = new_options.await?;
+            let callback: crate::job::Callback = Box::new(move |_editor, compositor| {
+                // Wrapping of pickers in overlay is done outside the picker code,
+                // so this is fragile and will break if wrapped in some other widget.
+                let picker = match compositor.find_id::<Overlay<DynamicPicker<T>>>(Self::ID) {
+                    Some(overlay) => &mut overlay.content.file_picker.picker,
+                    None => return,
+                };
+                picker.options = new_options;
+                picker.cursor = 0;
+                picker.force_score();
+            });
+            anyhow::Ok(callback)
+        });
+        EventResult::Consumed(None)
+    }
+
+    fn cursor(&self, area: Rect, ctx: &Editor) -> (Option<Position>, CursorKind) {
+        self.file_picker.cursor(area, ctx)
+    }
+
+    fn required_size(&mut self, viewport: (u16, u16)) -> Option<(u16, u16)> {
+        self.file_picker.required_size(viewport)
+    }
+
+    fn id(&self) -> Option<&'static str> {
+        Some(Self::ID)
+    }
+}