@@ -6510,6 +6510,7 @@ dependencies = [
"theme2",
"ui2",
"util",
+ "workspace2",
]
[[package]]
@@ -7019,6 +7020,29 @@ dependencies = [
"workspace",
]
+[[package]]
+name = "project_symbols2"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "editor2",
+ "futures 0.3.28",
+ "fuzzy2",
+ "gpui2",
+ "language2",
+ "lsp2",
+ "ordered-float 2.10.0",
+ "picker2",
+ "postage",
+ "project2",
+ "settings2",
+ "smol",
+ "text2",
+ "theme2",
+ "util",
+ "workspace2",
+]
+
[[package]]
name = "prometheus"
version = "0.13.3"
@@ -12081,6 +12105,7 @@ dependencies = [
"postage",
"project2",
"project_panel2",
+ "project_symbols2",
"quick_action_bar2",
"rand 0.8.5",
"recent_projects2",
@@ -1,11 +1,12 @@
use editor::Editor;
use gpui::{
div, prelude::*, rems, uniform_list, AnyElement, AppContext, DismissEvent, Div, EventEmitter,
- FocusHandle, FocusableView, MouseButton, MouseDownEvent, Render, Task, UniformListScrollHandle,
- View, ViewContext, WindowContext,
+ FocusHandle, FocusableView, Length, MouseButton, MouseDownEvent, Render, Task,
+ UniformListScrollHandle, View, ViewContext, WindowContext,
};
use std::{cmp, sync::Arc};
use ui::{prelude::*, v_stack, Color, Divider, Label};
+use workspace::ModalView;
pub struct Picker<D: PickerDelegate> {
pub delegate: D,
@@ -13,6 +14,7 @@ pub struct Picker<D: PickerDelegate> {
editor: View<Editor>,
pending_update_matches: Option<Task<()>>,
confirm_on_update: Option<bool>,
+ width: Option<Length>,
}
pub trait PickerDelegate: Sized + 'static {
@@ -55,11 +57,17 @@ impl<D: PickerDelegate> Picker<D> {
scroll_handle: UniformListScrollHandle::new(),
pending_update_matches: None,
confirm_on_update: None,
+ width: None,
};
this.update_matches("".to_string(), cx);
this
}
+ pub fn width(mut self, width: impl Into<gpui::Length>) -> Self {
+ self.width = Some(width.into());
+ self
+ }
+
pub fn focus(&self, cx: &mut WindowContext) {
self.editor.update(cx, |editor, cx| editor.focus(cx));
}
@@ -197,6 +205,7 @@ impl<D: PickerDelegate> Picker<D> {
}
impl<D: PickerDelegate> EventEmitter<DismissEvent> for Picker<D> {}
+impl<D: PickerDelegate> ModalView for Picker<D> {}
impl<D: PickerDelegate> Render for Picker<D> {
type Element = Div;
@@ -221,6 +230,9 @@ impl<D: PickerDelegate> Render for Picker<D> {
div()
.key_context("picker")
.size_full()
+ .when_some(self.width, |el, width| {
+ el.w(width)
+ })
.overflow_hidden()
.elevation_3(cx)
.on_action(cx.listener(Self::select_next))
@@ -0,0 +1,411 @@
+use editor::{scroll::autoscroll::Autoscroll, styled_runs_for_code_label, Bias, Editor};
+use fuzzy::{StringMatch, StringMatchCandidate};
+use gpui::{
+ actions, rems, AppContext, DismissEvent, FontWeight, Model, ParentElement, StyledText, Task,
+ View, ViewContext, WeakView,
+};
+use ordered_float::OrderedFloat;
+use picker::{Picker, PickerDelegate};
+use project::{Project, Symbol};
+use std::{borrow::Cow, cmp::Reverse, sync::Arc};
+use theme::ActiveTheme;
+use util::ResultExt;
+use workspace::{
+ ui::{v_stack, Color, Label, LabelCommon, LabelLike, ListItem, Selectable},
+ Workspace,
+};
+
+actions!(project_symbols, [Toggle]);
+
+pub fn init(cx: &mut AppContext) {
+ cx.observe_new_views(
+ |workspace: &mut Workspace, _: &mut ViewContext<Workspace>| {
+ workspace.register_action(|workspace, _: &Toggle, cx| {
+ let project = workspace.project().clone();
+ let handle = cx.view().downgrade();
+ workspace.toggle_modal(cx, move |cx| {
+ let delegate = ProjectSymbolsDelegate::new(handle, project);
+ Picker::new(delegate, cx).width(rems(34.))
+ })
+ });
+ },
+ )
+ .detach();
+}
+
+pub type ProjectSymbols = View<Picker<ProjectSymbolsDelegate>>;
+
+pub struct ProjectSymbolsDelegate {
+ workspace: WeakView<Workspace>,
+ project: Model<Project>,
+ selected_match_index: usize,
+ symbols: Vec<Symbol>,
+ visible_match_candidates: Vec<StringMatchCandidate>,
+ external_match_candidates: Vec<StringMatchCandidate>,
+ show_worktree_root_name: bool,
+ matches: Vec<StringMatch>,
+}
+
+impl ProjectSymbolsDelegate {
+ fn new(workspace: WeakView<Workspace>, project: Model<Project>) -> Self {
+ Self {
+ workspace,
+ project,
+ selected_match_index: 0,
+ symbols: Default::default(),
+ visible_match_candidates: Default::default(),
+ external_match_candidates: Default::default(),
+ matches: Default::default(),
+ show_worktree_root_name: false,
+ }
+ }
+
+ fn filter(&mut self, query: &str, cx: &mut ViewContext<Picker<Self>>) {
+ const MAX_MATCHES: usize = 100;
+ let mut visible_matches = cx.background_executor().block(fuzzy::match_strings(
+ &self.visible_match_candidates,
+ query,
+ false,
+ MAX_MATCHES,
+ &Default::default(),
+ cx.background_executor().clone(),
+ ));
+ let mut external_matches = cx.background_executor().block(fuzzy::match_strings(
+ &self.external_match_candidates,
+ query,
+ false,
+ MAX_MATCHES - visible_matches.len().min(MAX_MATCHES),
+ &Default::default(),
+ cx.background_executor().clone(),
+ ));
+ let sort_key_for_match = |mat: &StringMatch| {
+ let symbol = &self.symbols[mat.candidate_id];
+ (
+ Reverse(OrderedFloat(mat.score)),
+ &symbol.label.text[symbol.label.filter_range.clone()],
+ )
+ };
+
+ visible_matches.sort_unstable_by_key(sort_key_for_match);
+ external_matches.sort_unstable_by_key(sort_key_for_match);
+ let mut matches = visible_matches;
+ matches.append(&mut external_matches);
+
+ for mat in &mut matches {
+ let symbol = &self.symbols[mat.candidate_id];
+ let filter_start = symbol.label.filter_range.start;
+ for position in &mut mat.positions {
+ *position += filter_start;
+ }
+ }
+
+ self.matches = matches;
+ self.set_selected_index(0, cx);
+ }
+}
+
+impl PickerDelegate for ProjectSymbolsDelegate {
+ type ListItem = ListItem;
+ fn placeholder_text(&self) -> Arc<str> {
+ "Search project symbols...".into()
+ }
+
+ fn confirm(&mut self, secondary: bool, cx: &mut ViewContext<Picker<Self>>) {
+ if let Some(symbol) = self
+ .matches
+ .get(self.selected_match_index)
+ .map(|mat| self.symbols[mat.candidate_id].clone())
+ {
+ let buffer = self.project.update(cx, |project, cx| {
+ project.open_buffer_for_symbol(&symbol, cx)
+ });
+ let symbol = symbol.clone();
+ let workspace = self.workspace.clone();
+ cx.spawn(|_, mut cx| async move {
+ let buffer = buffer.await?;
+ workspace.update(&mut cx, |workspace, cx| {
+ let position = buffer
+ .read(cx)
+ .clip_point_utf16(symbol.range.start, Bias::Left);
+
+ let editor = if secondary {
+ workspace.split_project_item::<Editor>(buffer, cx)
+ } else {
+ workspace.open_project_item::<Editor>(buffer, cx)
+ };
+
+ editor.update(cx, |editor, cx| {
+ editor.change_selections(Some(Autoscroll::center()), cx, |s| {
+ s.select_ranges([position..position])
+ });
+ });
+ })?;
+ Ok::<_, anyhow::Error>(())
+ })
+ .detach_and_log_err(cx);
+ cx.emit(DismissEvent);
+ }
+ }
+
+ fn dismissed(&mut self, _cx: &mut ViewContext<Picker<Self>>) {}
+
+ fn match_count(&self) -> usize {
+ self.matches.len()
+ }
+
+ fn selected_index(&self) -> usize {
+ self.selected_match_index
+ }
+
+ fn set_selected_index(&mut self, ix: usize, _cx: &mut ViewContext<Picker<Self>>) {
+ self.selected_match_index = ix;
+ }
+
+ fn update_matches(&mut self, query: String, cx: &mut ViewContext<Picker<Self>>) -> Task<()> {
+ self.filter(&query, cx);
+ self.show_worktree_root_name = self.project.read(cx).visible_worktrees(cx).count() > 1;
+ let symbols = self
+ .project
+ .update(cx, |project, cx| project.symbols(&query, cx));
+ cx.spawn(|this, mut cx| async move {
+ let symbols = symbols.await.log_err();
+ if let Some(symbols) = symbols {
+ this.update(&mut cx, |this, cx| {
+ let delegate = &mut this.delegate;
+ let project = delegate.project.read(cx);
+ let (visible_match_candidates, external_match_candidates) = symbols
+ .iter()
+ .enumerate()
+ .map(|(id, symbol)| {
+ StringMatchCandidate::new(
+ id,
+ symbol.label.text[symbol.label.filter_range.clone()].to_string(),
+ )
+ })
+ .partition(|candidate| {
+ project
+ .entry_for_path(&symbols[candidate.id].path, cx)
+ .map_or(false, |e| !e.is_ignored)
+ });
+
+ delegate.visible_match_candidates = visible_match_candidates;
+ delegate.external_match_candidates = external_match_candidates;
+ delegate.symbols = symbols;
+ delegate.filter(&query, cx);
+ })
+ .log_err();
+ }
+ })
+ }
+
+ fn render_match(
+ &self,
+ ix: usize,
+ selected: bool,
+ cx: &mut ViewContext<Picker<Self>>,
+ ) -> Option<Self::ListItem> {
+ let string_match = &self.matches[ix];
+ let symbol = &self.symbols[string_match.candidate_id];
+ let syntax_runs = styled_runs_for_code_label(&symbol.label, cx.theme().syntax());
+
+ let mut path = symbol.path.path.to_string_lossy();
+ if self.show_worktree_root_name {
+ let project = self.project.read(cx);
+ if let Some(worktree) = project.worktree_for_id(symbol.path.worktree_id, cx) {
+ path = Cow::Owned(format!(
+ "{}{}{}",
+ worktree.read(cx).root_name(),
+ std::path::MAIN_SEPARATOR,
+ path.as_ref()
+ ));
+ }
+ }
+ let label = symbol.label.text.clone();
+ let path = path.to_string().clone();
+
+ let highlights = gpui::combine_highlights(
+ string_match
+ .positions
+ .iter()
+ .map(|pos| (*pos..pos + 1, FontWeight::BOLD.into())),
+ syntax_runs.map(|(range, mut highlight)| {
+ // Ignore font weight for syntax highlighting, as we'll use it
+ // for fuzzy matches.
+ highlight.font_weight = None;
+ (range, highlight)
+ }),
+ );
+
+ Some(
+ ListItem::new(ix).inset(true).selected(selected).child(
+ // todo!() combine_syntax_and_fuzzy_match_highlights()
+ v_stack()
+ .child(
+ LabelLike::new().child(
+ StyledText::new(label)
+ .with_highlights(&cx.text_style().clone(), highlights),
+ ),
+ )
+ .child(Label::new(path).color(Color::Muted)),
+ ),
+ )
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use futures::StreamExt;
+ use gpui::{serde_json::json, TestAppContext, VisualContext};
+ use language::{FakeLspAdapter, Language, LanguageConfig};
+ use project::FakeFs;
+ use settings::SettingsStore;
+ use std::{path::Path, sync::Arc};
+
+ #[gpui::test]
+ async fn test_project_symbols(cx: &mut TestAppContext) {
+ init_test(cx);
+
+ let mut language = Language::new(
+ LanguageConfig {
+ name: "Rust".into(),
+ path_suffixes: vec!["rs".to_string()],
+ ..Default::default()
+ },
+ None,
+ );
+ let mut fake_servers = language
+ .set_fake_lsp_adapter(Arc::<FakeLspAdapter>::default())
+ .await;
+
+ let fs = FakeFs::new(cx.executor());
+ fs.insert_tree("/dir", json!({ "test.rs": "" })).await;
+
+ let project = Project::test(fs.clone(), ["/dir".as_ref()], cx).await;
+ project.update(cx, |project, _| project.languages().add(Arc::new(language)));
+
+ let _buffer = project
+ .update(cx, |project, cx| {
+ project.open_local_buffer("/dir/test.rs", cx)
+ })
+ .await
+ .unwrap();
+
+ // Set up fake language server to return fuzzy matches against
+ // a fixed set of symbol names.
+ let fake_symbols = [
+ symbol("one", "/external"),
+ symbol("ton", "/dir/test.rs"),
+ symbol("uno", "/dir/test.rs"),
+ ];
+ let fake_server = fake_servers.next().await.unwrap();
+ fake_server.handle_request::<lsp::WorkspaceSymbolRequest, _, _>(
+ move |params: lsp::WorkspaceSymbolParams, cx| {
+ let executor = cx.background_executor().clone();
+ let fake_symbols = fake_symbols.clone();
+ async move {
+ let candidates = fake_symbols
+ .iter()
+ .enumerate()
+ .map(|(id, symbol)| StringMatchCandidate::new(id, symbol.name.clone()))
+ .collect::<Vec<_>>();
+ let matches = if params.query.is_empty() {
+ Vec::new()
+ } else {
+ fuzzy::match_strings(
+ &candidates,
+ ¶ms.query,
+ true,
+ 100,
+ &Default::default(),
+ executor.clone(),
+ )
+ .await
+ };
+
+ Ok(Some(lsp::WorkspaceSymbolResponse::Flat(
+ matches
+ .into_iter()
+ .map(|mat| fake_symbols[mat.candidate_id].clone())
+ .collect(),
+ )))
+ }
+ },
+ );
+
+ let (workspace, cx) = cx.add_window_view(|cx| Workspace::test_new(project.clone(), cx));
+
+ // Create the project symbols view.
+ let symbols = cx.build_view(|cx| {
+ Picker::new(
+ ProjectSymbolsDelegate::new(workspace.downgrade(), project.clone()),
+ cx,
+ )
+ });
+
+ // Spawn multiples updates before the first update completes,
+ // such that in the end, there are no matches. Testing for regression:
+ // https://github.com/zed-industries/zed/issues/861
+ symbols.update(cx, |p, cx| {
+ p.update_matches("o".to_string(), cx);
+ p.update_matches("on".to_string(), cx);
+ p.update_matches("onex".to_string(), cx);
+ });
+
+ cx.run_until_parked();
+ symbols.update(cx, |symbols, _| {
+ assert_eq!(symbols.delegate.matches.len(), 0);
+ });
+
+ // Spawn more updates such that in the end, there are matches.
+ symbols.update(cx, |p, cx| {
+ p.update_matches("one".to_string(), cx);
+ p.update_matches("on".to_string(), cx);
+ });
+
+ cx.run_until_parked();
+ symbols.update(cx, |symbols, _| {
+ let delegate = &symbols.delegate;
+ assert_eq!(delegate.matches.len(), 2);
+ assert_eq!(delegate.matches[0].string, "ton");
+ assert_eq!(delegate.matches[1].string, "one");
+ });
+
+ // Spawn more updates such that in the end, there are again no matches.
+ symbols.update(cx, |p, cx| {
+ p.update_matches("o".to_string(), cx);
+ p.update_matches("".to_string(), cx);
+ });
+
+ cx.run_until_parked();
+ symbols.update(cx, |symbols, _| {
+ assert_eq!(symbols.delegate.matches.len(), 0);
+ });
+ }
+
+ fn init_test(cx: &mut TestAppContext) {
+ cx.update(|cx| {
+ let store = SettingsStore::test(cx);
+ cx.set_global(store);
+ theme::init(theme::LoadThemes::JustBase, cx);
+ language::init(cx);
+ Project::init_settings(cx);
+ workspace::init_settings(cx);
+ });
+ }
+
+ fn symbol(name: &str, path: impl AsRef<Path>) -> lsp::SymbolInformation {
+ #[allow(deprecated)]
+ lsp::SymbolInformation {
+ name: name.to_string(),
+ kind: lsp::SymbolKind::FUNCTION,
+ tags: None,
+ deprecated: None,
+ container_name: None,
+ location: lsp::Location::new(
+ lsp::Url::from_file_path(path.as_ref()).unwrap(),
+ lsp::Range::new(lsp::Position::new(0, 0), lsp::Position::new(0, 0)),
+ ),
+ }
+ }
+}