From 705b429e78065041f0e4be1ded480d26c5a039ab Mon Sep 17 00:00:00 2001 From: Parker Loflin Date: Wed, 18 Nov 2026 09:34:07 +0000 Subject: [PATCH] multi_buffer: Sync only changed buffers (#67053) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit ## Summary A change to any buffer made the multibuffer's next sync read every buffer and diff, and adding a buffer counted as a change. With N buffers, each change cost O(N). Inserting excerpts syncs first, so building a multibuffer one path at a time took O(N²) time on the main thread. Project search, project diagnostics, multi-file git diffs, and find references all build their multibuffers this way. The multibuffer keeps a set of the buffers that changed or were added since the last sync, and a sync reads only those buffers and their diffs. `Buffer::record_changes` takes this set in place of a changed flag, and each buffer adds its ID when it changes. The snapshot stores each buffer's dirty, deleted-file, and conflict flags and counts how many buffers have each one, so `is_dirty`, `has_deleted_file`, and `has_conflict` don't scan every buffer. This also fixes three cases where the multibuffer stayed out of date until another buffer changed: - The `Buffer` methods `did_reload`, `set_capability`, `set_conflict`, and `set_agent_selections` changed dirty, conflict, or selection state without marking the buffer as changed. - Removing a buffer didn't update `is_dirty`, `has_deleted_file`, or `has_conflict`. - `MultiBuffer::clone` dropped changes that the original hadn't synced yet. Benchmark: a test searches an in-memory project of N files, with two matches in each, in a `ProjectSearchView`. Both versions call `MultiBuffer::sync_from_buffer_changes` N + 1 times, and sync time is the total of those calls. Release build, single-threaded GPUI test executor, multibuffer and worktree invariant checks off, Ryzen 7 9800X3D, median of five alternating runs of `main` and this branch: | Files | Sync before | Sync after | Sync speedup | Search before | Search after | Search speedup | |---|---|---|---|---|---|---| | 1,000 | 49.4 ms | 2.4 ms | 21× | 4.21 s | 4.13 s | 1.02× | | 2,000 | 216.3 ms | 5.2 ms | 42× | 10.59 s | 10.24 s | 1.03× | | 4,000 | 928.5 ms | 9.8 ms | 95× | 30.17 s | 28.83 s | 1.05× | ## Testing - `test_dirty_state_across_buffers` checks `MultiBuffer::is_dirty` across three buffers through edits, saves, a reload, a capability change, and an excerpt removal. It fails on `main` at the reload. - `test_deleted_file_and_conflict_state_across_buffers` marks two buffers deleted, then conflicted, without editing them, and clears or removes them one at a time. Each flag stays set until its last buffer is cleared or removed. It fails on `main` at the first conflict check. - `test_clone_with_pending_changes` clones a multibuffer before it syncs a buffer edit and checks that both copies show the edit. It fails on `main`, where the clone misses the edit. - After each mutation, the randomized multibuffer tests check that each buffer's snapshot matches the buffer's version and flags, and that the counts agree with the flags. - `cargo test -p multi_buffer`, `cargo test -p editor -p search -p language`, and `./script/clippy -p multi_buffer -p language` pass, as do the randomized multibuffer tests with `ITERATIONS=300`. ## Self-review - [x] I've reviewed my diff for quality, security, reliability, and performance. - [x] UI changes follow the [checklist](https://zed.dev/docs/development/ui-checklist). - [x] Tests cover the new or changed behavior. Release Notes: - Improved performance of multibuffers with many files, such as large project search results --- crates/editor/src/display_map.rs | 2 +- crates/language/src/buffer.rs | 33 ++-- crates/multi_buffer/src/multi_buffer.rs | 174 ++++++++++++++---- crates/multi_buffer/src/multi_buffer_tests.rs | 165 ++++++++++++++++- crates/multi_buffer/src/path_key.rs | 11 +- 5 files changed, 322 insertions(+), 63 deletions(-) diff --git a/crates/editor/src/display_map.rs b/crates/editor/src/display_map.rs index e759efc4111..c9bfa56f8a6 100644 --- a/crates/editor/src/display_map.rs +++ b/crates/editor/src/display_map.rs @@ -4909,7 +4909,7 @@ pub mod tests { let buffer = cx.new(|cx| Buffer::local("initial", cx)); let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx)); - // Edit the buffer. This sets buffer_changed_since_sync = true. + // Edit the buffer. This adds it to the multibuffer's changed buffers. // Importantly, do NOT call multibuffer.snapshot() yet. buffer.update(cx, |buffer, cx| { buffer.edit([(0..0, "prefix ")], None, cx); diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs index 544e344e087..7c6e4fa9eb7 100644 --- a/crates/language/src/buffer.rs +++ b/crates/language/src/buffer.rs @@ -27,7 +27,7 @@ use crate::{ use anyhow::{Context as _, Result}; use clock::Lamport; pub use clock::ReplicaId; -use collections::HashMap; +use collections::{HashMap, HashSet}; use encoding_rs::Encoding; use file_content::{ByteContent, decode_byte_header}; use fs::MTime; @@ -45,7 +45,7 @@ use settings::{SettingsStore, WorktreeId}; use smallvec::SmallVec; use std::{ any::Any, - cell::Cell, + cell::{Cell, RefCell}, cmp::{self, Ordering, Reverse}, collections::{BTreeMap, BTreeSet}, fmt::Write as _, @@ -138,7 +138,7 @@ pub struct Buffer { /// Memoize calls to has_changes_since(saved_version). /// The contents of a cell are (self.version, has_changes) at the time of a last call. has_unsaved_edits: Cell<(clock::Global, bool)>, - change_bits: Vec>>, + changed_buffer_sets: Vec>>>, modeline: Option>, _subscriptions: Vec, resolved_settings: Option>, @@ -1193,7 +1193,7 @@ impl Buffer { completion_triggers_timestamp: Lamport::MIN, deferred_ops: OperationQueue::new(), has_conflict: false, - change_bits: Default::default(), + changed_buffer_sets: Default::default(), modeline: None, _subscriptions: Vec::new(), resolved_settings: None, @@ -1645,6 +1645,7 @@ impl Buffer { pub fn set_capability(&mut self, capability: Capability, cx: &mut Context) { if self.capability != capability { self.capability = capability; + self.was_changed(); cx.emit(BufferEvent::CapabilityChanged) } } @@ -1786,6 +1787,7 @@ impl Buffer { .set((self.saved_version.clone(), false)); self.text.set_line_ending(line_ending); self.saved_mtime = mtime; + self.was_changed(); cx.emit(BufferEvent::Reloaded); cx.notify(); } @@ -2549,6 +2551,7 @@ impl Buffer { /// Marks the buffer as having a conflict regardless of current buffer state. pub fn set_conflict(&mut self) { self.has_conflict = true; + self.was_changed(); } /// Checks if the buffer and its file have both changed since the buffer @@ -2578,26 +2581,27 @@ impl Buffer { self.text.subscribe() } - /// Adds a bit to the list of bits that are set when the buffer's text changes. + /// Registers a set that receives this buffer's id whenever the buffer changes. /// /// This allows downstream code to check if the buffer's text has changed without /// waiting for an effect cycle, which would be required if using eents. - pub fn record_changes(&mut self, bit: rc::Weak>) { + pub fn record_changes(&mut self, changed_buffers: rc::Weak>>) { if let Err(ix) = self - .change_bits - .binary_search_by_key(&rc::Weak::as_ptr(&bit), rc::Weak::as_ptr) + .changed_buffer_sets + .binary_search_by_key(&rc::Weak::as_ptr(&changed_buffers), rc::Weak::as_ptr) { - self.change_bits.insert(ix, bit); + self.changed_buffer_sets.insert(ix, changed_buffers); } } - /// Set the change bit for all "listeners". + /// Inserts this buffer's id into every set registered with [`Buffer::record_changes`]. fn was_changed(&mut self) { - self.change_bits.retain(|change_bit| { - change_bit + let buffer_id = self.remote_id(); + self.changed_buffer_sets.retain(|changed_buffers| { + changed_buffers .upgrade() - .inspect(|bit| { - _ = bit.replace(true); + .inspect(|changed_buffers| { + changed_buffers.borrow_mut().insert(buffer_id); }) .is_some() }); @@ -2817,6 +2821,7 @@ impl Buffer { }, ); self.non_text_state_update_count += 1; + self.was_changed(); cx.notify(); } diff --git a/crates/multi_buffer/src/multi_buffer.rs b/crates/multi_buffer/src/multi_buffer.rs index f5798a65d18..d6a7bc5c924 100644 --- a/crates/multi_buffer/src/multi_buffer.rs +++ b/crates/multi_buffer/src/multi_buffer.rs @@ -38,7 +38,7 @@ use smallvec::SmallVec; use std::{ any::type_name, borrow::Cow, - cell::{Cell, OnceCell, Ref, RefCell}, + cell::{OnceCell, Ref, RefCell}, cmp::{self, Ordering}, fmt, future::Future, @@ -89,7 +89,9 @@ pub struct MultiBuffer { title: Option, /// The writing capability of the multi-buffer. capability: Capability, - buffer_changed_since_sync: Rc>, + /// Ids of the buffers that changed or were added since the last sync. Buffers add their ids + /// through [`Buffer::record_changes`]. + changed_buffers: Rc>>, } #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] @@ -678,6 +680,78 @@ struct BufferStateSnapshot { pub(crate) path_key: PathKey, path_key_index: PathKeyIndex, buffer_snapshot: BufferSnapshot, + status: BufferStatus, +} + +/// Buffer flags that `MultiBufferSnapshot` aggregates across its buffers. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +struct BufferStatus { + is_dirty: bool, + has_deleted_file: bool, + has_conflict: bool, +} + +impl BufferStatus { + fn new(buffer: &Buffer) -> Self { + Self { + is_dirty: buffer.is_dirty(), + has_deleted_file: buffer + .file() + .is_some_and(|file| file.disk_state().is_deleted()), + has_conflict: buffer.has_conflict(), + } + } +} + +#[derive(Clone, Debug, Default, PartialEq, Eq)] +struct BufferStatusCounts { + dirty: usize, + deleted_file: usize, + conflict: usize, +} + +impl BufferStatusCounts { + fn add(&mut self, status: BufferStatus) { + self.dirty += status.is_dirty as usize; + self.deleted_file += status.has_deleted_file as usize; + self.conflict += status.has_conflict as usize; + } + + fn remove(&mut self, status: BufferStatus) { + self.dirty -= status.is_dirty as usize; + self.deleted_file -= status.has_deleted_file as usize; + self.conflict -= status.has_conflict as usize; + } +} + +/// Buffer state snapshots by buffer id, with counts of the buffers that have each status flag. +#[derive(Clone, Debug, Default)] +struct BufferStateSnapshots { + snapshots: TreeMap, + status_counts: BufferStatusCounts, +} + +impl std::ops::Deref for BufferStateSnapshots { + type Target = TreeMap; + + fn deref(&self) -> &Self::Target { + &self.snapshots + } +} + +impl BufferStateSnapshots { + fn insert(&mut self, buffer_id: BufferId, buffer_state: BufferStateSnapshot) { + self.status_counts.add(buffer_state.status); + if let Some(old_buffer_state) = self.snapshots.insert_or_replace(buffer_id, buffer_state) { + self.status_counts.remove(old_buffer_state.status); + } + } + + fn remove(&mut self, buffer_id: &BufferId) { + if let Some(buffer_state) = self.snapshots.remove(buffer_id) { + self.status_counts.remove(buffer_state.status); + } + } } impl fmt::Debug for BufferStateSnapshot { @@ -693,15 +767,12 @@ impl fmt::Debug for BufferStateSnapshot { #[derive(Clone, Default)] pub struct MultiBufferSnapshot { excerpts: SumTree, - buffers: TreeMap, + buffers: BufferStateSnapshots, path_keys: Arc>, diffs: SumTree, diff_transforms: SumTree, non_text_state_update_count: usize, edit_count: usize, - is_dirty: bool, - has_deleted_file: bool, - has_conflict: bool, has_inverted_diff: bool, singleton: bool, trailing_excerpt_update_count: usize, @@ -1286,17 +1357,17 @@ impl MultiBuffer { singleton: false, capability, title: None, - buffer_changed_since_sync: Default::default(), + changed_buffers: Default::default(), history: History::default(), } } pub fn clone(&self, new_cx: &mut Context) -> Self { let mut buffers = BTreeMap::default(); - let buffer_changed_since_sync = Rc::new(Cell::new(false)); + let changed_buffers = Rc::new(RefCell::new(self.changed_buffers.borrow().clone())); for (buffer_id, buffer_state) in self.buffers.iter() { buffer_state.buffer.update(new_cx, |buffer, _| { - buffer.record_changes(Rc::downgrade(&buffer_changed_since_sync)); + buffer.record_changes(Rc::downgrade(&changed_buffers)); }); buffers.insert( *buffer_id, @@ -1322,7 +1393,7 @@ impl MultiBuffer { capability: self.capability, history: self.history.clone(), title: self.title.clone(), - buffer_changed_since_sync, + changed_buffers, } } @@ -1868,9 +1939,6 @@ impl MultiBuffer { diff_transforms: _, non_text_state_update_count: _, edit_count: _, - is_dirty, - has_deleted_file, - has_conflict, has_inverted_diff, singleton: _, trailing_excerpt_update_count, @@ -1887,9 +1955,6 @@ impl MultiBuffer { *buffers = Default::default(); *diffs = Default::default(); *trailing_excerpt_update_count += 1; - *is_dirty = false; - *has_deleted_file = false; - *has_conflict = false; *has_inverted_diff = false; let edits = Self::sync_diff_transforms( @@ -2507,14 +2572,15 @@ impl MultiBuffer { #[ztracing::instrument(skip_all)] fn sync(&self, cx: &App) { - let changed = self.buffer_changed_since_sync.replace(false); - if !changed { + let changed_buffer_ids = mem::take(&mut *self.changed_buffers.borrow_mut()); + if changed_buffer_ids.is_empty() { return; } let edits = Self::sync_from_buffer_changes( &mut self.snapshot.borrow_mut(), &self.buffers, &self.diffs, + &changed_buffer_ids, cx, ); if !edits.is_empty() { @@ -2524,11 +2590,17 @@ impl MultiBuffer { fn sync_mut(&mut self, cx: &App) -> &mut MultiBufferSnapshot { let snapshot = self.snapshot.get_mut(); - let changed = self.buffer_changed_since_sync.replace(false); - if !changed { + let changed_buffer_ids = mem::take(&mut *self.changed_buffers.borrow_mut()); + if changed_buffer_ids.is_empty() { return snapshot; } - let edits = Self::sync_from_buffer_changes(snapshot, &self.buffers, &self.diffs, cx); + let edits = Self::sync_from_buffer_changes( + snapshot, + &self.buffers, + &self.diffs, + &changed_buffer_ids, + cx, + ); if !edits.is_empty() { self.subscriptions.publish(edits); @@ -2541,6 +2613,7 @@ impl MultiBuffer { snapshot: &mut MultiBufferSnapshot, buffers: &BTreeMap, diffs: &HashMap, + changed_buffer_ids: &HashSet, cx: &App, ) -> Vec> { let MultiBufferSnapshot { @@ -2551,9 +2624,6 @@ impl MultiBuffer { diff_transforms: _, non_text_state_update_count, edit_count, - is_dirty, - has_deleted_file, - has_conflict, has_inverted_diff: _, singleton: _, trailing_excerpt_update_count: _, @@ -2562,13 +2632,13 @@ impl MultiBuffer { use_extended_diff_range: _, show_headers: _, } = snapshot; - *is_dirty = false; - *has_deleted_file = false; - *has_conflict = false; if !diffs.is_empty() { let mut diffs_to_add = Vec::new(); - for (id, diff) in diffs { + for (id, diff) in changed_buffer_ids + .iter() + .filter_map(|id| diffs.get_key_value(id)) + { if find_diff_state(buffer_diff, *id).is_none_or(|existing_diff| { if existing_diff.main_buffer.is_none() { return false; @@ -2580,7 +2650,7 @@ impl MultiBuffer { .changed_since(existing_diff.base_text().version()) }) { if diffs_to_add.capacity() == 0 { - diffs_to_add.reserve(diffs.len()); + diffs_to_add.reserve(changed_buffer_ids.len()); } diffs_to_add.push(sum_tree::Edit::Insert(diff.snapshot(*id, cx))); } @@ -2591,7 +2661,10 @@ impl MultiBuffer { let mut paths_to_edit = Vec::new(); let mut non_text_state_updated = false; let mut edited = false; - for buffer_state in buffers.values() { + for buffer_state in changed_buffer_ids + .iter() + .filter_map(|buffer_id| buffers.get(buffer_id)) + { let buffer = buffer_state.buffer.read(cx); let last_snapshot = buffer_snapshots .get(&buffer.remote_id()) @@ -2603,7 +2676,10 @@ impl MultiBuffer { current_version.changed_since(last_snapshot.buffer_snapshot.version()); let buffer_non_text_state_updated = non_text_state_update_count > last_snapshot.buffer_snapshot.non_text_state_update_count(); - if buffer_edited || buffer_non_text_state_updated { + if buffer_edited + || buffer_non_text_state_updated + || BufferStatus::new(buffer) != last_snapshot.status + { paths_to_edit.push(( last_snapshot.path_key.clone(), last_snapshot.path_key_index, @@ -2618,11 +2694,6 @@ impl MultiBuffer { edited |= buffer_edited; non_text_state_updated |= buffer_non_text_state_updated; - *is_dirty |= buffer.is_dirty(); - *has_deleted_file |= buffer - .file() - .is_some_and(|file| file.disk_state().is_deleted()); - *has_conflict |= buffer.has_conflict(); } if edited { *edit_count += 1; @@ -2648,6 +2719,7 @@ impl MultiBuffer { path_key: path.clone(), path_key_index, buffer_snapshot: buffer.snapshot(), + status: BufferStatus::new(buffer), }, ); @@ -3383,7 +3455,29 @@ impl MultiBuffer { } fn check_invariants(&self, cx: &App) { - self.read(cx).check_invariants(); + let snapshot = self.read(cx); + snapshot.check_invariants(); + + let mut status_counts = BufferStatusCounts::default(); + for (buffer_id, buffer_state) in &self.buffers { + let buffer = buffer_state.buffer.read(cx); + let buffer_state_snapshot = snapshot + .buffers + .get(buffer_id) + .expect("each buffer should have a snapshot"); + assert_eq!( + buffer_state_snapshot.buffer_snapshot.version(), + &buffer.version(), + "stale snapshot for buffer {buffer_id:?}" + ); + assert_eq!( + buffer_state_snapshot.status, + BufferStatus::new(buffer), + "stale status for buffer {buffer_id:?}" + ); + status_counts.add(buffer_state_snapshot.status); + } + assert_eq!(snapshot.buffers.status_counts, status_counts); } } @@ -6354,15 +6448,15 @@ impl MultiBufferSnapshot { } pub fn is_dirty(&self) -> bool { - self.is_dirty + self.buffers.status_counts.dirty > 0 } pub fn has_deleted_file(&self) -> bool { - self.has_deleted_file + self.buffers.status_counts.deleted_file > 0 } pub fn has_conflict(&self) -> bool { - self.has_conflict + self.buffers.status_counts.conflict > 0 } pub fn has_diagnostics(&self) -> bool { diff --git a/crates/multi_buffer/src/multi_buffer_tests.rs b/crates/multi_buffer/src/multi_buffer_tests.rs index 08a5fcc9498..9753e4a6950 100644 --- a/crates/multi_buffer/src/multi_buffer_tests.rs +++ b/crates/multi_buffer/src/multi_buffer_tests.rs @@ -2,15 +2,17 @@ use super::*; use buffer_diff::{DiffHunkStatus, DiffHunkStatusKind}; use gpui::{App, Entity, TestAppContext}; use indoc::indoc; -use language::{Buffer, Rope}; +use language::{Buffer, DiskState, LocalFile, Rope}; use parking_lot::RwLock; use rand::prelude::*; -use settings::SettingsStore; +use settings::{SettingsStore, WorktreeId}; use std::env; +use std::path::PathBuf; use std::sync::Arc; use std::time::{Duration, Instant}; use util::RandomCharIter; -use util::rel_path::rel_path; +use util::paths::PathStyle; +use util::rel_path::{RelPath, rel_path}; use util::test::sample_text; #[gpui::test] @@ -856,6 +858,120 @@ fn test_excerpt_events(cx: &mut App) { assert_eq!(*follower_edit_event_count.read(), 5); } +#[gpui::test] +fn test_dirty_state_across_buffers(cx: &mut App) { + let buffers = (0..3) + .map(|_| cx.new(|cx| Buffer::local(sample_text(3, 3, 'a'), cx))) + .collect::>(); + let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite)); + multibuffer.update(cx, |multibuffer, cx| { + for (ix, buffer) in buffers.iter().enumerate() { + multibuffer.set_excerpts_for_path( + PathKey::sorted(ix as u64), + buffer.clone(), + [Point::zero()..Point::new(1, 0)], + 0, + cx, + ); + } + }); + let is_dirty = |cx: &App| multibuffer.read(cx).is_dirty(cx); + let edit = |buffer: &Entity, cx: &mut App| { + buffer.update(cx, |buffer, cx| buffer.edit([(0..0, "x")], None, cx)); + }; + assert!(!is_dirty(cx)); + + edit(&buffers[0], cx); + edit(&buffers[1], cx); + assert!(is_dirty(cx)); + buffers[0].update(cx, |buffer, cx| buffer.did_save(buffer.version(), None, cx)); + assert!(is_dirty(cx)); + buffers[1].update(cx, |buffer, cx| buffer.did_save(buffer.version(), None, cx)); + assert!(!is_dirty(cx)); + + edit(&buffers[2], cx); + assert!(is_dirty(cx)); + buffers[2].update(cx, |buffer, cx| { + buffer.did_reload(buffer.version(), buffer.line_ending(), None, cx) + }); + assert!(!is_dirty(cx)); + + edit(&buffers[1], cx); + assert!(is_dirty(cx)); + buffers[1].update(cx, |buffer, cx| { + buffer.set_capability(Capability::ReadOnly, cx) + }); + assert!(!is_dirty(cx)); + buffers[1].update(cx, |buffer, cx| { + buffer.set_capability(Capability::ReadWrite, cx) + }); + assert!(is_dirty(cx)); + + multibuffer.update(cx, |multibuffer, cx| { + multibuffer.remove_excerpts(PathKey::sorted(1), cx); + }); + assert!(!is_dirty(cx)); +} + +#[gpui::test] +fn test_deleted_file_and_conflict_state_across_buffers(cx: &mut App) { + let buffers = (0..2) + .map(|_| cx.new(|cx| Buffer::local(sample_text(3, 3, 'a'), cx))) + .collect::>(); + let multibuffer = cx.new(|_| MultiBuffer::new(Capability::ReadWrite)); + multibuffer.update(cx, |multibuffer, cx| { + for (ix, buffer) in buffers.iter().enumerate() { + multibuffer.set_excerpts_for_path( + PathKey::sorted(ix as u64), + buffer.clone(), + [Point::zero()..Point::new(1, 0)], + 0, + cx, + ); + } + }); + let has_deleted_file = |cx: &App| multibuffer.read(cx).has_deleted_file(cx); + let has_conflict = |cx: &App| multibuffer.read(cx).has_conflict(cx); + let set_disk_state = |buffer: &Entity, disk_state: DiskState, cx: &mut App| { + let file = Arc::new(TestFile { + path: rel_path("file").into_arc(), + disk_state, + }); + buffer.update(cx, |buffer, cx| buffer.file_updated(file, cx)); + }; + + set_disk_state(&buffers[0], DiskState::Deleted, cx); + set_disk_state(&buffers[1], DiskState::Deleted, cx); + assert!(has_deleted_file(cx)); + set_disk_state(&buffers[0], DiskState::New, cx); + assert!(has_deleted_file(cx)); + set_disk_state(&buffers[1], DiskState::New, cx); + assert!(!has_deleted_file(cx)); + + buffers[0].update(cx, |buffer, _| buffer.set_conflict()); + buffers[1].update(cx, |buffer, _| buffer.set_conflict()); + assert!(has_conflict(cx)); + buffers[0].update(cx, |buffer, cx| buffer.did_save(buffer.version(), None, cx)); + assert!(has_conflict(cx)); + multibuffer.update(cx, |multibuffer, cx| { + multibuffer.remove_excerpts(PathKey::sorted(1), cx); + }); + assert!(!has_conflict(cx)); +} + +#[gpui::test] +fn test_clone_with_pending_changes(cx: &mut App) { + let buffer = cx.new(|cx| Buffer::local("abc", cx)); + let multibuffer = cx.new(|cx| MultiBuffer::singleton(buffer.clone(), cx)); + assert_eq!(multibuffer.read(cx).snapshot(cx).text(), "abc"); + + buffer.update(cx, |buffer, cx| buffer.edit([(0..0, "x")], None, cx)); + let cloned_multibuffer = + multibuffer.update(cx, |multibuffer, cx| cx.new(|cx| multibuffer.clone(cx))); + assert_eq!(cloned_multibuffer.read(cx).snapshot(cx).text(), "xabc"); + assert_eq!(multibuffer.read(cx).snapshot(cx).text(), "xabc"); +} + #[gpui::test] fn test_set_excerpts_for_path_reuses_excerpts_when_only_primary_changes(cx: &mut App) { let buffer = cx.new(|cx| Buffer::local(sample_text(10, 6, 'a'), cx)); @@ -7379,3 +7495,46 @@ enum AnchorContractOp { right: bool, }, } + +struct TestFile { + path: Arc, + disk_state: DiskState, +} + +impl File for TestFile { + fn as_local(&self) -> Option<&dyn LocalFile> { + None + } + + fn disk_state(&self) -> DiskState { + self.disk_state + } + + fn path(&self) -> &Arc { + &self.path + } + + fn full_path(&self, _: &App) -> PathBuf { + self.path.as_std_path().to_path_buf() + } + + fn path_style(&self, _: &App) -> PathStyle { + PathStyle::local() + } + + fn file_name<'a>(&'a self, _: &'a App) -> &'a str { + self.path.file_name().unwrap_or_default() + } + + fn worktree_id(&self, _: &App) -> WorktreeId { + WorktreeId::from_usize(0) + } + + fn to_proto(&self, _: &App) -> language::proto::File { + unimplemented!() + } + + fn is_private(&self) -> bool { + false + } +} diff --git a/crates/multi_buffer/src/path_key.rs b/crates/multi_buffer/src/path_key.rs index b5487719aff..6eed70806d3 100644 --- a/crates/multi_buffer/src/path_key.rs +++ b/crates/multi_buffer/src/path_key.rs @@ -10,9 +10,9 @@ use util::rel_path::RelPath; use ztracing::instrument; use crate::{ - Anchor, BufferState, BufferStateSnapshot, DiffChangeKind, Event, Excerpt, ExcerptOffset, - ExcerptRange, ExcerptSummary, ExpandExcerptDirection, MultiBuffer, MultiBufferOffset, - PathKeyIndex, build_excerpt_ranges, remove_diff_state, + Anchor, BufferState, BufferStateSnapshot, BufferStatus, DiffChangeKind, Event, Excerpt, + ExcerptOffset, ExcerptRange, ExcerptSummary, ExpandExcerptDirection, MultiBuffer, + MultiBufferOffset, PathKeyIndex, build_excerpt_ranges, remove_diff_state, }; #[derive(PartialEq, Eq, Ord, PartialOrd, Clone, Hash, Debug)] @@ -622,13 +622,14 @@ impl MultiBuffer { path_key: path_key.clone(), path_key_index, buffer_snapshot: buffer_snapshot.clone(), + status: BufferStatus::new(buffer.read(cx)), }, ); self.buffers.entry(buffer_id).or_insert_with(|| { - self.buffer_changed_since_sync.replace(true); + self.changed_buffers.borrow_mut().insert(buffer_id); buffer.update(cx, |buffer, _| { - buffer.record_changes(Rc::downgrade(&self.buffer_changed_since_sync)); + buffer.record_changes(Rc::downgrade(&self.changed_buffers)); }); BufferState { _subscriptions: [