Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
outline_panel: Add setting to hide symbols in multi-buffer views (#63404)
František Gažoe8fbacb6d7f5
diff --git a/assets/icons/file_code_off.svg b/assets/icons/file_code_off.svgnew file mode 100644index 00000000000..c97b4618531--- /dev/null+++ b/assets/icons/file_code_off.svg@@ -0,0 +1,6 @@+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">+<path d="M1.91129 3.37805L14.0887 12.6219" stroke="#DCE0E5" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round"/>+<path d="M3.94603 7.6676V12.3242C3.94603 12.6109 4.05281 12.8859 4.24288 13.0886C4.43294 13.2914 4.69073 13.4053 4.95952 13.4053H10.7097" stroke="#DCE0E5" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round"/>+<path d="M4.95952 2.59473H8.54451C9.16704 2.59473 9.76181 2.8524 10.1876 3.30656L11.4448 4.64763C11.8362 5.06507 12.054 5.61581 12.054 6.18801V7.98098" stroke="#DCE0E5" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round"/>+<path d="M6.2881 7.1399L5.6 8L6.8 9.5" stroke="#DCE0E5" stroke-width="1.2" stroke-linecap="round" stroke-linejoin="round"/>+</svg>diff --git a/assets/settings/default.json b/assets/settings/default.jsonindex 2fc3b3d0a25..78749a6be73 100644--- a/assets/settings/default.json+++ b/assets/settings/default.json@@ -1008,6 +1008,11 @@// Default depth to expand outline items in the current file.// Set to 0 to collapse all items that have children, 1 or higher to collapse items at that depth or deeper."expand_outlines_with_depth": 100,+ // Whether to hide symbols, excerpts and search matches in the outline panel+ // when a multi-buffer view (e.g. a diff or search results) is active,+ // showing only files and directories.+ // Does not affect single-file views.+ "multi_buffer_hide_symbols": false,},"collaboration_panel": {// Whether to show the collaboration panel button in the status bar.diff --git a/crates/icons/src/icons.rs b/crates/icons/src/icons.rsindex 64531a165a2..22ca64a5822 100644--- a/crates/icons/src/icons.rs+++ b/crates/icons/src/icons.rs@@ -127,6 +127,7 @@ pub enum IconName {FastForwardOff,File,FileCode,+ FileCodeOff,FileDiff,FileDoc,FileGeneric,diff --git a/crates/outline_panel/src/outline_panel.rs b/crates/outline_panel/src/outline_panel.rsindex b251aaab1d3..c2a42c123a4 100644--- a/crates/outline_panel/src/outline_panel.rs+++ b/crates/outline_panel/src/outline_panel.rs@@ -95,6 +95,8 @@ actions!(SelectParent,/// Toggles the pin status of the active editor.ToggleActiveEditorPin,+ /// Toggles showing symbols, excerpts and search matches for multi-buffer views.+ ToggleSymbols,/// Unfolds the selected directory.UnfoldDirectory,/// Toggles the outline panel.@@ -143,7 +145,9 @@ pub struct OutlinePanel {max_width_item_index: Option<usize>,preserve_selection_on_buffer_fold_toggles: HashSet<BufferId>,pending_default_expansion_depth: Option<usize>,+ default_depth_applied_buffers: HashSet<BufferId>,outline_children_cache: HashMap<BufferId, HashMap<(Range<Anchor>, usize), bool>>,+ hide_symbols_override: Option<bool>,}#[derive(Debug)]@@ -660,6 +664,16 @@ pub fn init(cx: &mut App) {workspace.close_panel::<OutlinePanel>(window, cx);}});+ workspace.register_action(|workspace, _: &ToggleSymbols, window, cx| {+ if let Some(outline_panel) = workspace.panel::<OutlinePanel>(cx) {+ // Defer to avoid updating the panel while the workspace is still being updated.+ window.defer(cx, move |window, cx| {+ outline_panel.update(cx, |outline_panel, cx| {+ outline_panel.toggle_symbols(&ToggleSymbols, window, cx);+ });+ });+ }+ });}).detach();}@@ -777,15 +791,33 @@ impl OutlinePanel {}} else if &outline_panel_settings != new_settings {let old_expansion_depth = outline_panel_settings.expand_outlines_with_depth;+ let old_hide_symbols = outline_panel_settings.multi_buffer_hide_symbols;outline_panel_settings = *new_settings;- if old_expansion_depth != new_settings.expand_outlines_with_depth {+ let mut update_cached_entries = false;+ if old_hide_symbols != outline_panel_settings.multi_buffer_hide_symbols {+ outline_panel.hide_symbols_override = None;+ outline_panel.update_non_fs_items(window, cx);+ outline_panel.remap_selection_for_hidden_symbols(window, cx);+ update_cached_entries = true;+ }+ if old_expansion_depth != outline_panel_settings.expand_outlines_with_depth+ {let old_collapsed_entries = outline_panel.collapsed_entries.clone();outline_panel.collapsed_entries.retain(|entry| !matches!(entry, CollapsedEntry::Outline(..)));- let new_depth = new_settings.expand_outlines_with_depth;+ let new_depth = outline_panel_settings.expand_outlines_with_depth;+ outline_panel.pending_default_expansion_depth = Some(new_depth);+ outline_panel.default_depth_applied_buffers = outline_panel+ .buffers+ .iter()+ .filter(|(_, buffer)| {+ matches!(buffer.outlines, OutlineState::Outlines(_))+ })+ .map(|(buffer_id, _)| *buffer_id)+ .collect();for (buffer_id, buffer) in &outline_panel.buffers {if let OutlineState::Outlines(outlines) = &buffer.outlines {@@ -810,12 +842,11 @@ impl OutlinePanel {}if old_collapsed_entries != outline_panel.collapsed_entries {- outline_panel.update_cached_entries(- Some(UPDATE_DEBOUNCE),- window,- cx,- );+ update_cached_entries = true;}+ }+ if update_cached_entries {+ outline_panel.update_cached_entries(Some(UPDATE_DEBOUNCE), window, cx);} else {cx.notify();}@@ -879,6 +910,7 @@ impl OutlinePanel {new_entries_for_fs_update: HashSet::default(),preserve_selection_on_buffer_fold_toggles: HashSet::default(),pending_default_expansion_depth: None,+ default_depth_applied_buffers: HashSet::default(),fs_entries_update_task: Task::ready(()),fs_entries_update_pending: false,cached_entries_update_task: Task::ready(()),@@ -895,6 +927,7 @@ impl OutlinePanel {filter_update_subscription,],outline_children_cache: HashMap::default(),+ hide_symbols_override: None,};if let Some((item, editor)) = workspace_active_editor(workspace, cx) {outline_panel.replace_active_editor(item, editor, window, cx);@@ -3139,7 +3172,7 @@ impl OutlinePanel {// Only update cached entries if we don't have outlines to fetch// If we do have outlines to fetch, let fetch_outdated_outlines handle the update- if outline_panel.buffers_to_fetch().is_empty() {+ if outline_panel.buffers_to_fetch(cx).is_empty() {outline_panel.update_cached_entries(debounce, window, cx);}@@ -3219,6 +3252,7 @@ impl OutlinePanel {self.pinned = false;self.mode = ItemsDisplayMode::Outline;self.pending_default_expansion_depth = None;+ self.default_depth_applied_buffers.clear();}fn location_for_editor_selection(@@ -3449,7 +3483,7 @@ impl OutlinePanel {}fn fetch_outdated_outlines(&mut self, window: &mut Window, cx: &mut Context<Self>) {- let buffers_to_fetch = self.buffers_to_fetch();+ let buffers_to_fetch = self.buffers_to_fetch(cx);if buffers_to_fetch.is_empty() {return;}@@ -3483,7 +3517,11 @@ impl OutlinePanel {outline_panel.update_in(cx, |outline_panel, window, cx| {let pending_default_depth =- outline_panel.pending_default_expansion_depth.take();+ outline_panel.pending_default_expansion_depth.filter(|_| {+ outline_panel+ .default_depth_applied_buffers+ .insert(buffer_id)+ });let debounce =if first_update.fetch_and(false, atomic::Ordering::AcqRel) {@@ -3528,6 +3566,61 @@ impl OutlinePanel {.is_some_and(|active_editor| active_editor.read(cx).buffer().read(cx).is_singleton())}+ fn multi_buffer_active(&self, cx: &App) -> bool {+ self.active_editor()+ .is_some_and(|active_editor| !active_editor.read(cx).buffer().read(cx).is_singleton())+ }++ fn hide_symbols_active(&self, cx: &App) -> bool {+ self.hide_symbols_override+ .unwrap_or(OutlinePanelSettings::get_global(cx).multi_buffer_hide_symbols)+ }++ fn remap_selection_for_hidden_symbols(&mut self, window: &mut Window, cx: &mut Context<Self>) {+ if !self.multi_buffer_active(cx) || !self.hide_symbols_active(cx) {+ return;+ }+ let buffer_id = match self.selected_entry() {+ Some(PanelEntry::Outline(OutlineEntry::Excerpt(excerpt))) => {+ Some(excerpt.context.start.buffer_id)+ }+ Some(PanelEntry::Outline(OutlineEntry::Outline(outline))) => {+ Some(outline.range.start.buffer_id)+ }+ Some(PanelEntry::Search(search_entry)) => {+ let match_start = search_entry.match_range.start;+ self.active_editor().and_then(|editor| {+ let multi_buffer_snapshot = editor.read(cx).buffer().read(cx).snapshot(cx);+ multi_buffer_snapshot+ .anchor_to_buffer_anchor(match_start)+ .map(|(anchor, _)| anchor.buffer_id)+ })+ }+ Some(PanelEntry::Fs(_) | PanelEntry::FoldedDirs(_)) | None => None,+ };+ let Some(buffer_id) = buffer_id else {+ return;+ };+ let file_entry = self+ .fs_entries+ .iter()+ .find(|fs_entry| match fs_entry {+ FsEntry::File(FsEntryFile {+ buffer_id: file_buffer_id,+ ..+ })+ | FsEntry::ExternalFile(FsEntryExternalFile {+ buffer_id: file_buffer_id,+ ..+ }) => *file_buffer_id == buffer_id,+ FsEntry::Directory(..) => false,+ })+ .cloned();+ if let Some(file_entry) = file_entry {+ self.select_entry(PanelEntry::Fs(file_entry), false, window, cx);+ }+ }+fn invalidate_outlines(&mut self, ids: &[BufferId]) {self.outline_fetch_tasks.clear();let mut ids = ids.iter().collect::<HashSet<_>>();@@ -3541,7 +3634,13 @@ impl OutlinePanel {}}- fn buffers_to_fetch(&self) -> HashSet<BufferId> {+ fn buffers_to_fetch(&self, cx: &App) -> HashSet<BufferId> {+ // Hide-symbols mode never renders outline rows, so fetching outlines would be wasted+ // work; `update_fs_entries`'s completion only refreshes cached entries once this is+ // empty, so the gate has to live here rather than in `fetch_outdated_outlines` alone.+ if self.multi_buffer_active(cx) && self.hide_symbols_active(cx) {+ return HashSet::default();+ }self.fs_entries.iter().fold(HashSet::default(), |mut buffers_to_fetch, fs_entry| {@@ -3692,6 +3791,7 @@ impl OutlinePanel {let Ok(()) = outline_panel.update(cx, |outline_panel, cx| {let auto_fold_dirs = OutlinePanelSettings::get_global(cx).auto_fold_dirs;+ let hide_symbols = !is_singleton && outline_panel.hide_symbols_active(cx);let mut folded_dirs_entry = None::<(usize, FoldedDirsEntry)>;let track_matches = query.is_some();@@ -3703,58 +3803,59 @@ impl OutlinePanel {depth: usize,}- let search_precomputed =- if let ItemsDisplayMode::Search(search_state) = &outline_panel.mode {- let multi_buffer_snapshot =- active_editor.read(cx).buffer().read(cx).snapshot(cx);- let mut folded_buffers = HashSet::default();- let mut not_folded_buffers = HashSet::default();- let mut matches_by_buffer = HashMap::default();-- for (match_range, search_data) in &search_state.matches {- let Some((start_anchor, _)) =- multi_buffer_snapshot.anchor_to_buffer_anchor(match_range.start)- else {- continue;- };- let start_buffer_id = start_anchor.buffer_id;- let end_buffer_id = multi_buffer_snapshot- .anchor_to_buffer_anchor(match_range.end)- .map(|(anchor, _)| anchor.buffer_id);-- let mut any_folded = false;- for buffer_id in- [Some(start_buffer_id), end_buffer_id].into_iter().flatten()- {- if folded_buffers.contains(&buffer_id) {+ let search_precomputed = if hide_symbols {+ None+ } else if let ItemsDisplayMode::Search(search_state) = &outline_panel.mode {+ let multi_buffer_snapshot =+ active_editor.read(cx).buffer().read(cx).snapshot(cx);+ let mut folded_buffers = HashSet::default();+ let mut not_folded_buffers = HashSet::default();+ let mut matches_by_buffer = HashMap::default();++ for (match_range, search_data) in &search_state.matches {+ let Some((start_anchor, _)) =+ multi_buffer_snapshot.anchor_to_buffer_anchor(match_range.start)+ else {+ continue;+ };+ let start_buffer_id = start_anchor.buffer_id;+ let end_buffer_id = multi_buffer_snapshot+ .anchor_to_buffer_anchor(match_range.end)+ .map(|(anchor, _)| anchor.buffer_id);++ let mut any_folded = false;+ for buffer_id in+ [Some(start_buffer_id), end_buffer_id].into_iter().flatten()+ {+ if folded_buffers.contains(&buffer_id) {+ any_folded = true;+ } else if !not_folded_buffers.contains(&buffer_id) {+ if active_editor.read(cx).is_buffer_folded(buffer_id, cx) {+ folded_buffers.insert(buffer_id);any_folded = true;- } else if !not_folded_buffers.contains(&buffer_id) {- if active_editor.read(cx).is_buffer_folded(buffer_id, cx) {- folded_buffers.insert(buffer_id);- any_folded = true;- } else {- not_folded_buffers.insert(buffer_id);- }+ } else {+ not_folded_buffers.insert(buffer_id);}}- if any_folded {- continue;- }-- matches_by_buffer- .entry(start_buffer_id)- .or_insert_with(Vec::new)- .push((match_range.clone(), Arc::clone(search_data)));+ }+ if any_folded {+ continue;}- Some(SearchPrecomputed {- multi_buffer_snapshot,- matches_by_buffer,- folded_buffers,- })- } else {- None- };+ matches_by_buffer+ .entry(start_buffer_id)+ .or_insert_with(Vec::new)+ .push((match_range.clone(), Arc::clone(search_data)));+ }++ Some(SearchPrecomputed {+ multi_buffer_snapshot,+ matches_by_buffer,+ folded_buffers,+ })+ } else {+ None+ };let mut parent_dirs = Vec::<ParentStats>::new();for entry in outline_panel.fs_entries.clone() {@@ -3983,25 +4084,28 @@ impl OutlinePanel {);}- match outline_panel.mode {- ItemsDisplayMode::Search(_) => {- if (is_singleton || query.is_some() || (should_add && is_expanded))- && let Some(search) = &search_precomputed- {- outline_panel.add_search_entries(- &mut generation_state,- search,- &entry,- depth,- query.is_some(),- is_singleton,- cx,- );+ if !hide_symbols {+ match outline_panel.mode {+ ItemsDisplayMode::Search(_) => {+ if (is_singleton || query.is_some() || (should_add && is_expanded))+ && let Some(search) = &search_precomputed+ {+ outline_panel.add_search_entries(+ &mut generation_state,+ search,+ &entry,+ depth,+ query.is_some(),+ is_singleton,+ cx,+ );+ }}- }- ItemsDisplayMode::Outline => {- let excerpts_to_consider =- if is_singleton || query.is_some() || (should_add && is_expanded) {+ ItemsDisplayMode::Outline => {+ let excerpts_to_consider = if is_singleton+ || query.is_some()+ || (should_add && is_expanded)+ {match &entry {FsEntry::File(FsEntryFile {buffer_id,@@ -4018,18 +4122,19 @@ impl OutlinePanel {} else {None};- if let Some((buffer_id, _entry_excerpts)) = excerpts_to_consider- && !active_editor.read(cx).is_buffer_folded(buffer_id, cx)- {- outline_panel.add_buffer_entries(- &mut generation_state,- buffer_id,- depth,- track_matches,- is_singleton,- query.as_deref(),- cx,- );+ if let Some((buffer_id, _entry_excerpts)) = excerpts_to_consider+ && !active_editor.read(cx).is_buffer_folded(buffer_id, cx)+ {+ outline_panel.add_buffer_entries(+ &mut generation_state,+ buffer_id,+ depth,+ track_matches,+ is_singleton,+ query.as_deref(),+ cx,+ );+ }}}}@@ -4387,7 +4492,24 @@ impl OutlinePanel {let mut last_depth_at_level: Vec<Option<Range<Anchor>>> = vec![None; 10];- let all_outlines: Vec<_> = buffer.iter_outlines().collect();+ let all_outlines = buffer+ .iter_outlines()+ .filter(|outline| match &buffer_snapshot {+ Some(buffer_snapshot) => {+ outline+ .range+ .start+ .cmp(&excerpt.context.end, buffer_snapshot)+ .is_le()+ && outline+ .range+ .end+ .cmp(&excerpt.context.start, buffer_snapshot)+ .is_ge()+ }+ None => true,+ })+ .collect::<Vec<_>>();let mut outline_has_children = HashMap::default();let mut visible_outlines = Vec::new();@@ -4558,6 +4680,22 @@ impl OutlinePanel {cx.notify();}+ pub fn toggle_symbols(+ &mut self,+ _: &ToggleSymbols,+ window: &mut Window,+ cx: &mut Context<Self>,+ ) {+ if !self.multi_buffer_active(cx) {+ return;+ }+ self.hide_symbols_override = Some(!self.hide_symbols_active(cx));+ self.update_non_fs_items(window, cx);+ self.remap_selection_for_hidden_symbols(window, cx);+ self.update_cached_entries(None, window, cx);+ cx.notify();+ }+fn selected_entry(&self) -> Option<&PanelEntry> {match &self.selected_entry {SelectedEntry::Invalidated(entry) => entry.as_ref(),@@ -4835,6 +4973,13 @@ impl OutlinePanel {};let has_query = self.query(cx).is_some();+ let show_symbols_toggle = self.multi_buffer_active(cx);+ let hide_symbols = self.hide_symbols_active(cx);+ let (hide_symbols_icon, hide_symbols_tooltip) = if hide_symbols {+ (IconName::FileCodeOff, "Show Symbols")+ } else {+ (IconName::FileCode, "Hide Symbols")+ };h_flex().p_2()@@ -4868,9 +5013,27 @@ impl OutlinePanel {})),)})+ .when(show_symbols_toggle, |this| {+ this.child(+ IconButton::new("toggle_symbols", hide_symbols_icon)+ .shape(IconButtonShape::Square)+ .tooltip(Tooltip::for_action_title_in(+ hide_symbols_tooltip,+ &ToggleSymbols,+ &self.focus_handle,+ ))+ .on_click(cx.listener(|outline_panel, _, window, cx| {+ outline_panel.toggle_symbols(&ToggleSymbols, window, cx);+ })),+ )+ }).child(IconButton::new(pin_button_id, icon)- .tooltip(Tooltip::text(icon_tooltip))+ .tooltip(Tooltip::for_action_title_in(+ icon_tooltip,+ &ToggleActiveEditorPin,+ &self.focus_handle,+ )).shape(IconButtonShape::Square).on_click(cx.listener(|outline_panel, _, window, cx| {outline_panel.toggle_active_editor_pin(@@ -5122,6 +5285,7 @@ impl Render for OutlinePanel {.on_action(cx.listener(Self::copy_path)).on_action(cx.listener(Self::copy_relative_path)).on_action(cx.listener(Self::toggle_active_editor_pin))+ .on_action(cx.listener(Self::toggle_symbols)).on_action(cx.listener(Self::unfold_directory)).on_action(cx.listener(Self::fold_directory)).on_action(cx.listener(Self::open_excerpts))@@ -6841,6 +7005,75 @@ outline: struct OutlineEntryExcerpt})}+ async fn open_buffer(+ project: &Entity<Project>,+ abs_path: &str,+ cx: &mut VisualTestContext,+ ) -> Entity<language::Buffer> {+ project+ .update(cx, |project, cx| {+ let path = project.find_project_path(abs_path, cx).unwrap();+ project.open_buffer(path, cx)+ })+ .await+ .unwrap()+ }++ fn add_multi_buffer_editor(+ workspace: &Entity<Workspace>,+ project: &Entity<Project>,+ excerpts: &[(&Entity<language::Buffer>, Vec<Range<language::Point>>)],+ cx: &mut VisualTestContext,+ ) -> Entity<Editor> {+ workspace.update_in(cx, |workspace, window, cx| {+ let multibuffer = cx.new(|cx| {+ let mut multibuffer = editor::MultiBuffer::new(language::Capability::ReadWrite);+ for (buffer, ranges) in excerpts {+ let ranges = if ranges.is_empty() {+ vec![language::Point::default()..buffer.read(cx).max_point()]+ } else {+ ranges.clone()+ };+ multibuffer.set_excerpts_for_buffer((*buffer).clone(), ranges, 0, cx);+ }+ multibuffer+ });+ let editor = cx+ .new(|cx| Editor::for_multibuffer(multibuffer, Some(project.clone()), window, cx));+ workspace.add_item_to_active_pane(Box::new(editor.clone()), None, true, window, cx);+ editor.update(cx, |editor, cx| {+ window.focus(&editor.focus_handle(cx), cx);+ });+ editor+ })+ }++ fn settle_outline_panel(outline_panel: &Entity<OutlinePanel>, cx: &mut VisualTestContext) {+ cx.executor()+ .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(500));+ cx.run_until_parked();+ outline_panel.update_in(cx, |panel, window, cx| {+ panel.update_non_fs_items(window, cx);+ panel.update_cached_entries(Some(UPDATE_DEBOUNCE), window, cx);+ });+ cx.executor()+ .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(500));+ cx.run_until_parked();+ }++ fn update_outline_panel_settings(+ cx: &mut VisualTestContext,+ update: impl FnOnce(&mut settings::OutlinePanelSettingsContent),+ ) {+ cx.update(|_, cx| {+ SettingsStore::update_global(cx, |store, cx| {+ store.update_user_settings(cx, |settings| {+ update(settings.outline_panel.get_or_insert_default());+ });+ });+ });+ }+fn display_entries(project: &Entity<Project>,multi_buffer_snapshot: &MultiBufferSnapshot,@@ -6851,6 +7084,9 @@ outline: struct OutlineEntryExcerptlet project = project.read(cx);let mut display_string = String::new();for entry in cached_entries {+ if matches!(entry.entry, PanelEntry::Outline(OutlineEntry::Excerpt(_))) {+ continue;+ }if !display_string.is_empty() {display_string += "\n";}@@ -8233,4 +8469,1044 @@ outline: struct Foo <==== selected"Cursor at row 6 should select '# Section B'");}++ #[gpui::test]+ async fn test_hide_symbols_in_multibuffer(cx: &mut TestAppContext) {+ init_test(cx);++ let fs = FakeFs::new(cx.background_executor.clone());+ fs.insert_tree(+ path!("/test"),+ json!({+ "src": {+ "one.rs": indoc!("+ pub fn one() {+ let x = 1;+ }+ "),+ "two.rs": indoc!("+ pub struct Two {+ field: i32,+ }+ "),+ }+ }),+ )+ .await;++ let project = Project::test(fs.clone(), [path!("/test").as_ref()], cx).await;+ project.read_with(cx, |project, _| project.languages().add(rust_lang()));+ let (window, workspace) = add_outline_panel(&project, cx).await;+ let cx = &mut VisualTestContext::from_window(window.into(), cx);+ let outline_panel = outline_panel(&workspace, cx);+ outline_panel.update_in(cx, |outline_panel, window, cx| {+ outline_panel.set_active(true, window, cx)+ });++ let buffer_one = open_buffer(&project, path!("/test/src/one.rs"), cx).await;+ let buffer_two = open_buffer(&project, path!("/test/src/two.rs"), cx).await;+ add_multi_buffer_editor(+ &workspace,+ &project,+ &[(&buffer_one, Vec::new()), (&buffer_two, Vec::new())],+ cx,+ );+ settle_outline_panel(&outline_panel, cx);++ outline_panel.update(cx, |panel, _cx| {+ assert!(+ panel.cached_entries.iter().any(|entry| matches!(+ entry.entry,+ PanelEntry::Outline(OutlineEntry::Outline(_))+ )),+ "expected outline rows in the multibuffer before enabling hide-symbols mode"+ );+ });++ let collapsed_entries_snapshot =+ outline_panel.read_with(cx, |panel, _cx| panel.collapsed_entries.clone());++ let struct_two_outline = outline_panel.read_with(cx, |panel, _cx| {+ panel+ .cached_entries+ .iter()+ .find_map(|entry| match &entry.entry {+ PanelEntry::Outline(OutlineEntry::Outline(outline))+ if outline.text == "pub struct Two" =>+ {+ Some(entry.entry.clone())+ }+ _ => None,+ })+ .expect("expected an outline row for `pub struct Two`")+ });+ outline_panel.update_in(cx, |panel, window, cx| {+ panel.select_entry(struct_two_outline, true, window, cx);+ });++ update_outline_panel_settings(cx, |settings| {+ settings.multi_buffer_hide_symbols = Some(true);+ });+ cx.executor()+ .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(500));+ cx.run_until_parked();++ outline_panel.update(cx, |panel, _cx| {+ assert!(+ panel.cached_entries.iter().all(|entry| matches!(+ entry.entry,+ PanelEntry::Fs(_) | PanelEntry::FoldedDirs(_)+ )),+ "hide-symbols mode should only show fs entries, got {:#?}",+ panel.cached_entries+ );+ assert_eq!(+ panel.collapsed_entries, collapsed_entries_snapshot,+ "hide-symbols mode should not mutate collapsed_entries"+ );+ });++ outline_panel.update(cx, |panel, cx| {+ let buffer_two_id = buffer_two.read(cx).remote_id();+ match panel.selected_entry() {+ Some(PanelEntry::Fs(FsEntry::File(file))) => assert_eq!(+ file.buffer_id, buffer_two_id,+ "hiding symbols should remap the selected outline to its containing file"+ ),+ other => panic!("expected the file row of two.rs to be selected, got {other:?}"),+ }+ });++ outline_panel.update_in(cx, |panel, window, cx| {+ panel.toggle_symbols(&ToggleSymbols, window, cx);+ });+ cx.executor()+ .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(500));+ cx.run_until_parked();++ outline_panel.update(cx, |panel, cx| {+ assert!(+ panel.cached_entries.iter().any(|entry| matches!(+ entry.entry,+ PanelEntry::Outline(OutlineEntry::Outline(_))+ )),+ "toggling hide-symbols off should re-fetch and show outline rows again"+ );+ assert_eq!(+ panel.collapsed_entries, collapsed_entries_snapshot,+ "toggling hide-symbols should not mutate collapsed_entries"+ );+ let buffer_two_id = buffer_two.read(cx).remote_id();+ match panel.selected_entry() {+ Some(PanelEntry::Fs(FsEntry::File(file))) => assert_eq!(+ file.buffer_id, buffer_two_id,+ "re-showing symbols should keep the remapped file row selected"+ ),+ other => panic!("expected the file row of two.rs to stay selected, got {other:?}"),+ }+ });++ outline_panel.update_in(cx, |panel, window, cx| {+ panel.toggle_symbols(&ToggleSymbols, window, cx);+ });+ cx.executor()+ .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(500));+ cx.run_until_parked();++ outline_panel.update(cx, |panel, _cx| {+ assert!(+ panel.cached_entries.iter().all(|entry| matches!(+ entry.entry,+ PanelEntry::Fs(_) | PanelEntry::FoldedDirs(_)+ )),+ "toggling hide-symbols back on should hide outline rows again"+ );+ assert_eq!(+ panel.collapsed_entries, collapsed_entries_snapshot,+ "hide-symbols mode should not mutate collapsed_entries"+ );+ });++ // `hide_symbols_override` is `Some(true)` here while the setting is still `true` too,+ // so flipping the setting to `false` makes the override disagree with the incoming+ // settings change, exercising the settings-observer's override reset.+ update_outline_panel_settings(cx, |settings| {+ settings.multi_buffer_hide_symbols = Some(false);+ });+ cx.executor()+ .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(500));+ cx.run_until_parked();++ outline_panel.update(cx, |panel, _cx| {+ assert!(+ panel.cached_entries.iter().any(|entry| matches!(+ entry.entry,+ PanelEntry::Outline(OutlineEntry::Outline(_))+ )),+ "settings change should clear a stale hide-symbols override and re-show outline rows"+ );+ assert_eq!(+ panel.collapsed_entries, collapsed_entries_snapshot,+ "settings-driven override reset should not mutate collapsed_entries"+ );+ });++ // Regression test: dispatch through the workspace-registered handler (not by calling+ // `toggle_symbols` directly) while the editor, not the panel, is focused. This is the+ // path that used to double-lease the `Workspace` entity and panic.+ outline_panel.update_in(cx, |panel, window, cx| {+ assert!(+ !panel.focus_handle(cx).contains_focused(window, cx),+ "the editor, not the outline panel, should be focused before dispatching"+ );+ });++ cx.dispatch_action(ToggleSymbols);+ cx.executor()+ .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(500));+ cx.run_until_parked();++ outline_panel.update(cx, |panel, _cx| {+ assert!(+ panel.cached_entries.iter().all(|entry| matches!(+ entry.entry,+ PanelEntry::Fs(_) | PanelEntry::FoldedDirs(_)+ )),+ "dispatching ToggleSymbols via the workspace handler while unfocused should \+ enable hide-symbols mode without panicking, got {:#?}",+ panel.cached_entries+ );+ });+ }++ #[gpui::test]+ async fn test_hide_symbols_exempts_singleton(cx: &mut TestAppContext) {+ init_test(cx);+ cx.update(|cx| {+ SettingsStore::update_global(cx, |store, cx| {+ store.update_user_settings(cx, |settings| {+ settings+ .outline_panel+ .get_or_insert_default()+ .multi_buffer_hide_symbols = Some(true);+ });+ });+ });++ let fs = FakeFs::new(cx.background_executor.clone());+ fs.insert_tree(+ "/test",+ json!({+ "src": {+ "lib.rs": indoc!("+ mod outer {+ pub struct OuterStruct {+ field: String,+ }+ impl OuterStruct {+ pub fn new() -> Self {+ Self { field: String::new() }+ }+ pub fn method(&self) {+ println!(\"{}\", self.field);+ }+ }+ mod inner {+ pub fn inner_function() {+ let x = 42;+ println!(\"{}\", x);+ }+ pub struct InnerStruct {+ value: i32,+ }+ }+ }+ fn main() {+ let s = outer::OuterStruct::new();+ s.method();+ }+ "),+ }+ }),+ )+ .await;++ let project = Project::test(fs.clone(), ["/test".as_ref()], cx).await;+ project.read_with(cx, |project, _| project.languages().add(rust_lang()));+ let (window, workspace) = add_outline_panel(&project, cx).await;+ let cx = &mut VisualTestContext::from_window(window.into(), cx);+ let outline_panel = outline_panel(&workspace, cx);++ outline_panel.update_in(cx, |outline_panel, window, cx| {+ outline_panel.set_active(true, window, cx)+ });++ workspace+ .update_in(cx, |workspace, window, cx| {+ workspace.open_abs_path(+ PathBuf::from("/test/src/lib.rs"),+ OpenOptions {+ visible: Some(OpenVisible::All),+ ..Default::default()+ },+ window,+ cx,+ )+ })+ .await+ .unwrap();++ cx.executor()+ .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(500));+ cx.run_until_parked();++ // Force another update cycle to ensure outlines are fetched+ outline_panel.update_in(cx, |panel, window, cx| {+ panel.update_non_fs_items(window, cx);+ panel.update_cached_entries(Some(UPDATE_DEBOUNCE), window, cx);+ });+ cx.executor()+ .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(500));+ cx.run_until_parked();++ outline_panel.update(cx, |outline_panel, cx| {+ assert_eq!(+ display_entries(+ &project,+ &snapshot(outline_panel, cx),+ &outline_panel.cached_entries,+ outline_panel.selected_entry(),+ cx,+ ),+ indoc!(+ "+outline: mod outer <==== selected+ outline: pub struct OuterStruct+ outline: field+ outline: impl OuterStruct+ outline: pub fn new+ outline: pub fn method+ outline: mod inner+ outline: pub fn inner_function+ outline: pub struct InnerStruct+ outline: value+outline: fn main"+ ),+ "singleton editors should be exempt from hide-symbols mode"+ );+ });++ outline_panel.update_in(cx, |panel, window, cx| {+ panel.toggle_symbols(&ToggleSymbols, window, cx);+ assert_eq!(+ panel.hide_symbols_override, None,+ "toggling symbols in a singleton view should be a no-op and not arm the override"+ );+ });+ }++ #[gpui::test(iterations = 10)]+ async fn test_hide_symbols_hides_search_matches(cx: &mut TestAppContext) {+ init_test(cx);++ let fs = FakeFs::new(cx.background_executor.clone());+ let root = path!("/rust-analyzer");+ populate_with_test_ra_project(&fs, root).await;+ let project = Project::test(fs.clone(), [Path::new(root)], cx).await;+ project.read_with(cx, |project, _| project.languages().add(rust_lang()));+ let (window, workspace) = add_outline_panel(&project, cx).await;+ let cx = &mut VisualTestContext::from_window(window.into(), cx);+ let outline_panel = outline_panel(&workspace, cx);+ outline_panel.update_in(cx, |outline_panel, window, cx| {+ outline_panel.set_active(true, window, cx)+ });++ workspace.update_in(cx, |workspace, window, cx| {+ ProjectSearchView::deploy_search(+ workspace,+ &workspace::DeploySearch::default(),+ window,+ cx,+ )+ });+ let search_view = workspace.update_in(cx, |workspace, _window, cx| {+ workspace+ .active_pane()+ .read(cx)+ .items()+ .find_map(|item| item.downcast::<ProjectSearchView>())+ .expect("Project search view expected to appear after new search event trigger")+ });++ let query = "param_names_for_lifetime_elision_hints";+ perform_project_search(&search_view, query, cx);+ search_view.update(cx, |search_view, cx| {+ search_view+ .results_editor()+ .update(cx, |results_editor, cx| {+ assert_eq!(+ results_editor.display_text(cx).match_indices(query).count(),+ 9+ );+ });+ });++ let all_matches = r#"rust-analyzer/+ crates/+ ide/src/+ inlay_hints/+ fn_lifetime_fn.rs+ search: match config.«param_names_for_lifetime_elision_hints» {+ search: allocated_lifetimes.push(if config.«param_names_for_lifetime_elision_hints» {+ search: Some(it) if config.«param_names_for_lifetime_elision_hints» => {+ search: InlayHintsConfig { «param_names_for_lifetime_elision_hints»: true, ..TEST_CONFIG },+ inlay_hints.rs+ search: pub «param_names_for_lifetime_elision_hints»: bool,+ search: «param_names_for_lifetime_elision_hints»: self+ static_index.rs+ search: «param_names_for_lifetime_elision_hints»: false,+ rust-analyzer/src/+ cli/+ analysis_stats.rs+ search: «param_names_for_lifetime_elision_hints»: true,+ config.rs+ search: «param_names_for_lifetime_elision_hints»: self"#+ .to_string();++ let select_first_in_all_matches = |line_to_select: &str| {+ assert!(+ all_matches.contains(line_to_select),+ "`{line_to_select}` was not found in all matches `{all_matches}`"+ );+ all_matches.replacen(+ line_to_select,+ &format!("{line_to_select}{SELECTED_MARKER}"),+ 1,+ )+ };++ cx.executor()+ .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100));+ cx.run_until_parked();+ outline_panel.update(cx, |outline_panel, cx| {+ assert_eq!(+ display_entries(+ &project,+ &snapshot(outline_panel, cx),+ &outline_panel.cached_entries,+ outline_panel.selected_entry(),+ cx,+ ),+ select_first_in_all_matches(+ "search: match config.«param_names_for_lifetime_elision_hints» {"+ )+ );+ });++ update_outline_panel_settings(cx, |settings| {+ settings.multi_buffer_hide_symbols = Some(true);+ });+ cx.executor()+ .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100));+ cx.run_until_parked();++ outline_panel.update(cx, |outline_panel, cx| {+ assert!(+ outline_panel.cached_entries.iter().all(|entry| matches!(+ entry.entry,+ PanelEntry::Fs(_) | PanelEntry::FoldedDirs(_)+ )),+ "hide-symbols mode should hide search match rows, got {:#?}",+ outline_panel.cached_entries+ );+ assert_eq!(+ display_entries(+ &project,+ &snapshot(outline_panel, cx),+ &outline_panel.cached_entries,+ outline_panel.selected_entry(),+ cx,+ ),+ indoc!(+ "+rust-analyzer/+ crates/+ ide/src/+ inlay_hints/+ fn_lifetime_fn.rs <==== selected+ inlay_hints.rs+ static_index.rs+ rust-analyzer/src/+ cli/+ analysis_stats.rs+ config.rs"+ ),+ "directories and files should still render in hide-symbols mode, \+ with the previously selected search match remapped to its file"+ );+ });++ outline_panel.update_in(cx, |outline_panel, window, cx| {+ outline_panel.toggle_symbols(&ToggleSymbols, window, cx);+ });+ cx.executor()+ .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100));+ cx.run_until_parked();++ outline_panel.update(cx, |outline_panel, cx| {+ assert!(+ outline_panel+ .cached_entries+ .iter()+ .any(|entry| matches!(entry.entry, PanelEntry::Search(_))),+ "toggling hide-symbols off should bring search match rows back"+ );+ assert_eq!(+ display_entries(+ &project,+ &snapshot(outline_panel, cx),+ &outline_panel.cached_entries,+ outline_panel.selected_entry(),+ cx,+ ),+ all_matches.replacen(+ "fn_lifetime_fn.rs",+ &format!("fn_lifetime_fn.rs{SELECTED_MARKER}"),+ 1,+ ),+ "re-showing search matches should keep the remapped file row selected"+ );+ });+ }++ #[gpui::test]+ async fn test_excerpt_outlines_scoped_to_excerpt_range(cx: &mut TestAppContext) {+ init_test(cx);++ let fs = FakeFs::new(cx.background_executor.clone());+ fs.insert_tree(+ path!("/test"),+ json!({+ "src": {+ "one.rs": indoc!("+ fn alpha() {+ let one = 1;+ }++ fn beta() {+ let two = 2;+ }+ "),+ "two.rs": indoc!("+ struct Gamma {+ field: i32,+ }++ fn delta() {}+ "),+ "three.rs": indoc!("+ mod epsilon {+ fn zeta() {+ let three = 3;+ }+ }+ "),+ }+ }),+ )+ .await;++ let project = Project::test(fs.clone(), [path!("/test").as_ref()], cx).await;+ project.read_with(cx, |project, _| project.languages().add(rust_lang()));+ let (window, workspace) = add_outline_panel(&project, cx).await;+ let cx = &mut VisualTestContext::from_window(window.into(), cx);+ let outline_panel = outline_panel(&workspace, cx);+ outline_panel.update_in(cx, |outline_panel, window, cx| {+ outline_panel.set_active(true, window, cx)+ });++ let buffer_one = open_buffer(&project, path!("/test/src/one.rs"), cx).await;+ let buffer_two = open_buffer(&project, path!("/test/src/two.rs"), cx).await;+ let buffer_three = open_buffer(&project, path!("/test/src/three.rs"), cx).await;++ add_multi_buffer_editor(+ &workspace,+ &project,+ &[+ (+ &buffer_one,+ vec![+ language::Point::new(0, 0)..language::Point::new(2, 1),+ language::Point::new(4, 0)..language::Point::new(6, 1),+ ],+ ),+ (+ &buffer_two,+ vec![language::Point::new(0, 0)..language::Point::new(2, 1)],+ ),+ (+ &buffer_three,+ vec![language::Point::new(2, 0)..language::Point::new(2, 22)],+ ),+ ],+ cx,+ );+ settle_outline_panel(&outline_panel, cx);++ outline_panel.update(cx, |outline_panel, cx| {+ assert_eq!(+ display_entries(+ &project,+ &snapshot(outline_panel, cx),+ &outline_panel.cached_entries,+ None,+ cx,+ ),+ indoc!(+ "+test/+ src/+ one.rs+ outline: fn alpha+ outline: fn beta+ three.rs+ outline: mod epsilon+ outline: fn zeta+ two.rs+ outline: struct Gamma+ outline: field"+ ),+ "each excerpt should only show outlines intersecting its range, \+ without duplicating outlines from other excerpts of the same buffer \+ and without outlines that lie outside every excerpt"+ );+ });+ }++ #[gpui::test]+ async fn test_simultaneous_hide_symbols_and_depth_settings_change(cx: &mut TestAppContext) {+ init_test(cx);++ let fs = FakeFs::new(cx.background_executor.clone());+ fs.insert_tree(+ path!("/test"),+ json!({+ "src": {+ "one.rs": indoc!("+ pub fn one() {+ let x = 1;+ }+ "),+ "two.rs": indoc!("+ pub struct Two {+ field: i32,+ }+ "),+ }+ }),+ )+ .await;++ let project = Project::test(fs.clone(), [path!("/test").as_ref()], cx).await;+ project.read_with(cx, |project, _| project.languages().add(rust_lang()));+ let (window, workspace) = add_outline_panel(&project, cx).await;+ let cx = &mut VisualTestContext::from_window(window.into(), cx);+ let outline_panel = outline_panel(&workspace, cx);+ outline_panel.update_in(cx, |outline_panel, window, cx| {+ outline_panel.set_active(true, window, cx)+ });++ let buffer_one = open_buffer(&project, path!("/test/src/one.rs"), cx).await;+ let buffer_two = open_buffer(&project, path!("/test/src/two.rs"), cx).await;+ add_multi_buffer_editor(+ &workspace,+ &project,+ &[(&buffer_one, Vec::new()), (&buffer_two, Vec::new())],+ cx,+ );+ settle_outline_panel(&outline_panel, cx);++ outline_panel.update(cx, |panel, _cx| {+ assert!(+ panel.cached_entries.iter().any(|entry| matches!(+ entry.entry,+ PanelEntry::Outline(OutlineEntry::Outline(_))+ )),+ "expected outline rows before the settings change"+ );+ assert_eq!(+ panel+ .collapsed_entries+ .iter()+ .filter(|entry| matches!(entry, CollapsedEntry::Outline(..)))+ .count(),+ 0,+ "no outline should be collapsed at the default expansion depth"+ );+ });++ update_outline_panel_settings(cx, |settings| {+ settings.multi_buffer_hide_symbols = Some(true);+ settings.expand_outlines_with_depth = Some(0);+ });+ cx.executor()+ .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(500));+ cx.run_until_parked();++ outline_panel.update(cx, |panel, _cx| {+ assert!(+ panel.cached_entries.iter().all(|entry| matches!(+ entry.entry,+ PanelEntry::Fs(_) | PanelEntry::FoldedDirs(_)+ )),+ "hide-symbols mode should only show fs entries, got {:#?}",+ panel.cached_entries+ );+ assert_eq!(+ panel+ .collapsed_entries+ .iter()+ .filter(|entry| matches!(entry, CollapsedEntry::Outline(..)))+ .count(),+ 1,+ "a depth change arriving together with a hide-symbols change should still \+ collapse the only outline with children (struct Two)"+ );+ });++ update_outline_panel_settings(cx, |settings| {+ settings.multi_buffer_hide_symbols = Some(false);+ });+ cx.executor()+ .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(500));+ cx.run_until_parked();++ outline_panel.update(cx, |panel, cx| {+ assert_eq!(+ display_entries(+ &project,+ &snapshot(panel, cx),+ &panel.cached_entries,+ None,+ cx+ ),+ indoc!(+ "+test/+ src/+ one.rs+ outline: pub fn one+ two.rs+ outline: pub struct Two"+ ),+ "after re-showing symbols, the depth applied during the combined settings \+ change should keep struct Two collapsed, hiding its field"+ );+ });+ }++ #[gpui::test]+ async fn test_filtered_symbol_selection_survives_hide_symbols(cx: &mut TestAppContext) {+ init_test(cx);++ let fs = FakeFs::new(cx.background_executor.clone());+ fs.insert_tree(+ path!("/test"),+ json!({+ "src": {+ "one.rs": indoc!("+ fn alpha() {+ let one = 1;+ }+ "),+ "two.rs": indoc!("+ pub struct Two {+ field: i32,+ }+ "),+ }+ }),+ )+ .await;++ let project = Project::test(fs.clone(), [path!("/test").as_ref()], cx).await;+ project.read_with(cx, |project, _| project.languages().add(rust_lang()));+ let (window, workspace) = add_outline_panel(&project, cx).await;+ let cx = &mut VisualTestContext::from_window(window.into(), cx);+ let outline_panel = outline_panel(&workspace, cx);+ outline_panel.update_in(cx, |outline_panel, window, cx| {+ outline_panel.set_active(true, window, cx)+ });++ let buffer_one = open_buffer(&project, path!("/test/src/one.rs"), cx).await;+ let buffer_two = open_buffer(&project, path!("/test/src/two.rs"), cx).await;+ add_multi_buffer_editor(+ &workspace,+ &project,+ &[(&buffer_one, Vec::new()), (&buffer_two, Vec::new())],+ cx,+ );+ settle_outline_panel(&outline_panel, cx);++ outline_panel.update_in(cx, |panel, window, cx| {+ panel.filter_editor.update(cx, |filter_editor, cx| {+ filter_editor.set_text("alpha", window, cx);+ });+ });+ cx.executor()+ .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100));+ cx.run_until_parked();++ let alpha_outline = outline_panel.read_with(cx, |panel, _cx| {+ panel+ .cached_entries+ .iter()+ .find_map(|entry| match &entry.entry {+ PanelEntry::Outline(OutlineEntry::Outline(outline))+ if outline.text == "fn alpha" =>+ {+ Some(entry.entry.clone())+ }+ _ => None,+ })+ .expect("expected the filtered view to contain the `fn alpha` outline")+ });+ outline_panel.update_in(cx, |panel, window, cx| {+ panel.select_entry(alpha_outline, true, window, cx);+ });++ outline_panel.update_in(cx, |panel, window, cx| {+ panel.toggle_symbols(&ToggleSymbols, window, cx);+ });+ cx.executor()+ .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100));+ cx.run_until_parked();++ outline_panel.update_in(cx, |panel, window, cx| {+ assert_eq!(+ panel.cached_entries.len(),+ 0,+ "hiding symbols with a symbol-only filter should show an empty list, got {:#?}",+ panel.cached_entries+ );+ let buffer_one_id = buffer_one.read(cx).remote_id();+ match panel.selected_entry() {+ Some(PanelEntry::Fs(FsEntry::File(file))) => assert_eq!(+ file.buffer_id, buffer_one_id,+ "the filtered outline selection should remap to its containing file"+ ),+ other => panic!("expected the file row of one.rs to be selected, got {other:?}"),+ }+ panel.select_next(&SelectNext, window, cx);+ panel.select_previous(&SelectPrevious, window, cx);+ });++ outline_panel.update_in(cx, |panel, window, cx| {+ panel.filter_editor.update(cx, |filter_editor, cx| {+ filter_editor.set_text("", window, cx);+ });+ });+ cx.executor()+ .advance_clock(UPDATE_DEBOUNCE + Duration::from_millis(100));+ cx.run_until_parked();++ outline_panel.update(cx, |panel, cx| {+ assert_eq!(+ display_entries(+ &project,+ &snapshot(panel, cx),+ &panel.cached_entries,+ panel.selected_entry(),+ cx,+ ),+ indoc!(+ "+test/+ src/+ one.rs <==== selected+ two.rs"+ ),+ "clearing the filter should reveal the remapped file row still selected"+ );+ });+ }++ #[gpui::test]+ async fn test_default_depth_applies_to_all_buffers(cx: &mut TestAppContext) {+ init_test(cx);+ cx.update(|cx| {+ SettingsStore::update_global(cx, |store, cx| {+ store.update_user_settings(cx, |settings| {+ settings+ .outline_panel+ .get_or_insert_default()+ .expand_outlines_with_depth = Some(0);+ });+ });+ });++ let fs = FakeFs::new(cx.background_executor.clone());+ fs.insert_tree(+ path!("/test"),+ json!({+ "src": {+ "one.rs": indoc!("+ mod alpha {+ fn a() {}+ }+ "),+ "two.rs": indoc!("+ pub struct Two {+ field: i32,+ }+ "),+ }+ }),+ )+ .await;++ let project = Project::test(fs.clone(), [path!("/test").as_ref()], cx).await;+ project.read_with(cx, |project, _| project.languages().add(rust_lang()));+ let (window, workspace) = add_outline_panel(&project, cx).await;+ let cx = &mut VisualTestContext::from_window(window.into(), cx);+ let outline_panel = outline_panel(&workspace, cx);+ outline_panel.update_in(cx, |outline_panel, window, cx| {+ outline_panel.set_active(true, window, cx)+ });++ let buffer_one = open_buffer(&project, path!("/test/src/one.rs"), cx).await;+ let buffer_two = open_buffer(&project, path!("/test/src/two.rs"), cx).await;+ add_multi_buffer_editor(+ &workspace,+ &project,+ &[(&buffer_one, Vec::new()), (&buffer_two, Vec::new())],+ cx,+ );+ settle_outline_panel(&outline_panel, cx);++ outline_panel.update(cx, |panel, cx| {+ assert_eq!(+ panel+ .collapsed_entries+ .iter()+ .filter(|entry| matches!(entry, CollapsedEntry::Outline(..)))+ .count(),+ 2,+ "the default expansion depth should collapse parent outlines in every \+ buffer of the multi-buffer, not just the first fetched one"+ );+ assert_eq!(+ display_entries(+ &project,+ &snapshot(panel, cx),+ &panel.cached_entries,+ None,+ cx+ ),+ indoc!(+ "+test/+ src/+ one.rs+ outline: mod alpha+ two.rs+ outline: pub struct Two"+ ),+ "both files should render only their collapsed parent outlines"+ );+ });+ }++ #[gpui::test]+ async fn test_depth_change_while_symbols_hidden_applies_on_reveal(cx: &mut TestAppContext) {+ init_test(cx);+ cx.update(|cx| {+ SettingsStore::update_global(cx, |store, cx| {+ store.update_user_settings(cx, |settings| {+ settings+ .outline_panel+ .get_or_insert_default()+ .multi_buffer_hide_symbols = Some(true);+ });+ });+ });++ let fs = FakeFs::new(cx.background_executor.clone());+ fs.insert_tree(+ path!("/test"),+ json!({+ "src": {+ "one.rs": indoc!("+ mod alpha {+ fn a() {}+ }+ "),+ "two.rs": indoc!("+ pub struct Two {+ field: i32,+ }+ "),+ }+ }),+ )+ .await;++ let project = Project::test(fs.clone(), [path!("/test").as_ref()], cx).await;+ project.read_with(cx, |project, _| project.languages().add(rust_lang()));+ let (window, workspace) = add_outline_panel(&project, cx).await;+ let cx = &mut VisualTestContext::from_window(window.into(), cx);+ let outline_panel = outline_panel(&workspace, cx);+ outline_panel.update_in(cx, |outline_panel, window, cx| {+ outline_panel.set_active(true, window, cx)+ });++ let buffer_one = open_buffer(&project, path!("/test/src/one.rs"), cx).await;+ let buffer_two = open_buffer(&project, path!("/test/src/two.rs"), cx).await;+ add_multi_buffer_editor(+ &workspace,+ &project,+ &[(&buffer_one, Vec::new()), (&buffer_two, Vec::new())],+ cx,+ );+ settle_outline_panel(&outline_panel, cx);++ outline_panel.update(cx, |panel, _cx| {+ assert!(+ panel.cached_entries.iter().all(|entry| matches!(+ entry.entry,+ PanelEntry::Fs(_) | PanelEntry::FoldedDirs(_)+ )),+ "symbols should be hidden and outlines unfetched before the settings change"+ );+ });++ update_outline_panel_settings(cx, |settings| {+ settings.multi_buffer_hide_symbols = Some(false);+ settings.expand_outlines_with_depth = Some(0);+ });+ settle_outline_panel(&outline_panel, cx);++ outline_panel.update(cx, |panel, cx| {+ assert_eq!(+ display_entries(+ &project,+ &snapshot(panel, cx),+ &panel.cached_entries,+ None,+ cx+ ),+ indoc!(+ "+test/+ src/+ one.rs+ outline: mod alpha+ two.rs+ outline: pub struct Two"+ ),+ "a depth change while symbols were hidden should apply to outlines \+ fetched after the symbols are shown again"+ );+ });+ }}diff --git a/crates/outline_panel/src/outline_panel_settings.rs b/crates/outline_panel/src/outline_panel_settings.rsindex 238da62e2f0..0c4605b5a81 100644--- a/crates/outline_panel/src/outline_panel_settings.rs+++ b/crates/outline_panel/src/outline_panel_settings.rs@@ -18,6 +18,7 @@ pub struct OutlinePanelSettings {pub auto_fold_dirs: bool,pub scrollbar: ScrollbarSettings,pub expand_outlines_with_depth: usize,+ pub multi_buffer_hide_symbols: bool,}#[derive(Copy, Clone, Debug, PartialEq, Eq)]@@ -76,6 +77,7 @@ impl Settings for OutlinePanelSettings {.map(ui_scrollbar_settings_from_raw),},expand_outlines_with_depth: panel.expand_outlines_with_depth.unwrap(),+ multi_buffer_hide_symbols: panel.multi_buffer_hide_symbols.unwrap(),}}}diff --git a/crates/settings_content/src/settings_content.rs b/crates/settings_content/src/settings_content.rsindex 55436c87a9c..5e003678894 100644--- a/crates/settings_content/src/settings_content.rs+++ b/crates/settings_content/src/settings_content.rs@@ -1210,6 +1210,13 @@ pub struct OutlinePanelSettingsContent {////// Default: 100pub expand_outlines_with_depth: Option<usize>,+ /// Whether to hide symbols, excerpts and search matches in the outline panel+ /// when a multi-buffer view (e.g. a diff or search results) is active,+ /// showing only files and directories.+ /// Does not affect single-file views.+ ///+ /// Default: false+ pub multi_buffer_hide_symbols: Option<bool>,}#[derive(diff --git a/crates/settings_ui/src/page_data.rs b/crates/settings_ui/src/page_data.rsindex 5f00e971df8..9941e2c3fdd 100644--- a/crates/settings_ui/src/page_data.rs+++ b/crates/settings_ui/src/page_data.rs@@ -5892,7 +5892,7 @@ fn panels_page() -> SettingsPage {]}- fn outline_panel_section() -> [SettingsPageItem; 11] {+ fn outline_panel_section() -> [SettingsPageItem; 12] {[SettingsPageItem::SectionHeader("Outline Panel"),SettingsPageItem::SettingItem(SettingItem {@@ -6108,6 +6108,29 @@ fn panels_page() -> SettingsPage {}),metadata: None,}),+ SettingsPageItem::SettingItem(SettingItem {+ title: "Hide Symbols in Multi-Buffers",+ description: "Whether to hide symbols, excerpts and search matches in the outline panel when a multi-buffer view is active.",+ field: Box::new(SettingField {+ organization_override: None,+ json_path: Some("outline_panel.multi_buffer_hide_symbols"),+ pick: |settings_content| {+ settings_content+ .outline_panel+ .as_ref()?+ .multi_buffer_hide_symbols+ .as_ref()+ },+ write: |settings_content, value, _| {+ settings_content+ .outline_panel+ .get_or_insert_default()+ .multi_buffer_hide_symbols = value;+ },+ }),+ metadata: None,+ files: USER,+ }),]}diff --git a/docs/src/reference/all-settings.md b/docs/src/reference/all-settings.mdindex ecd9aca7d92..2eb333f1eeb 100644--- a/docs/src/reference/all-settings.md+++ b/docs/src/reference/all-settings.md@@ -5817,7 +5817,8 @@ You can define these in user or project settings; project settings are merged on},"scrollbar": {"show": null- }+ },+ "multi_buffer_hide_symbols": false}}```diff --git a/docs/src/visual-customization.md b/docs/src/visual-customization.mdindex a562634acf0..da848c6325d 100644--- a/docs/src/visual-customization.md+++ b/docs/src/visual-customization.md@@ -608,7 +608,8 @@ See [Terminal settings](./reference/all-settings.md#terminal) for additional non"auto_fold_dirs": true, // Fold dirs with single subdir"scrollbar": { // Project panel scrollbar settings"show": null // Show/hide: (auto, system, always, never)- }+ },+ "multi_buffer_hide_symbols": false // Hide symbols in multi-buffer views (show only files)}```