Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

Refactor `BufferDiff` to allow multiple diffs to share the same base text buffer (#58266)

Cole Miller3df081249847
diff --git a/Cargo.lock b/Cargo.lock
index 829bb12da64..ab2c986115f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2440,7 +2440,6 @@ version = "0.1.0"
dependencies = [
"clock",
"ctor",
- "futures 0.3.32",
"gpui",
"imara-diff",
"language",
diff --git a/crates/acp_thread/src/diff.rs b/crates/acp_thread/src/diff.rs
index a6d3b86db7c..d297b5fa98f 100644
--- a/crates/acp_thread/src/diff.rs
+++ b/crates/acp_thread/src/diff.rs
@@ -24,6 +24,7 @@ impl Diff {
) -> Self {
let multibuffer = cx.new(|_cx| MultiBuffer::without_headers(Capability::ReadOnly));
let new_buffer = cx.new(|cx| Buffer::local(new_text, cx));
+ let base_text_exists = old_text.is_some();
let base_text = old_text.clone().unwrap_or(String::new()).into();
let task = cx.spawn({
let multibuffer = multibuffer.clone();
@@ -40,8 +41,8 @@ impl Diff {
let diff = build_buffer_diff(
old_text.unwrap_or("".into()).into(),
+ base_text_exists,
&buffer,
- Some(language_registry.clone()),
cx,
)
.await?;
@@ -88,16 +89,7 @@ impl Diff {
let language = buffer.read(cx).language().cloned();
let language_registry = buffer.read(cx).language_registry();
let buffer_diff = cx.new(|cx| {
- let mut diff = BufferDiff::new_unchanged(&buffer_text_snapshot, cx);
- diff.language_changed(language.clone(), language_registry.clone(), cx);
- let secondary_diff = cx.new(|cx| {
- // For the secondary diff buffer we skip assigning the language as we do not really need to perform any syntax highlighting on
- // it. As a result, by skipping it we are potentially shaving off a lot of RSS plus we get a snappier feel for large diff
- // view multibuffers.
- BufferDiff::new_unchanged(&buffer_text_snapshot, cx)
- });
- diff.set_secondary_diff(secondary_diff);
- diff
+ BufferDiff::new_unchanged(&buffer_text_snapshot, language, language_registry, cx)
});
let multibuffer = cx.new(|cx| {
@@ -233,28 +225,20 @@ impl PendingDiff {
let base_text = self.base_text.clone();
self.update_diff = cx.spawn(async move |diff, cx| {
let text_snapshot = buffer.read_with(cx, |buffer, _| buffer.text_snapshot());
- let language = buffer.read_with(cx, |buffer, _| buffer.language().cloned());
+ let base_text_snapshot = buffer_diff.read_with(cx, |diff, cx| diff.base_text(cx));
let update = buffer_diff
.update(cx, |diff, cx| {
diff.update_diff(
text_snapshot.clone(),
+ &base_text_snapshot,
Some(base_text.clone()),
- None,
- language,
cx,
)
})
.await;
- let (task1, task2) = buffer_diff.update(cx, |diff, cx| {
- let task1 = diff.set_snapshot(update.clone(), &text_snapshot, cx);
- let task2 = diff
- .secondary_diff()
- .unwrap()
- .update(cx, |diff, cx| diff.set_snapshot(update, &text_snapshot, cx));
- (task1, task2)
+ buffer_diff.update(cx, |diff, cx| {
+ diff.set_snapshot(update.clone(), cx);
});
- task1.await;
- task2.await;
diff.update(cx, |diff, cx| {
if let Diff::Pending(diff) = diff {
diff.update_visible_ranges(cx);
@@ -272,7 +256,6 @@ impl PendingDiff {
let ranges = self.excerpt_ranges(cx);
let base_text = self.base_text.clone();
let new_buffer = self.new_buffer.read(cx);
- let language_registry = new_buffer.language_registry();
let path = new_buffer
.file()
@@ -299,7 +282,7 @@ impl PendingDiff {
let buffer = buffer.clone();
async move |_this, cx| {
buffer.update(cx, |buffer, _| buffer.parsing_idle()).await;
- build_buffer_diff(base_text, &buffer, language_registry, cx).await
+ build_buffer_diff(base_text, true, &buffer, cx).await
}
});
@@ -397,39 +380,18 @@ pub struct FinalizedDiff {
async fn build_buffer_diff(
old_text: Arc<str>,
+ base_text_exists: bool,
buffer: &Entity<Buffer>,
- language_registry: Option<Arc<LanguageRegistry>>,
cx: &mut AsyncApp,
) -> Result<Entity<BufferDiff>> {
let language = cx.update(|cx| buffer.read(cx).language().cloned());
- let text_snapshot = cx.update(|cx| buffer.read(cx).text_snapshot());
+ let language_registry = cx.update(|cx| buffer.read(cx).language_registry());
let buffer = cx.update(|cx| buffer.read(cx).snapshot());
+ let base_text = base_text_exists.then(|| old_text);
- let secondary_diff = cx.new(|cx| BufferDiff::new(&buffer, cx));
-
- let update = secondary_diff
- .update(cx, |secondary_diff, cx| {
- secondary_diff.update_diff(
- text_snapshot.clone(),
- Some(old_text),
- Some(false),
- language.clone(),
- cx,
- )
- })
- .await;
-
- secondary_diff
- .update(cx, |secondary_diff, cx| {
- secondary_diff.set_snapshot(update.clone(), &buffer, cx)
- })
- .await;
-
- let diff = cx.new(|cx| BufferDiff::new(&buffer, cx));
+ let diff = cx.new(|cx| BufferDiff::new(&buffer, language, language_registry, cx));
diff.update(cx, |diff, cx| {
- diff.language_changed(language, language_registry, cx);
- diff.set_secondary_diff(secondary_diff);
- diff.set_snapshot(update.clone(), &buffer, cx)
+ diff.set_base_text(base_text, buffer.text, cx)
})
.await;
Ok(diff)
diff --git a/crates/action_log/src/action_log.rs b/crates/action_log/src/action_log.rs
index 99cc0a2d79b..f8b15f621e9 100644
--- a/crates/action_log/src/action_log.rs
+++ b/crates/action_log/src/action_log.rs
@@ -159,11 +159,8 @@ impl ActionLog {
let text_snapshot = buffer.read(cx).text_snapshot();
let language = buffer.read(cx).language().cloned();
let language_registry = buffer.read(cx).language_registry();
- let diff = cx.new(|cx| {
- let mut diff = BufferDiff::new(&text_snapshot, cx);
- diff.language_changed(language, language_registry, cx);
- diff
- });
+ let diff =
+ cx.new(|cx| BufferDiff::new(&text_snapshot, language, language_registry, cx));
let (diff_update_tx, diff_update_rx) = mpsc::unbounded();
let diff_base;
let unreviewed_edits;
@@ -465,29 +462,15 @@ impl ActionLog {
new_diff_base: Rope,
cx: &mut AsyncApp,
) -> Result<()> {
- let (diff, language) = this.read_with(cx, |this, cx| {
+ let diff = this.read_with(cx, |this, _cx| {
let tracked_buffer = this
.tracked_buffers
.get(buffer)
.context("buffer not tracked")?;
- anyhow::Ok((
- tracked_buffer.diff.clone(),
- buffer.read(cx).language().cloned(),
- ))
+ anyhow::Ok(tracked_buffer.diff.clone())
})??;
- let update = diff
- .update(cx, |diff, cx| {
- diff.update_diff(
- buffer_snapshot.clone(),
- Some(new_base_text),
- Some(true),
- language,
- cx,
- )
- })
- .await;
diff.update(cx, |diff, cx| {
- diff.set_snapshot(update.clone(), &buffer_snapshot, cx)
+ diff.set_base_text(Some(new_base_text), buffer_snapshot.clone(), cx)
})
.await;
let diff_snapshot = diff.update(cx, |diff, cx| diff.snapshot(cx));
diff --git a/crates/agent_ui/src/agent_diff.rs b/crates/agent_ui/src/agent_diff.rs
index 9a820db7b20..a4ae164c51f 100644
--- a/crates/agent_ui/src/agent_diff.rs
+++ b/crates/agent_ui/src/agent_diff.rs
@@ -102,6 +102,7 @@ impl AgentDiffPane {
);
diff_display_editor
.set_render_diff_hunk_controls(diff_hunk_controls(&thread, workspace.clone()), cx);
+ diff_display_editor.set_render_diff_hunks_as_unstaged(cx);
diff_display_editor.update_editors(cx, |editor, _cx| {
editor.register_addon(AgentDiffAddon);
});
@@ -1572,6 +1573,7 @@ impl AgentDiff {
diff_hunk_controls(&thread, workspace.clone()),
cx,
);
+ editor.set_render_diff_hunks_as_unstaged(true, cx);
editor.set_expand_all_diff_hunks(cx);
editor.register_addon(EditorAgentDiffAddon);
});
diff --git a/crates/agent_ui/src/entry_view_state.rs b/crates/agent_ui/src/entry_view_state.rs
index 48747f9cb33..68627d1ec87 100644
--- a/crates/agent_ui/src/entry_view_state.rs
+++ b/crates/agent_ui/src/entry_view_state.rs
@@ -470,6 +470,7 @@ fn create_editor_diff(
editor.set_show_code_actions(false, cx);
editor.set_show_git_diff_gutter(false, cx);
editor.set_expand_all_diff_hunks(cx);
+ editor.set_render_diff_hunks_as_unstaged(true, cx);
editor.set_text_style_refinement(diff_editor_text_style_refinement(cx));
editor
})
diff --git a/crates/buffer_diff/Cargo.toml b/crates/buffer_diff/Cargo.toml
index d574b0dd3cf..4bcdd3422ec 100644
--- a/crates/buffer_diff/Cargo.toml
+++ b/crates/buffer_diff/Cargo.toml
@@ -16,7 +16,6 @@ test-support = ["settings"]
[dependencies]
clock.workspace = true
-futures.workspace = true
imara-diff.workspace = true
gpui.workspace = true
language.workspace = true
diff --git a/crates/buffer_diff/src/buffer_diff.rs b/crates/buffer_diff/src/buffer_diff.rs
index cc89f8c314d..c300ace11ae 100644
--- a/crates/buffer_diff/src/buffer_diff.rs
+++ b/crates/buffer_diff/src/buffer_diff.rs
@@ -1,14 +1,12 @@
-use futures::channel::oneshot;
use gpui::{App, AppContext as _, Context, Entity, EventEmitter, Task};
use imara_diff::{Algorithm, Sink, intern::InternedInput, sources::lines_with_terminator};
use language::{
- Capability, Diff, DiffOptions, Language, LanguageName, LanguageRegistry,
+ Capability, DiffOptions, Language, LanguageName, LanguageRegistry,
language_settings::LanguageSettings, word_diff_ranges,
};
use rope::Rope;
use std::{
cmp::Ordering,
- future::Future,
iter,
ops::{Range, RangeInclusive},
sync::Arc,
@@ -17,26 +15,33 @@ use sum_tree::SumTree;
use text::{
Anchor, Bias, BufferId, Edit, OffsetRangeExt, Patch, Point, ToOffset as _, ToPoint as _,
};
-use util::ResultExt;
+use util::{ResultExt, debug_panic};
pub const MAX_WORD_DIFF_LINE_COUNT: usize = 5;
pub struct BufferDiff {
pub buffer_id: BufferId,
- inner: BufferDiffInner<Entity<language::Buffer>>,
+ base_text_buffer: Entity<language::Buffer>,
+ diff_snapshot: Option<BufferDiffSnapshot>,
secondary_diff: Option<Entity<BufferDiff>>,
+ buffer_snapshot: text::BufferSnapshot,
}
#[derive(Clone)]
pub struct BufferDiffSnapshot {
- inner: BufferDiffInner<language::BufferSnapshot>,
+ hunks: SumTree<InternalDiffHunk>,
+ pending_hunks: SumTree<PendingHunk>,
+ base_text: language::BufferSnapshot,
+ base_text_exists: bool,
+ buffer_snapshot: text::BufferSnapshot,
secondary_diff: Option<Arc<BufferDiffSnapshot>>,
}
impl std::fmt::Debug for BufferDiffSnapshot {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("BufferDiffSnapshot")
- .field("inner", &self.inner)
+ .field("hunks", &self.hunks)
+ .field("remote_id", &self.base_text.remote_id())
.field("secondary_diff", &self.secondary_diff)
.finish()
}
@@ -44,24 +49,20 @@ impl std::fmt::Debug for BufferDiffSnapshot {
#[derive(Clone)]
pub struct BufferDiffUpdate {
- inner: BufferDiffInner<Arc<str>>,
- buffer_snapshot: text::BufferSnapshot,
- base_text_edits: Option<Diff>,
- base_text_changed: bool,
-}
-
-#[derive(Clone)]
-struct BufferDiffInner<BaseText> {
hunks: SumTree<InternalDiffHunk>,
- pending_hunks: SumTree<PendingHunk>,
- base_text: BaseText,
+ base_text: language::BufferSnapshot,
base_text_exists: bool,
buffer_snapshot: text::BufferSnapshot,
}
-impl<BaseText> BufferDiffInner<BaseText> {
- fn buffer_version(&self) -> &clock::Global {
- self.buffer_snapshot.version()
+impl BufferDiffUpdate {
+ pub fn set_base_text_snapshot(
+ &mut self,
+ base_text: language::BufferSnapshot,
+ base_text_exists: bool,
+ ) {
+ self.base_text = base_text;
+ self.base_text_exists = base_text_exists;
}
}
@@ -228,15 +229,6 @@ impl sum_tree::SeekTarget<'_, DiffHunkSummary, DiffHunkSummary> for usize {
}
}
-impl std::fmt::Debug for BufferDiffInner<language::BufferSnapshot> {
- fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
- f.debug_struct("BufferDiffSnapshot")
- .field("hunks", &self.hunks)
- .field("remote_id", &self.base_text.remote_id())
- .finish()
- }
-}
-
impl BufferDiffSnapshot {
#[cfg(test)]
fn new_sync(
@@ -249,26 +241,28 @@ impl BufferDiffSnapshot {
}
pub fn buffer_id(&self) -> BufferId {
- self.inner.buffer_snapshot.remote_id()
+ self.buffer_snapshot.remote_id()
+ }
+
+ pub fn buffer_snapshot(&self) -> &text::BufferSnapshot {
+ &self.buffer_snapshot
}
pub fn is_empty(&self) -> bool {
- self.inner.hunks.is_empty()
+ self.hunks.is_empty()
}
pub fn changed_row_counts(&self) -> (u32, u32) {
- let summary = self.inner.hunks.summary();
+ let summary = self.hunks.summary();
(summary.added_rows, summary.removed_rows)
}
pub fn base_text_string(&self) -> Option<String> {
- self.inner
- .base_text_exists
- .then(|| self.inner.base_text.text())
+ self.base_text_exists.then(|| self.base_text.text())
}
pub fn base_text_exists(&self) -> bool {
- self.inner.base_text_exists
+ self.base_text_exists
}
pub fn secondary_diff(&self) -> Option<&BufferDiffSnapshot> {
@@ -276,11 +270,11 @@ impl BufferDiffSnapshot {
}
pub fn buffer_version(&self) -> &clock::Global {
- self.inner.buffer_version()
+ self.buffer_snapshot.version()
}
fn original_buffer_snapshot(&self) -> &text::BufferSnapshot {
- &self.inner.buffer_snapshot
+ &self.buffer_snapshot
}
#[ztracing::instrument(skip_all)]
@@ -289,9 +283,15 @@ impl BufferDiffSnapshot {
range: Range<Anchor>,
buffer: &'a text::BufferSnapshot,
) -> impl 'a + Iterator<Item = DiffHunk> {
- let unstaged_counterpart = self.secondary_diff.as_ref().map(|diff| &diff.inner);
- self.inner
- .hunks_intersecting_range(range, buffer, unstaged_counterpart)
+ let unstaged_counterpart = self.secondary_diff.as_deref();
+ let range = range.to_offset(buffer);
+ let filter = move |summary: &DiffHunkSummary| {
+ let summary_range = summary.buffer_range.to_offset(buffer);
+ let before_start = summary_range.end < range.start;
+ let after_end = summary_range.start > range.end;
+ !before_start && !after_end
+ };
+ self.hunks_intersecting_range_impl(filter, buffer, unstaged_counterpart)
}
pub fn hunks_intersecting_range_rev<'a>(
@@ -304,7 +304,7 @@ impl BufferDiffSnapshot {
let after_end = summary.buffer_range.start.cmp(&range.end, buffer).is_gt();
!before_start && !after_end
};
- self.inner.hunks_intersecting_range_rev_impl(filter, buffer)
+ self.hunks_intersecting_range_rev_impl(filter, buffer)
}
pub fn hunks_intersecting_base_text_range<'a>(
@@ -312,14 +312,13 @@ impl BufferDiffSnapshot {
range: Range<usize>,
main_buffer: &'a text::BufferSnapshot,
) -> impl 'a + Iterator<Item = DiffHunk> {
- let unstaged_counterpart = self.secondary_diff.as_ref().map(|diff| &diff.inner);
+ let unstaged_counterpart = self.secondary_diff.as_deref();
let filter = move |summary: &DiffHunkSummary| {
let before_start = summary.diff_base_byte_range.end < range.start;
let after_end = summary.diff_base_byte_range.start > range.end;
!before_start && !after_end
};
- self.inner
- .hunks_intersecting_range_impl(filter, main_buffer, unstaged_counterpart)
+ self.hunks_intersecting_range_impl(filter, main_buffer, unstaged_counterpart)
}
pub fn hunks_intersecting_base_text_range_rev<'a>(
@@ -332,8 +331,7 @@ impl BufferDiffSnapshot {
let after_end = summary.diff_base_byte_range.start.cmp(&range.end).is_gt();
!before_start && !after_end
};
- self.inner
- .hunks_intersecting_range_rev_impl(filter, main_buffer)
+ self.hunks_intersecting_range_rev_impl(filter, main_buffer)
}
pub fn hunks<'a>(
@@ -374,7 +372,7 @@ impl BufferDiffSnapshot {
}
pub fn base_text(&self) -> &language::BufferSnapshot {
- &self.inner.base_text
+ &self.base_text
}
/// If this function returns `true`, the base texts are equal. If this
@@ -382,11 +380,11 @@ impl BufferDiffSnapshot {
/// result is used to avoid recalculating diffs in situations where we know
/// nothing has changed.
pub fn base_texts_definitely_eq(&self, other: &Self) -> bool {
- if self.inner.base_text_exists != other.inner.base_text_exists {
+ if self.base_text_exists != other.base_text_exists {
return false;
}
- let left = &self.inner.base_text;
- let right = &other.inner.base_text;
+ let left = &self.base_text;
+ let right = &other.base_text;
let (old_id, old_version, old_empty) = (left.remote_id(), left.version(), left.is_empty());
let (new_id, new_version, new_empty) =
(right.remote_id(), right.version(), right.is_empty());
@@ -438,7 +436,7 @@ impl BufferDiffSnapshot {
range: RangeInclusive<Point>,
buffer: &'a text::BufferSnapshot,
) -> Patch<Point> {
- if !self.inner.base_text_exists {
+ if !self.base_text_exists {
return Patch::new(vec![Edit {
old: Point::zero()..buffer.max_point(),
new: Point::zero()..Point::zero(),
@@ -447,7 +445,7 @@ impl BufferDiffSnapshot {
let mut edits_since_diff = Patch::new(
buffer
- .edits_since::<Point>(&self.inner.buffer_snapshot.version)
+ .edits_since::<Point>(&self.buffer_snapshot.version)
.collect::<Vec<_>>(),
);
edits_since_diff.invert();
@@ -460,7 +458,7 @@ impl BufferDiffSnapshot {
let original_snapshot = self.original_buffer_snapshot();
let base_text = self.base_text();
- let mut cursor = self.inner.hunks.cursor(original_snapshot);
+ let mut cursor = self.hunks.cursor(original_snapshot);
self.hunk_before_buffer_anchor(
original_snapshot.anchor_before(start_point),
&mut cursor,
@@ -519,8 +517,7 @@ impl BufferDiffSnapshot {
inverted_edits_since.invert();
inverted_edits_since.compose(
- self.inner
- .hunks
+ self.hunks
.iter()
.map(|hunk| {
let old_start = hunk.buffer_range.start.to_point(original_snapshot);
@@ -536,16 +533,14 @@ impl BufferDiffSnapshot {
new: new_start..new_end,
}
})
- .chain(
- if !self.inner.base_text_exists && self.inner.hunks.is_empty() {
- Some(Edit {
- old: Point::zero()..original_snapshot.max_point(),
- new: Point::zero()..Point::zero(),
- })
- } else {
- None
- },
- ),
+ .chain(if !self.base_text_exists && self.hunks.is_empty() {
+ Some(Edit {
+ old: Point::zero()..original_snapshot.max_point(),
+ new: Point::zero()..Point::zero(),
+ })
+ } else {
+ None
+ }),
)
}
@@ -558,7 +553,7 @@ impl BufferDiffSnapshot {
range: RangeInclusive<Point>,
buffer: &'a text::BufferSnapshot,
) -> Patch<Point> {
- if !self.inner.base_text_exists {
+ if !self.base_text_exists {
return Patch::new(vec![Edit {
old: Point::zero()..Point::zero(),
new: Point::zero()..buffer.max_point(),
@@ -566,11 +561,11 @@ impl BufferDiffSnapshot {
}
let edits_since_diff = buffer
- .edits_since::<Point>(&self.inner.buffer_snapshot.version)
+ .edits_since::<Point>(&self.buffer_snapshot.version)
.collect::<Vec<_>>();
let mut hunk_patch = Vec::new();
- let mut cursor = self.inner.hunks.cursor(self.original_buffer_snapshot());
+ let mut cursor = self.hunks.cursor(self.original_buffer_snapshot());
let hunk_before = self
.hunk_before_base_text_offset(range.start().to_offset(self.base_text()), &mut cursor);
@@ -635,7 +630,7 @@ impl BufferDiffSnapshot {
let original_snapshot = self.original_buffer_snapshot();
let mut hunk_edits: Vec<Edit<Point>> = Vec::new();
- for hunk in self.inner.hunks.iter() {
+ for hunk in self.hunks.iter() {
let old_start = self
.base_text()
.offset_to_point(hunk.diff_base_byte_range.start);
@@ -649,7 +644,7 @@ impl BufferDiffSnapshot {
new: new_start..new_end,
});
}
- if !self.inner.base_text_exists && hunk_edits.is_empty() {
+ if !self.base_text_exists && hunk_edits.is_empty() {
hunk_edits.push(Edit {
old: Point::zero()..Point::zero(),
new: Point::zero()..original_snapshot.max_point(),
@@ -709,8 +704,7 @@ impl BufferDiffSnapshot {
}
}
-impl BufferDiffInner<Entity<language::Buffer>> {
- /// Returns the new index text and new pending hunks.
+impl BufferDiffSnapshot {
fn stage_or_unstage_hunks_impl(
&mut self,
unstaged_diff: &Self,
@@ -718,14 +712,13 @@ impl BufferDiffInner<Entity<language::Buffer>> {
hunks: &[DiffHunk],
buffer: &text::BufferSnapshot,
file_exists: bool,
- cx: &mut Context<BufferDiff>,
) -> Option<Rope> {
let head_text = self
.base_text_exists
- .then(|| self.base_text.read(cx).as_rope().clone());
+ .then(|| self.base_text.as_rope().clone());
let index_text = unstaged_diff
.base_text_exists
- .then(|| unstaged_diff.base_text.read(cx).as_rope().clone());
+ .then(|| unstaged_diff.base_text.as_rope().clone());
// If the file doesn't exist in either HEAD or the index, then the
// entire file must be either created or deleted in the index.
@@ -932,23 +925,7 @@ impl BufferDiffInner<Entity<language::Buffer>> {
}
}
-impl BufferDiffInner<language::BufferSnapshot> {
- fn hunks_intersecting_range<'a>(
- &'a self,
- range: Range<Anchor>,
- buffer: &'a text::BufferSnapshot,
- secondary: Option<&'a Self>,
- ) -> impl 'a + Iterator<Item = DiffHunk> {
- let range = range.to_offset(buffer);
- let filter = move |summary: &DiffHunkSummary| {
- let summary_range = summary.buffer_range.to_offset(buffer);
- let before_start = summary_range.end < range.start;
- let after_end = summary_range.start > range.end;
- !before_start && !after_end
- };
- self.hunks_intersecting_range_impl(filter, buffer, secondary)
- }
-
+impl BufferDiffSnapshot {
fn hunks_intersecting_range_impl<'a>(
&'a self,
filter: impl 'a + Fn(&DiffHunkSummary) -> bool,
@@ -1473,6 +1450,7 @@ fn compare_hunks(
changed_range,
base_text_changed_range,
extended_range,
+ base_text_changed: false,
}
}
@@ -1489,61 +1467,91 @@ pub struct DiffChanged {
pub changed_range: Option<Range<text::Anchor>>,
pub base_text_changed_range: Option<Range<usize>>,
pub extended_range: Option<Range<text::Anchor>>,
+ pub base_text_changed: bool,
}
#[derive(Clone, Debug)]
pub enum BufferDiffEvent {
BaseTextChanged,
DiffChanged(DiffChanged),
- LanguageChanged,
HunksStagedOrUnstaged(Option<Rope>),
}
-struct SetSnapshotResult {
- change: DiffChanged,
- base_text_changed: bool,
-}
-
impl EventEmitter<BufferDiffEvent> for BufferDiff {}
impl BufferDiff {
- pub fn new(buffer: &text::BufferSnapshot, cx: &mut App) -> Self {
+ pub fn new(
+ buffer: &text::BufferSnapshot,
+ language: Option<Arc<Language>>,
+ language_registry: Option<Arc<LanguageRegistry>>,
+ cx: &mut App,
+ ) -> Self {
let base_text = cx.new(|cx| {
- let mut buffer = language::Buffer::local("", cx);
- buffer.set_capability(Capability::ReadOnly, cx);
- buffer
+ let mut base_buffer = language::Buffer::local("", cx);
+ base_buffer.set_capability(Capability::ReadOnly, cx);
+ if let Some(language_registry) = language_registry {
+ base_buffer.set_language_registry(language_registry);
+ }
+ base_buffer.set_language_async(language, cx);
+ base_buffer
});
BufferDiff {
buffer_id: buffer.remote_id(),
- inner: BufferDiffInner {
- base_text,
- hunks: SumTree::new(buffer),
- pending_hunks: SumTree::new(buffer),
- base_text_exists: false,
- buffer_snapshot: buffer.clone(),
- },
+ base_text_buffer: base_text,
+ diff_snapshot: None,
+ buffer_snapshot: buffer.clone(),
+ secondary_diff: None,
+ }
+ }
+
+ pub fn new_with_base_text_buffer(
+ buffer: &text::BufferSnapshot,
+ base_text_buffer: Entity<language::Buffer>,
+ _cx: &mut App,
+ ) -> Self {
+ BufferDiff {
+ buffer_id: buffer.remote_id(),
+ base_text_buffer,
+ diff_snapshot: None,
+ buffer_snapshot: buffer.clone(),
secondary_diff: None,
}
}
- pub fn new_unchanged(buffer: &text::BufferSnapshot, cx: &mut Context<Self>) -> Self {
+ pub fn new_unchanged(
+ buffer: &text::BufferSnapshot,
+ language: Option<Arc<Language>>,
+ language_registry: Option<Arc<LanguageRegistry>>,
+ cx: &mut Context<Self>,
+ ) -> Self {
let base_text = buffer.text();
let base_text = cx.new(|cx| {
- let mut buffer = language::Buffer::local(base_text, cx);
- buffer.set_capability(Capability::ReadOnly, cx);
- buffer
+ let mut base_buffer = language::Buffer::local(base_text, cx);
+ base_buffer.set_capability(Capability::ReadOnly, cx);
+ if let Some(language_registry) = language_registry {
+ base_buffer.set_language_registry(language_registry);
+ }
+ base_buffer.set_language_async(language, cx);
+ base_buffer
});
+ let base_text_snapshot = base_text.read(cx).snapshot();
+
+ let diff_snapshot = BufferDiffSnapshot {
+ hunks: SumTree::new(buffer),
+ pending_hunks: SumTree::new(buffer),
+ base_text: base_text_snapshot,
+ base_text_exists: true,
+ buffer_snapshot: buffer.clone(),
+ secondary_diff: None,
+ };
+
BufferDiff {
buffer_id: buffer.remote_id(),
- inner: BufferDiffInner {
- base_text,
- hunks: SumTree::new(buffer),
- pending_hunks: SumTree::new(buffer),
- base_text_exists: true,
- buffer_snapshot: buffer.clone(),
- },
+ base_text_buffer: base_text,
+ diff_snapshot: Some(diff_snapshot),
+ buffer_snapshot: buffer.clone(),
secondary_diff: None,
}
}
@@ -1554,17 +1562,23 @@ impl BufferDiff {
buffer: &text::BufferSnapshot,
cx: &mut Context<Self>,
) -> Self {
- let mut this = BufferDiff::new(&buffer, cx);
+ let mut this = BufferDiff::new(buffer, None, None, cx);
let mut base_text = base_text.to_owned();
text::LineEnding::normalize(&mut base_text);
- let inner = cx.foreground_executor().block_on(this.update_diff(
+ let base_text_buffer = cx.new(|cx| {
+ let mut buffer = language::Buffer::local(base_text, cx);
+ buffer.set_capability(Capability::ReadOnly, cx);
+ buffer
+ });
+ let base_text = base_text_buffer.read(cx).snapshot();
+ this.base_text_buffer = base_text_buffer;
+ let update = cx.foreground_executor().block_on(this.update_diff(
buffer.clone(),
- Some(Arc::from(base_text)),
- Some(false),
- None,
+ &base_text,
+ Some(Arc::from(base_text.text())),
cx,
));
- this.set_snapshot(inner, &buffer, cx).detach();
+ this.set_snapshot(update, cx);
this
}
@@ -1577,8 +1591,11 @@ impl BufferDiff {
}
pub fn clear_pending_hunks(&mut self, cx: &mut Context<Self>) {
+ let Some(diff_snapshot) = &mut self.diff_snapshot else {
+ return;
+ };
if self.secondary_diff.is_some() {
- self.inner.pending_hunks = SumTree::from_summary(DiffHunkSummary {
+ diff_snapshot.pending_hunks = SumTree::from_summary(DiffHunkSummary {
buffer_range: Anchor::min_min_range_for_buffer(self.buffer_id),
diff_base_byte_range: 0..0,
added_rows: 0,
@@ -1590,6 +1607,7 @@ impl BufferDiff {
changed_range: changed_range.clone(),
base_text_changed_range: base_text_range,
extended_range: changed_range,
+ base_text_changed: false,
}));
}
}
@@ -1602,19 +1620,18 @@ impl BufferDiff {
file_exists: bool,
cx: &mut Context<Self>,
) -> Option<Rope> {
- let new_index_text = self
- .secondary_diff
- .as_ref()?
- .update(cx, |secondary_diff, cx| {
- self.inner.stage_or_unstage_hunks_impl(
- &secondary_diff.inner,
- stage,
- hunks,
- buffer,
- file_exists,
- cx,
- )
- });
+ let secondary_diff = self.secondary_diff.clone()?;
+ let diff_snapshot = self.diff_snapshot.as_mut()?;
+ let unstaged_diff_snapshot = secondary_diff.read_with(cx, |secondary_diff, _cx| {
+ secondary_diff.diff_snapshot.clone()
+ })?;
+ let new_index_text = diff_snapshot.stage_or_unstage_hunks_impl(
+ &unstaged_diff_snapshot,
+ stage,
+ hunks,
+ buffer,
+ file_exists,
+ );
cx.emit(BufferDiffEvent::HunksStagedOrUnstaged(
new_index_text.clone(),
@@ -1627,6 +1644,7 @@ impl BufferDiff {
changed_range: changed_range.clone(),
base_text_changed_range,
extended_range: changed_range,
+ base_text_changed: false,
}));
}
new_index_text
@@ -1643,12 +1661,23 @@ impl BufferDiff {
.snapshot(cx)
.hunks_intersecting_range(Anchor::min_max_range_for_buffer(buffer.remote_id()), buffer)
.collect::<Vec<_>>();
+ let Some(diff_snapshot) = &mut self.diff_snapshot else {
+ return;
+ };
let Some(secondary) = self.secondary_diff.clone() else {
return;
};
- let secondary = secondary.read(cx).inner.clone();
- self.inner
- .stage_or_unstage_hunks_impl(&secondary, stage, &hunks, buffer, file_exists, cx);
+ let secondary = secondary.read(cx);
+ let Some(secondary_snapshot) = &secondary.diff_snapshot else {
+ return;
+ };
+ diff_snapshot.stage_or_unstage_hunks_impl(
+ &secondary_snapshot,
+ stage,
+ &hunks,
+ buffer,
+ file_exists,
+ );
if let Some((first, last)) = hunks.first().zip(hunks.last()) {
let changed_range = Some(first.buffer_range.start..last.buffer_range.end);
let base_text_changed_range =
@@ -1657,6 +1686,7 @@ impl BufferDiff {
changed_range: changed_range.clone(),
base_text_changed_range,
extended_range: changed_range,
+ base_text_changed: false,
}));
}
}
@@ -1664,172 +1694,139 @@ impl BufferDiff {
pub fn update_diff(
&self,
buffer: text::BufferSnapshot,
+ base_text_snapshot: &language::BufferSnapshot,
base_text: Option<Arc<str>>,
- base_text_change: Option<bool>,
- language: Option<Arc<Language>>,
cx: &App,
) -> Task<BufferDiffUpdate> {
let base_text = base_text.map(|t| text::LineEnding::normalize_arc(t));
- let prev_base_text = self.base_text(cx).as_rope().clone();
- let base_text_changed = base_text_change.is_some();
- let compute_base_text_edits = base_text_change == Some(true);
+ debug_assert_eq!(
+ base_text.as_deref().unwrap_or_default(),
+ &base_text_snapshot.text()
+ );
+ debug_assert_eq!(
+ base_text_snapshot.remote_id(),
+ self.base_text_buffer.read(cx).remote_id()
+ );
+
+ let language = base_text_snapshot.language();
let diff_options = build_diff_options(
- language.as_ref().map(|l| l.name()),
- language.as_ref().map(|l| l.default_scope()),
+ language.map(|l| l.name()),
+ language.map(|l| l.default_scope()),
cx,
);
let buffer_snapshot = buffer.clone();
-
- let base_text_diff_task = if base_text_changed && compute_base_text_edits {
- base_text
- .as_ref()
- .map(|new_text| self.inner.base_text.read(cx).diff(new_text.clone(), cx))
- } else {
- None
- };
-
- let hunk_task = cx.background_executor().spawn({
- let buffer_snapshot = buffer_snapshot.clone();
- async move {
- let base_text_rope = if let Some(base_text) = &base_text {
- if base_text_changed {
- Rope::from(base_text.as_ref())
- } else {
- prev_base_text
- }
- } else {
- Rope::new()
- };
- let base_text_exists = base_text.is_some();
- let hunks = compute_hunks(
- base_text
- .clone()
- .map(|base_text| (base_text, base_text_rope.clone())),
- &buffer,
- diff_options,
- );
- let base_text = base_text.unwrap_or_default();
- BufferDiffInner {
- base_text,
- hunks,
- base_text_exists,
- pending_hunks: SumTree::new(&buffer),
- buffer_snapshot,
- }
+ let base_text_snapshot = base_text_snapshot.clone();
+ let base_text_exists = base_text.is_some();
+ let unchanged_hunks = self.diff_snapshot.as_ref().and_then(|diff_snapshot| {
+ if diff_snapshot.base_text_exists == base_text_exists
+ && diff_snapshot.base_text.version() == base_text_snapshot.version()
+ && diff_snapshot.buffer_snapshot.version() == buffer_snapshot.version()
+ {
+ Some(diff_snapshot.hunks.clone())
+ } else {
+ None
}
});
cx.background_executor().spawn(async move {
- let (inner, base_text_edits) = match base_text_diff_task {
- Some(diff_task) => {
- let (inner, diff) = futures::join!(hunk_task, diff_task);
- (inner, Some(diff))
- }
- None => (hunk_task.await, None),
+ let hunks = if let Some(unchanged_hunks) = unchanged_hunks {
+ unchanged_hunks
+ } else if let Some(base_text) = base_text {
+ compute_hunks(
+ Some((base_text, base_text_snapshot.as_rope().clone())),
+ &buffer,
+ diff_options,
+ )
+ } else {
+ compute_hunks(None, &buffer, diff_options)
};
BufferDiffUpdate {
- inner,
+ hunks,
+ base_text: base_text_snapshot,
+ base_text_exists,
buffer_snapshot,
- base_text_edits,
- base_text_changed,
}
})
}
- #[ztracing::instrument(skip_all)]
- pub fn language_changed(
- &mut self,
- language: Option<Arc<Language>>,
- language_registry: Option<Arc<LanguageRegistry>>,
- cx: &mut Context<Self>,
- ) {
- let fut = self.inner.base_text.update(cx, |base_text, cx| {
- if let Some(language_registry) = language_registry {
- base_text.set_language_registry(language_registry);
- }
- base_text.set_language_async(language, cx);
- base_text.parsing_idle()
- });
- cx.spawn(async move |this, cx| {
- fut.await;
- this.update(cx, |_, cx| {
- cx.emit(BufferDiffEvent::LanguageChanged);
- })
- .ok();
- })
- .detach();
- }
-
- fn set_snapshot_with_secondary_inner(
+ pub fn set_snapshot_with_secondary(
&mut self,
update: BufferDiffUpdate,
- buffer: &text::BufferSnapshot,
secondary_diff_change: Option<Range<Anchor>>,
clear_pending_hunks: bool,
cx: &mut Context<Self>,
- ) -> impl Future<Output = SetSnapshotResult> + use<> {
+ ) -> Option<Range<Anchor>> {
log::debug!("set snapshot with secondary {secondary_diff_change:?}");
- let old_snapshot = self.snapshot(cx);
- let new_state = update.inner;
- let base_text_changed = update.base_text_changed;
-
- let state = &mut self.inner;
- state.base_text_exists = new_state.base_text_exists;
- let should_compare_hunks = update.base_text_edits.is_some() || !base_text_changed;
- let parsing_idle = if let Some(diff) = update.base_text_edits {
- state.base_text.update(cx, |base_text, cx| {
- base_text.set_sync_parse_timeout(None);
- base_text.set_capability(Capability::ReadWrite, cx);
- base_text.apply_diff(diff, cx);
- base_text.set_capability(Capability::ReadOnly, cx);
- Some(base_text.parsing_idle())
- })
- } else if update.base_text_changed {
- state.base_text.update(cx, |base_text, cx| {
- base_text.set_sync_parse_timeout(None);
- base_text.set_capability(Capability::ReadWrite, cx);
- base_text.set_text(new_state.base_text.clone(), cx);
- base_text.set_capability(Capability::ReadOnly, cx);
- Some(base_text.parsing_idle())
- })
- } else {
- None
+ let BufferDiffUpdate {
+ hunks: new_hunks,
+ base_text: new_base_text,
+ base_text_exists: new_base_text_exists,
+ buffer_snapshot: new_buffer_snapshot,
+ } = update;
+ let buffer = &new_buffer_snapshot;
+ let old_snapshot = self
+ .diff_snapshot
+ .clone()
+ .unwrap_or_else(|| BufferDiffSnapshot {
+ hunks: SumTree::new(buffer),
+ pending_hunks: SumTree::new(buffer),
+ base_text: new_base_text.clone(),
+ base_text_exists: false,
+ buffer_snapshot: new_buffer_snapshot.clone(),
+ secondary_diff: None,
+ });
+ let mut new_snapshot = BufferDiffSnapshot {
+ hunks: new_hunks.clone(),
+ base_text: new_base_text.clone(),
+ base_text_exists: new_base_text_exists,
+ buffer_snapshot: new_buffer_snapshot.clone(),
+ pending_hunks: old_snapshot.pending_hunks.clone(),
+ secondary_diff: None,
};
- let old_buffer_snapshot = &old_snapshot.inner.buffer_snapshot;
- let old_base_snapshot = &old_snapshot.inner.base_text;
- let new_base_snapshot = state.base_text.read(cx).snapshot();
+ let old_base_text_exists = old_snapshot.base_text_exists;
+ let old_buffer_snapshot = &old_snapshot.buffer_snapshot;
+ let old_base_text = &old_snapshot.base_text;
+ let base_text_changed = old_base_text_exists != new_base_text_exists
+ || (new_base_text_exists
+ && (old_base_text.remote_id() != new_base_text.remote_id()
+ || new_base_text
+ .version()
+ .changed_since(old_base_text.version())));
let DiffChanged {
mut changed_range,
mut base_text_changed_range,
mut extended_range,
- } = match (state.base_text_exists, new_state.base_text_exists) {
- (false, false) => DiffChanged::default(),
- (true, true) if should_compare_hunks => compare_hunks(
- &new_state.hunks,
- &old_snapshot.inner.hunks,
+ base_text_changed: _,
+ } = match (old_base_text_exists, new_base_text_exists) {
+ (false, false) if self.diff_snapshot.is_some() => DiffChanged::default(),
+ (true, true) => compare_hunks(
+ &new_hunks,
+ &old_snapshot.hunks,
old_buffer_snapshot,
buffer,
- old_base_snapshot,
- &new_base_snapshot,
+ old_base_text,
+ &new_base_text,
),
_ => {
let full_range = text::Anchor::min_max_range_for_buffer(self.buffer_id);
- let full_base_range = 0..new_state.base_text.len();
+ let full_base_range = 0..new_base_text.len();
DiffChanged {
changed_range: Some(full_range.clone()),
base_text_changed_range: Some(full_base_range),
extended_range: Some(full_range),
+ base_text_changed: false,
}
}
};
- state.hunks = new_state.hunks;
- state.buffer_snapshot = update.buffer_snapshot;
if base_text_changed || clear_pending_hunks {
- if let Some((first, last)) = state.pending_hunks.first().zip(state.pending_hunks.last())
+ if let Some((first, last)) = old_snapshot
+ .pending_hunks
+ .first()
+ .zip(old_snapshot.pending_hunks.last())
{
let pending_range = first.buffer_range.start..last.buffer_range.end;
if let Some(range) = &mut changed_range {
@@ -1855,7 +1852,7 @@ impl BufferDiff {
extended_range = Some(pending_range);
}
}
- state.pending_hunks = SumTree::new(buffer);
+ new_snapshot.pending_hunks = SumTree::new(buffer);
}
if let Some(secondary_changed_range) = secondary_diff_change
@@ -1884,140 +1881,164 @@ impl BufferDiff {
}
}
- async move {
- if let Some(parsing_idle) = parsing_idle {
- parsing_idle.await;
- }
- SetSnapshotResult {
- change: DiffChanged {
- changed_range,
- base_text_changed_range,
- extended_range,
- },
- base_text_changed,
- }
+ self.diff_snapshot = Some(new_snapshot);
+ self.buffer_snapshot = new_buffer_snapshot;
+
+ let result = DiffChanged {
+ changed_range,
+ base_text_changed_range,
+ extended_range,
+ base_text_changed,
+ };
+ if result.base_text_changed {
+ cx.emit(BufferDiffEvent::BaseTextChanged);
}
+ let changed_range = result.changed_range.clone();
+ cx.emit(BufferDiffEvent::DiffChanged(result));
+ changed_range
}
pub fn set_snapshot(
&mut self,
new_state: BufferDiffUpdate,
- buffer: &text::BufferSnapshot,
cx: &mut Context<Self>,
- ) -> Task<Option<Range<Anchor>>> {
- self.set_snapshot_with_secondary(new_state, buffer, None, false, cx)
- }
-
- pub fn set_snapshot_with_secondary(
- &mut self,
- update: BufferDiffUpdate,
- buffer: &text::BufferSnapshot,
- secondary_diff_change: Option<Range<Anchor>>,
- clear_pending_hunks: bool,
- cx: &mut Context<Self>,
- ) -> Task<Option<Range<Anchor>>> {
- let fut = self.set_snapshot_with_secondary_inner(
- update,
- buffer,
- secondary_diff_change,
- clear_pending_hunks,
- cx,
- );
-
- cx.spawn(async move |this, cx| {
- let result = fut.await;
- this.update(cx, |_, cx| {
- if result.base_text_changed {
- cx.emit(BufferDiffEvent::BaseTextChanged);
- }
- cx.emit(BufferDiffEvent::DiffChanged(result.change.clone()));
- })
- .ok();
- result.change.changed_range
- })
+ ) -> Option<Range<Anchor>> {
+ self.set_snapshot_with_secondary(new_state, None, false, cx)
}
pub fn base_text(&self, cx: &App) -> language::BufferSnapshot {
- self.inner.base_text.read(cx).snapshot()
+ self.base_text_buffer.read(cx).snapshot()
}
pub fn base_text_exists(&self) -> bool {
- self.inner.base_text_exists
+ self.diff_snapshot
+ .as_ref()
+ .is_some_and(|diff_snapshot| diff_snapshot.base_text_exists)
}
pub fn snapshot(&self, cx: &App) -> BufferDiffSnapshot {
- BufferDiffSnapshot {
- inner: BufferDiffInner {
- hunks: self.inner.hunks.clone(),
- pending_hunks: self.inner.pending_hunks.clone(),
- base_text: self.inner.base_text.read(cx).snapshot(),
- base_text_exists: self.inner.base_text_exists,
- buffer_snapshot: self.inner.buffer_snapshot.clone(),
- },
- secondary_diff: self.secondary_diff.as_ref().map(|diff| {
- debug_assert!(diff.read(cx).secondary_diff.is_none());
- Arc::new(diff.read(cx).snapshot(cx))
- }),
- }
+ let mut snapshot = self.diff_snapshot.clone().unwrap_or_else(|| {
+ let base_text = self.base_text_buffer.read(cx).snapshot();
+ BufferDiffSnapshot {
+ hunks: SumTree::new(&self.buffer_snapshot),
+ pending_hunks: SumTree::new(&self.buffer_snapshot),
+ base_text,
+ base_text_exists: false,
+ buffer_snapshot: self.buffer_snapshot.clone(),
+ secondary_diff: None,
+ }
+ });
+ snapshot.secondary_diff = self.secondary_diff.as_ref().map(|diff| {
+ debug_assert!(diff.read(cx).secondary_diff.is_none());
+ Arc::new(diff.read(cx).snapshot(cx))
+ });
+ snapshot
}
/// Used in cases where the change set isn't derived from git.
+ ///
+ /// Dropping the returned task cancels the update, leaving the diff
+ /// unchanged. Calls must not overlap; to re-run this when the buffer or
+ /// base text changes, store the task somewhere that the next call will
+ /// overwrite, so that the previous call is cancelled.
pub fn set_base_text(
&mut self,
base_text: Option<Arc<str>>,
- language: Option<Arc<Language>>,
buffer: text::BufferSnapshot,
cx: &mut Context<Self>,
- ) -> oneshot::Receiver<()> {
- let (tx, rx) = oneshot::channel();
- let complete_on_drop = util::defer(|| {
- tx.send(()).ok();
- });
+ ) -> Task<()> {
cx.spawn(async move |this, cx| {
+ let base_text_exists = base_text.is_some();
+ let base_text = base_text.unwrap_or_default();
+ let Some(base_text_diff) = this
+ .update(cx, |this, cx| {
+ this.base_text_buffer.update(cx, |base_text_buffer, cx| {
+ base_text_buffer.diff(base_text.clone(), cx)
+ })
+ })
+ .log_err()
+ else {
+ return;
+ };
+ let base_text_diff = base_text_diff.await;
+ let Some(edited_base_text) = this
+ .update(cx, |this, cx| {
+ if this.base_text_buffer.read(cx).version() != base_text_diff.base_version {
+ log::warn!("dropping concurrent diff update");
+ debug_panic!("incorrect concurrent call to set_base_text");
+ return None;
+ }
+ let edited_base_text =
+ this.base_text_buffer.update(cx, |base_text_buffer, cx| {
+ base_text_buffer.set_line_ending(base_text_diff.line_ending, cx);
+ assert!(base_text_buffer.version() == base_text_diff.base_version);
+ base_text_buffer.snapshot_with_edits(base_text_diff.edits, cx)
+ });
+ Some(edited_base_text)
+ })
+ .log_err()
+ .flatten()
+ else {
+ return;
+ };
+ let edited_base_text = edited_base_text.await;
+ let base_text_snapshot = edited_base_text.snapshot().clone();
let Some(state) = this
.update(cx, |this, cx| {
- this.update_diff(buffer.clone(), base_text, Some(false), language, cx)
+ this.update_diff(
+ buffer.clone(),
+ &base_text_snapshot,
+ base_text_exists.then(|| base_text.clone()),
+ cx,
+ )
})
.log_err()
else {
return;
};
let state = state.await;
- if let Some(task) = this
- .update(cx, |this, cx| this.set_snapshot(state, &buffer, cx))
- .log_err()
- {
- task.await;
- }
- drop(complete_on_drop)
+ this.update(cx, |this, cx| {
+ if &this.base_text_buffer.read(cx).version() != edited_base_text.base_version() {
+ log::warn!("dropping concurrent diff update");
+ debug_panic!("incorrect concurrent call to set_base_text");
+ return;
+ }
+
+ this.base_text_buffer.update(cx, |base_text_buffer, cx| {
+ base_text_buffer.fast_forward(edited_base_text, cx)
+ });
+ this.set_snapshot(state, cx);
+ })
+ .log_err();
})
- .detach();
- rx
}
- pub fn base_text_string(&self, cx: &App) -> Option<String> {
- self.inner
- .base_text_exists
- .then(|| self.inner.base_text.read(cx).text())
+ pub fn base_text_string(&self, _cx: &App) -> Option<String> {
+ self.diff_snapshot.as_ref().and_then(|diff_snapshot| {
+ if diff_snapshot.base_text_exists {
+ Some(diff_snapshot.base_text.text())
+ } else {
+ None
+ }
+ })
}
#[cfg(any(test, feature = "test-support"))]
pub fn recalculate_diff_sync(&mut self, buffer: &text::BufferSnapshot, cx: &mut Context<Self>) {
- let language = self.base_text(cx).language().cloned();
- let base_text = self.base_text_string(cx).map(|s| s.as_str().into());
- let fut = self.update_diff(buffer.clone(), base_text, None, language, cx);
+ let base_text = self.base_text(cx);
+ let fut = self.update_diff(
+ buffer.clone(),
+ &base_text,
+ self.base_text_exists().then(|| Arc::from(base_text.text())),
+ cx,
+ );
let fg_executor = cx.foreground_executor().clone();
let snapshot = fg_executor.block_on(fut);
- let fut = self.set_snapshot_with_secondary_inner(snapshot, buffer, None, false, cx);
- let result = fg_executor.block_on(fut);
- if result.base_text_changed {
- cx.emit(BufferDiffEvent::BaseTextChanged);
- }
- cx.emit(BufferDiffEvent::DiffChanged(result.change));
+ let _changed_range = self.set_snapshot(snapshot, cx);
}
pub fn base_text_buffer(&self) -> &Entity<language::Buffer> {
- &self.inner.base_text
+ &self.base_text_buffer
}
}
@@ -2216,7 +2237,7 @@ mod tests {
],
);
- diff = cx.update(|cx| BufferDiff::new(&buffer, cx).snapshot(cx));
+ diff = cx.update(|cx| BufferDiff::new(&buffer, None, None, cx).snapshot(cx));
assert_hunks::<&str, _>(
diff.hunks_intersecting_range(
Anchor::min_max_range_for_buffer(buffer.remote_id()),
@@ -2846,15 +2867,16 @@ mod tests {
let mut buffer = Buffer::new(ReplicaId::LOCAL, BufferId::new(1).unwrap(), buffer_text_1);
- let empty_diff = cx.update(|cx| BufferDiff::new(&buffer, cx).snapshot(cx));
+ let empty_diff = cx.update(|cx| BufferDiff::new(&buffer, None, None, cx).snapshot(cx));
let diff_1 = BufferDiffSnapshot::new_sync(&buffer, base_text.clone(), cx);
let DiffChanged {
changed_range,
base_text_changed_range,
extended_range: _,
+ base_text_changed: _,
} = compare_hunks(
- &diff_1.inner.hunks,
- &empty_diff.inner.hunks,
+ &diff_1.hunks,
+ &empty_diff.hunks,
&buffer,
&buffer,
&diff_1.base_text(),
@@ -2887,9 +2909,10 @@ mod tests {
changed_range,
base_text_changed_range,
extended_range: _,
+ base_text_changed: _,
} = compare_hunks(
- &diff_2.inner.hunks,
- &diff_1.inner.hunks,
+ &diff_2.hunks,
+ &diff_1.hunks,
&buffer,
&buffer,
diff_2.base_text(),
@@ -2925,9 +2948,10 @@ mod tests {
changed_range,
base_text_changed_range,
extended_range: _,
+ base_text_changed: _,
} = compare_hunks(
- &diff_3.inner.hunks,
- &diff_2.inner.hunks,
+ &diff_3.hunks,
+ &diff_2.hunks,
&buffer,
&buffer,
diff_3.base_text(),
@@ -2959,9 +2983,10 @@ mod tests {
changed_range,
base_text_changed_range,
extended_range: _,
+ base_text_changed: _,
} = compare_hunks(
- &diff_4.inner.hunks,
- &diff_3.inner.hunks,
+ &diff_4.hunks,
+ &diff_3.hunks,
&buffer,
&buffer,
diff_4.base_text(),
@@ -2994,9 +3019,10 @@ mod tests {
changed_range,
base_text_changed_range,
extended_range: _,
+ base_text_changed: _,
} = compare_hunks(
- &diff_5.inner.hunks,
- &diff_4.inner.hunks,
+ &diff_5.hunks,
+ &diff_4.hunks,
&buffer,
&buffer,
diff_5.base_text(),
@@ -3029,9 +3055,10 @@ mod tests {
changed_range,
base_text_changed_range,
extended_range: _,
+ base_text_changed: _,
} = compare_hunks(
- &diff_6.inner.hunks,
- &diff_5.inner.hunks,
+ &diff_6.hunks,
+ &diff_5.hunks,
&buffer,
&buffer,
diff_6.base_text(),
@@ -3063,9 +3090,10 @@ mod tests {
changed_range,
base_text_changed_range,
extended_range: _,
+ base_text_changed: _,
} = compare_hunks(
- &diff_7.inner.hunks,
- &diff_6.inner.hunks,
+ &diff_7.hunks,
+ &diff_6.hunks,
&buffer,
&buffer,
diff_7.base_text(),
@@ -3096,9 +3124,10 @@ mod tests {
changed_range,
base_text_changed_range,
extended_range: _,
+ base_text_changed: _,
} = compare_hunks(
- &diff_8.inner.hunks,
- &diff_7.inner.hunks,
+ &diff_8.hunks,
+ &diff_7.hunks,
&buffer,
&buffer,
diff_8.base_text(),
@@ -3322,19 +3351,18 @@ mod tests {
);
buffer.text_snapshot()
});
+ let base_text_snapshot = diff.read_with(cx, |diff, cx| diff.base_text(cx));
let update = diff
.update(cx, |diff, cx| {
diff.update_diff(
snapshot.clone(),
- Some(base_text.as_str().into()),
- None,
- None,
+ &base_text_snapshot,
+ Some(Arc::from(base_text_snapshot.text())),
cx,
)
})
.await;
- diff.update(cx, |diff, cx| diff.set_snapshot(update, &snapshot, cx))
- .await;
+ diff.update(cx, |diff, cx| diff.set_snapshot(update, cx));
cx.run_until_parked();
drop(subscription);
let events = rx.into_iter().collect::<Vec<_>>();
@@ -3344,6 +3372,7 @@ mod tests {
changed_range: _,
base_text_changed_range,
extended_range: _,
+ base_text_changed: _,
}),
] => {
// TODO(cole) this seems like it should pass but currently fails (see compare_hunks)
@@ -3398,9 +3427,10 @@ mod tests {
changed_range,
base_text_changed_range: _,
extended_range,
+ base_text_changed: _,
} = compare_hunks(
- &diff_b.inner.hunks,
- &diff_a.inner.hunks,
+ &diff_b.hunks,
+ &diff_a.hunks,
&old_buffer,
&buffer,
&diff_a.base_text(),
@@ -3461,9 +3491,10 @@ mod tests {
changed_range,
base_text_changed_range: _,
extended_range,
+ base_text_changed: _,
} = compare_hunks(
- &diff_2b.inner.hunks,
- &diff_2a.inner.hunks,
+ &diff_2b.hunks,
+ &diff_2a.hunks,
&old_buffer_2,
&buffer_2,
&diff_2a.base_text(),
@@ -3531,6 +3562,7 @@ mod tests {
changed_range,
base_text_changed_range,
extended_range: _,
+ base_text_changed: _,
} = compare_hunks(
&new_hunks_1,
&old_hunks_1,
@@ -3590,6 +3622,7 @@ mod tests {
changed_range,
base_text_changed_range,
extended_range: _,
+ base_text_changed: _,
} = compare_hunks(
&new_hunks_2,
&old_hunks_2,
@@ -3658,6 +3691,7 @@ mod tests {
changed_range,
base_text_changed_range,
extended_range: _,
+ base_text_changed: _,
} = compare_hunks(
&new_hunks_3,
&old_hunks_3,
@@ -3735,6 +3769,7 @@ mod tests {
changed_range,
base_text_changed_range,
extended_range: _,
+ base_text_changed: _,
} = compare_hunks(
&new_hunks_4,
&old_hunks_4,
@@ -3990,17 +4025,11 @@ mod tests {
);
let buffer_snapshot = buffer.snapshot();
- let diff = cx.new(|cx| BufferDiff::new(&buffer_snapshot, cx));
+ let diff = cx.new(|cx| BufferDiff::new(&buffer_snapshot, None, None, cx));
diff.update(cx, |diff, cx| {
- diff.set_base_text(
- Some(Arc::from(base_text_crlf)),
- None,
- buffer_snapshot.clone(),
- cx,
- )
+ diff.set_base_text(Some(Arc::from(base_text_crlf)), buffer_snapshot.clone(), cx)
})
- .await
- .ok();
+ .await;
cx.run_until_parked();
let snapshot = diff.update(cx, |diff, cx| diff.snapshot(cx));
diff --git a/crates/collab/tests/integration/integration_tests.rs b/crates/collab/tests/integration/integration_tests.rs
index 7fc56a3c86c..dac33f9855b 100644
--- a/crates/collab/tests/integration/integration_tests.rs
+++ b/crates/collab/tests/integration/integration_tests.rs
@@ -2886,6 +2886,107 @@ async fn test_git_diff_base_change(
});
}
+#[gpui::test(iterations = 10)]
+async fn test_git_diff_index_matches_head(
+ executor: BackgroundExecutor,
+ cx_a: &mut TestAppContext,
+ cx_b: &mut TestAppContext,
+) {
+ let mut server = TestServer::start(executor.clone()).await;
+ let client_a = server.create_client(cx_a, "user_a").await;
+ let client_b = server.create_client(cx_b, "user_b").await;
+ server
+ .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
+ .await;
+ let active_call_a = cx_a.read(ActiveCall::global);
+
+ let committed_text = "
+ one
+ two
+ three
+ "
+ .unindent();
+ let file_contents = "
+ one
+ TWO
+ three
+ "
+ .unindent();
+
+ client_a
+ .fs()
+ .insert_tree(
+ "/dir",
+ json!({
+ ".git": {},
+ "a.txt": file_contents,
+ }),
+ )
+ .await;
+ client_a
+ .fs()
+ .set_head_and_index_for_repo(Path::new("/dir/.git"), &[("a.txt", committed_text.clone())]);
+
+ let (project_local, worktree_id) = client_a.build_local_project("/dir", cx_a).await;
+ let project_id = active_call_a
+ .update(cx_a, |call, cx| {
+ call.share_project(project_local.clone(), cx)
+ })
+ .await
+ .unwrap();
+ let project_remote = client_b.join_remote_project(project_id, cx_b).await;
+
+ // Open the uncommitted diff on the guest, without opening it on the host
+ // first, so that the host loads the diff bases in response to the guest's
+ // request.
+ let remote_buffer = project_remote
+ .update(cx_b, |p, cx| {
+ p.open_buffer((worktree_id, rel_path("a.txt")), cx)
+ })
+ .await
+ .unwrap();
+ let remote_uncommitted_diff = project_remote
+ .update(cx_b, |p, cx| {
+ p.open_uncommitted_diff(remote_buffer.clone(), cx)
+ })
+ .await
+ .unwrap();
+ executor.run_until_parked();
+
+ // The guest's index and head texts share one allocation, which is only
+ // possible if the host detected that the index matches the head and sent
+ // `Mode::IndexMatchesHead`.
+ let buffer_id = remote_buffer.read_with(cx_b, |buffer, _| buffer.remote_id());
+ project_remote.read_with(cx_b, |project, cx| {
+ assert!(
+ project
+ .git_store()
+ .read(cx)
+ .index_matches_head_for_buffer(buffer_id, cx),
+ "the host should send IndexMatchesHead when the index is clean"
+ );
+ });
+
+ remote_uncommitted_diff.read_with(cx_b, |diff, cx| {
+ let buffer = remote_buffer.read(cx);
+ assert_eq!(
+ diff.base_text_string(cx).as_deref(),
+ Some(committed_text.as_str())
+ );
+ assert_hunks(
+ diff.snapshot(cx).hunks_in_row_range(0..3, buffer),
+ buffer,
+ &diff.base_text_string(cx).unwrap(),
+ &[(
+ 1..2,
+ "two\n",
+ "TWO\n",
+ DiffHunkStatus::modified(DiffHunkSecondaryStatus::HasSecondaryHunk),
+ )],
+ );
+ });
+}
+
#[gpui::test(iterations = 10)]
async fn test_git_branch_name(
executor: BackgroundExecutor,
diff --git a/crates/edit_prediction_ui/src/rate_prediction_modal.rs b/crates/edit_prediction_ui/src/rate_prediction_modal.rs
index 782fc93f996..deae41c21ef 100644
--- a/crates/edit_prediction_ui/src/rate_prediction_modal.rs
+++ b/crates/edit_prediction_ui/src/rate_prediction_modal.rs
@@ -5,7 +5,7 @@ use editor::{Editor, Inlay, MultiBuffer};
use feature_flags::{FeatureFlag, PresenceFlag, register_feature_flag};
use gpui::{
App, BorderStyle, DismissEvent, EdgesRefinement, Entity, EventEmitter, FocusHandle, Focusable,
- Length, StyleRefinement, TextStyleRefinement, Window, actions, prelude::*,
+ Length, StyleRefinement, Task, TextStyleRefinement, Window, actions, prelude::*,
};
use language::{
Bias, Buffer, BufferSnapshot, CodeLabel, LanguageRegistry, Point, ToOffset, ToPoint,
@@ -71,6 +71,8 @@ struct ActivePrediction {
expected_editor: Entity<Editor>,
_expected_buffer_subscription: gpui::Subscription,
formatted_inputs: Entity<Markdown>,
+ _predicted_diff_task: Task<()>,
+ expected_diff_task: Task<()>,
}
#[derive(Debug, Clone, Copy, PartialEq, PartialOrd)]
@@ -308,29 +310,14 @@ impl RatePredictionsModal {
new_buffer_snapshot: BufferSnapshot,
old_buffer_snapshot: BufferSnapshot,
cx: &mut App,
- ) {
- let language = new_buffer_snapshot.language().cloned();
+ ) -> Task<()> {
diff.update(cx, |diff, cx| {
- let update = diff.update_diff(
- new_buffer_snapshot.text.clone(),
+ diff.set_base_text(
Some(old_buffer_snapshot.text().into()),
- Some(true),
- language,
+ new_buffer_snapshot.text,
cx,
- );
- cx.spawn(async move |diff, cx| {
- let update = update.await;
- if let Some(task) = diff
- .update(cx, |diff, cx| {
- diff.set_snapshot(update, &new_buffer_snapshot.text, cx)
- })
- .ok()
- {
- task.await;
- }
- })
- .detach();
- });
+ )
+ })
}
fn insert_editable_region_markers(
@@ -469,10 +456,17 @@ impl RatePredictionsModal {
Point::new(visible_range.start.row.saturating_sub(5), 0)
..Point::new(visible_range.end.row.saturating_add(5), 0)
.min(predicted_buffer_snapshot.max_point());
- self.diff_editor.update(cx, |editor, cx| {
+ let predicted_diff_task = self.diff_editor.update(cx, |editor, cx| {
let predicted_buffer_id = predicted_buffer_snapshot.remote_id();
- let diff = cx.new(|cx| BufferDiff::new(&predicted_buffer_snapshot.text, cx));
- Self::update_buffer_diff(
+ let diff = cx.new(|cx| {
+ BufferDiff::new(
+ &predicted_buffer_snapshot.text,
+ predicted_buffer_snapshot.language().cloned(),
+ predicted_buffer.read(cx).language_registry(),
+ cx,
+ )
+ });
+ let predicted_diff_task = Self::update_buffer_diff(
&diff,
predicted_buffer_snapshot.clone(),
prediction.snapshot.clone(),
@@ -490,6 +484,7 @@ impl RatePredictionsModal {
);
multibuffer.add_diff(diff, cx);
});
+ predicted_diff_task
});
if let Some(editable_range) = editable_range.as_ref() {
@@ -625,8 +620,15 @@ impl RatePredictionsModal {
..range.end.to_point(&expected_buffer_snapshot)
})
.unwrap_or(visible_range);
- let expected_diff = cx.new(|cx| BufferDiff::new(&expected_buffer_snapshot.text, cx));
- Self::update_buffer_diff(
+ let expected_diff = cx.new(|cx| {
+ BufferDiff::new(
+ &expected_buffer_snapshot.text,
+ expected_buffer_snapshot.language().cloned(),
+ expected_buffer.read(cx).language_registry(),
+ cx,
+ )
+ });
+ let expected_diff_task = Self::update_buffer_diff(
&expected_diff,
expected_buffer_snapshot.clone(),
prediction.snapshot.clone(),
@@ -676,16 +678,19 @@ impl RatePredictionsModal {
let expected_buffer_subscription = cx.subscribe(&expected_buffer, {
let expected_diff = expected_diff.clone();
let original_snapshot = prediction.snapshot.clone();
- move |_this, buffer, event, cx| match event {
+ move |this, buffer, event, cx| match event {
language::BufferEvent::Edited { .. }
| language::BufferEvent::LanguageChanged(_)
| language::BufferEvent::Reparsed => {
- Self::update_buffer_diff(
+ let task = Self::update_buffer_diff(
&expected_diff,
buffer.read(cx).snapshot(),
original_snapshot.clone(),
cx,
);
+ if let Some(active_prediction) = this.active_prediction.as_mut() {
+ active_prediction.expected_diff_task = task;
+ }
}
_ => {}
}
@@ -716,6 +721,8 @@ impl RatePredictionsModal {
expected_buffer,
expected_editor,
_expected_buffer_subscription: expected_buffer_subscription,
+ _predicted_diff_task: predicted_diff_task,
+ expected_diff_task,
formatted_inputs: cx.new(|cx| {
Markdown::new(
formatted_inputs.into(),
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 9c7a2594950..1dcb2180809 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -1122,6 +1122,10 @@ pub struct Editor {
load_diff_task: Option<Shared<Task<()>>>,
/// Whether we are temporarily displaying a diff other than git's
temporary_diff_override: bool,
+ /// Whether to render all diff hunks with the "unstaged" appearance,
+ /// regardless of whether they have a secondary hunk. Used by views whose
+ /// diffs aren't related to the git index (e.g. agent diffs).
+ render_diff_hunks_as_unstaged: bool,
selection_mark_mode: bool,
toggle_fold_multiple_buffers: Task<()>,
_scroll_cursor_center_top_bottom_task: Task<()>,
@@ -2348,6 +2352,7 @@ impl Editor {
text_style_refinement: None,
load_diff_task: load_uncommitted_diff,
temporary_diff_override: false,
+ render_diff_hunks_as_unstaged: false,
minimap: None,
change_list: ChangeList::new(),
mode,
diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rs
index 49eb44ead50..48a074b25cc 100644
--- a/crates/editor/src/editor_tests.rs
+++ b/crates/editor/src/editor_tests.rs
@@ -37636,95 +37636,6 @@ async fn test_restore_and_next(cx: &mut TestAppContext) {
);
}
-#[gpui::test]
-async fn test_restore_hunk_with_stale_base_text(cx: &mut TestAppContext) {
- // Regression test: prepare_restore_change must read base_text from the same
- // snapshot the hunk came from, not from the live BufferDiff entity. The live
- // entity's base_text may have already been updated asynchronously (e.g.
- // because git HEAD changed) while the MultiBufferSnapshot still holds the
- // old hunk byte ranges — using both together causes Rope::slice to panic
- // when the old range exceeds the new base text length.
- init_test(cx, |_| {});
- let mut cx = EditorTestContext::new(cx).await;
-
- let long_base_text = "one\ntwo\nthree\nfour\nfive\nsix\nseven\neight\nnine\nten\n";
- cx.set_state("ˇONE\ntwo\nTHREE\nfour\nFIVE\nsix\nseven\neight\nnine\nten\n");
- cx.set_head_text(long_base_text);
-
- let buffer_id = cx.update_buffer(|buffer, _| buffer.remote_id());
-
- // Verify we have hunks from the initial diff.
- let has_hunks = cx.update_editor(|editor, window, cx| {
- let snapshot = editor.snapshot(window, cx);
- let hunks = snapshot
- .buffer_snapshot()
- .diff_hunks_in_range(MultiBufferOffset(0)..snapshot.buffer_snapshot().len());
- hunks.count() > 0
- });
- assert!(has_hunks, "should have diff hunks before restoring");
-
- // Now trigger a git HEAD change to a much shorter base text.
- // After this, the live BufferDiff entity's base_text buffer will be
- // updated synchronously (inside set_snapshot_with_secondary_inner),
- // but DiffChanged is deferred until parsing_idle completes.
- // We step the executor tick-by-tick to find the window where the
- // live base_text is already short but the MultiBuffer snapshot is
- // still stale (old hunks + old base_text).
- let short_base_text = "short\n";
- let fs = cx.update_editor(|editor, _, cx| editor.project().unwrap().read(cx).fs().as_fake());
- let path = cx.update_buffer(|buffer, _| buffer.file().unwrap().path().clone());
- fs.set_head_for_repo(
- &Path::new(path!("/root")).join(".git"),
- &[(path.as_unix_str(), short_base_text.to_string())],
- "newcommit",
- );
-
- // Step the executor tick-by-tick. At each step, check whether the
- // race condition exists: live BufferDiff has short base text but
- // the MultiBuffer snapshot still has old (long) hunks.
- let mut found_race = false;
- for _ in 0..200 {
- cx.executor().tick();
-
- let race_exists = cx.update_editor(|editor, _window, cx| {
- let multi_buffer = editor.buffer().read(cx);
- let diff_entity = match multi_buffer.diff_for(buffer_id) {
- Some(d) => d,
- None => return false,
- };
- let live_base_len = diff_entity.read(cx).base_text(cx).len();
- let snapshot = multi_buffer.snapshot(cx);
- let snapshot_base_len = snapshot
- .diff_for_buffer_id(buffer_id)
- .map(|d| d.base_text().len());
- // Race: live base text is shorter than what the snapshot knows.
- live_base_len < long_base_text.len() && snapshot_base_len == Some(long_base_text.len())
- });
-
- if race_exists {
- found_race = true;
- // The race window is open: the live entity has new (short) base
- // text but the MultiBuffer snapshot still has old hunks with byte
- // ranges computed against the old long base text. Attempt restore.
- // Without the fix, this panics with "cannot summarize past end of
- // rope". With the fix, it reads base_text from the stale snapshot
- // (consistent with the stale hunks) and succeeds.
- cx.update_editor(|editor, window, cx| {
- editor.select_all(&SelectAll, window, cx);
- editor.git_restore(&Default::default(), window, cx);
- });
- break;
- }
- }
-
- assert!(
- found_race,
- "failed to observe the race condition between \
- live BufferDiff base_text and stale MultiBuffer snapshot; \
- the test may need adjustment if the async diff pipeline changed"
- );
-}
-
#[gpui::test]
async fn test_align_selections(cx: &mut TestAppContext) {
init_test(cx, |_| {});
diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs
index 8994021ea51..e3d634b4a0a 100644
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -5135,6 +5135,7 @@ impl EditorElement {
}
fn paint_gutter_diff_hunks(
+ &self,
layout: &mut EditorLayout,
split_side: Option<SplitSide>,
window: &mut Window,
@@ -5210,7 +5211,7 @@ impl EditorElement {
.editor_background
.blend(background_color);
- if !Self::diff_hunk_hollow(status, cx) {
+ if !self.diff_hunk_hollow(status, cx) {
window.paint_quad(quad(
hunk_bounds,
corner_radii,
@@ -5388,7 +5389,7 @@ impl EditorElement {
)
});
if show_git_gutter {
- Self::paint_gutter_diff_hunks(layout, self.split_side, window, cx)
+ self.paint_gutter_diff_hunks(layout, self.split_side, window, cx)
}
let highlight_width = 0.275 * layout.position_map.line_height;
@@ -6501,8 +6502,9 @@ impl EditorElement {
)
}
- fn diff_hunk_hollow(status: DiffHunkStatus, cx: &mut App) -> bool {
- let unstaged = status.has_secondary_hunk();
+ fn diff_hunk_hollow(&self, status: DiffHunkStatus, cx: &mut App) -> bool {
+ let unstaged =
+ self.editor.read(cx).render_diff_hunks_as_unstaged || status.has_secondary_hunk();
let unstaged_hollow = matches!(
ProjectSettings::get_global(cx).git.hunk_style,
GitHunkStyleSetting::UnstagedHollow
@@ -8194,7 +8196,7 @@ impl Element for EditorElement {
type_id: None,
};
- let background = if Self::diff_hunk_hollow(diff_status, cx) {
+ let background = if self.diff_hunk_hollow(diff_status, cx) {
hollow_highlight
} else {
filled_highlight
diff --git a/crates/editor/src/git.rs b/crates/editor/src/git.rs
index 16b1bc4daee..dbe4f073e50 100644
--- a/crates/editor/src/git.rs
+++ b/crates/editor/src/git.rs
@@ -175,6 +175,18 @@ impl Editor {
cx.notify();
}
+ /// Make all diff hunks render with the "unstaged" appearance, regardless
+ /// of whether they have a secondary hunk. Intended for views whose diffs
+ /// aren't related to the git index (e.g. agent diffs).
+ pub fn set_render_diff_hunks_as_unstaged(
+ &mut self,
+ render_as_unstaged: bool,
+ cx: &mut Context<Self>,
+ ) {
+ self.render_diff_hunks_as_unstaged = render_as_unstaged;
+ cx.notify();
+ }
+
pub fn git_blame_inline_enabled(&self) -> bool {
self.git_blame_inline_enabled
}
@@ -230,6 +242,7 @@ impl Editor {
pub fn end_temporary_diff_override(&mut self, cx: &mut Context<Self>) {
self.temporary_diff_override = false;
+ self.render_diff_hunks_as_unstaged = false;
self.set_render_diff_hunk_controls(Arc::new(render_diff_hunk_controls), cx);
self.buffer.update(cx, |buffer, cx| {
buffer.set_all_diff_hunks_collapsed(cx);
diff --git a/crates/editor/src/split.rs b/crates/editor/src/split.rs
index d6380c04cf5..2c3bd5f8dba 100644
--- a/crates/editor/src/split.rs
+++ b/crates/editor/src/split.rs
@@ -471,6 +471,12 @@ impl SplittableEditor {
});
}
+ pub fn set_render_diff_hunks_as_unstaged(&self, cx: &mut Context<Self>) {
+ self.update_editors(cx, |editor, cx| {
+ editor.set_render_diff_hunks_as_unstaged(true, cx);
+ });
+ }
+
fn focused_side(&self) -> SplitSide {
if let Some(lhs) = &self.lhs
&& lhs.was_last_focused
@@ -607,9 +613,11 @@ impl SplittableEditor {
});
let render_diff_hunk_controls = self.rhs_editor.read(cx).render_diff_hunk_controls.clone();
+ let render_diff_hunks_as_unstaged = self.rhs_editor.read(cx).render_diff_hunks_as_unstaged;
let lhs_editor = cx.new(|cx| {
let mut editor =
Editor::for_multibuffer(lhs_multibuffer.clone(), Some(project.clone()), window, cx);
+ editor.set_render_diff_hunks_as_unstaged(render_diff_hunks_as_unstaged, cx);
editor.set_number_deleted_lines(true, cx);
editor.set_delegate_expand_excerpts(true);
editor.set_delegate_stage_and_restore(true);
@@ -2612,7 +2620,7 @@ mod tests {
.collect::<Vec<_>>();
editor.update(cx, |editor, cx| {
- let path = PathKey::for_buffer(&buffer, cx);
+ let path = PathKey::sorted(0);
editor.update_excerpts_for_path(path, buffer.clone(), ranges, 0, diff.clone(), cx);
});
cx.run_until_parked();
@@ -2669,7 +2677,7 @@ mod tests {
let (buffer, diff) = buffer_with_diff(&base_text, &current_text, &mut cx);
editor.update(cx, |editor, cx| {
- let path = PathKey::for_buffer(&buffer, cx);
+ let path = PathKey::sorted(0);
editor.update_excerpts_for_path(
path,
buffer.clone(),
@@ -2798,7 +2806,7 @@ mod tests {
let (buffer2, diff2) = buffer_with_diff(&base_text2, &base_text2, &mut cx);
editor.update(cx, |editor, cx| {
- let path1 = PathKey::for_buffer(&buffer1, cx);
+ let path1 = PathKey::sorted(0);
editor.update_excerpts_for_path(
path1,
buffer1.clone(),
@@ -2807,7 +2815,7 @@ mod tests {
diff1.clone(),
cx,
);
- let path2 = PathKey::for_buffer(&buffer2, cx);
+ let path2 = PathKey::sorted(1);
editor.update_excerpts_for_path(
path2,
buffer2.clone(),
@@ -2956,7 +2964,7 @@ mod tests {
let (buffer, diff) = buffer_with_diff(&base_text, &current_text, &mut cx);
editor.update(cx, |editor, cx| {
- let path = PathKey::for_buffer(&buffer, cx);
+ let path = PathKey::sorted(0);
editor.update_excerpts_for_path(
path,
buffer.clone(),
@@ -3083,7 +3091,7 @@ mod tests {
let (buffer, diff) = buffer_with_diff(&base_text, &current_text, &mut cx);
editor.update(cx, |editor, cx| {
- let path = PathKey::for_buffer(&buffer, cx);
+ let path = PathKey::sorted(0);
editor.update_excerpts_for_path(
path,
buffer.clone(),
@@ -3202,7 +3210,7 @@ mod tests {
let (buffer, diff) = buffer_with_diff(&base_text, &current_text, &mut cx);
editor.update(cx, |editor, cx| {
- let path = PathKey::for_buffer(&buffer, cx);
+ let path = PathKey::sorted(0);
editor.update_excerpts_for_path(
path,
buffer.clone(),
@@ -3332,7 +3340,7 @@ mod tests {
let (buffer, diff) = buffer_with_diff(&base_text, &current_text, &mut cx);
editor.update(cx, |editor, cx| {
- let path = PathKey::for_buffer(&buffer, cx);
+ let path = PathKey::sorted(0);
editor.update_excerpts_for_path(
path,
buffer.clone(),
@@ -3429,7 +3437,7 @@ mod tests {
editor.update(cx, |editor, cx| {
let end = Point::new(0, text.len() as u32);
- let path1 = PathKey::for_buffer(&buffer1, cx);
+ let path1 = PathKey::sorted(0);
editor.update_excerpts_for_path(
path1,
buffer1.clone(),
@@ -3438,7 +3446,7 @@ mod tests {
diff1.clone(),
cx,
);
- let path2 = PathKey::for_buffer(&buffer2, cx);
+ let path2 = PathKey::sorted(1);
editor.update_excerpts_for_path(
path2,
buffer2.clone(),
@@ -3506,7 +3514,7 @@ mod tests {
let (buffer, diff) = buffer_with_diff(&base_text, &current_text, &mut cx);
editor.update(cx, |editor, cx| {
- let path = PathKey::for_buffer(&buffer, cx);
+ let path = PathKey::sorted(0);
editor.update_excerpts_for_path(
path,
buffer.clone(),
@@ -3569,7 +3577,7 @@ mod tests {
let (buffer, diff) = buffer_with_diff(&base_text, &current_text, &mut cx);
editor.update(cx, |editor, cx| {
- let path = PathKey::for_buffer(&buffer, cx);
+ let path = PathKey::sorted(0);
editor.update_excerpts_for_path(
path,
buffer.clone(),
@@ -3630,7 +3638,7 @@ mod tests {
let (buffer, diff) = buffer_with_diff(&text, &text, &mut cx);
editor.update(cx, |editor, cx| {
- let path = PathKey::for_buffer(&buffer, cx);
+ let path = PathKey::sorted(0);
editor.update_excerpts_for_path(
path,
buffer.clone(),
@@ -3743,10 +3751,10 @@ mod tests {
.unindent();
let buffer2 = cx.new(|cx| Buffer::local(current_text.to_string(), cx));
- let diff2 = cx.new(|cx| BufferDiff::new(&buffer2.read(cx).text_snapshot(), cx));
+ let diff2 = cx.new(|cx| BufferDiff::new(&buffer2.read(cx).text_snapshot(), None, None, cx));
editor.update(cx, |editor, cx| {
- let path1 = PathKey::for_buffer(&buffer1, cx);
+ let path1 = PathKey::sorted(0);
editor.update_excerpts_for_path(
path1,
buffer1.clone(),
@@ -3756,7 +3764,7 @@ mod tests {
cx,
);
- let path2 = PathKey::for_buffer(&buffer2, cx);
+ let path2 = PathKey::sorted(1);
editor.update_excerpts_for_path(
path2,
buffer2.clone(),
@@ -3854,7 +3862,7 @@ mod tests {
let (buffer, diff) = buffer_with_diff(&base_text, &current_text, &mut cx);
editor.update(cx, |editor, cx| {
- let path = PathKey::for_buffer(&buffer, cx);
+ let path = PathKey::sorted(0);
editor.update_excerpts_for_path(
path,
buffer.clone(),
@@ -3930,7 +3938,7 @@ mod tests {
let (buffer, diff) = buffer_with_diff(&base_text, &current_text, &mut cx);
editor.update(cx, |editor, cx| {
- let path = PathKey::for_buffer(&buffer, cx);
+ let path = PathKey::sorted(0);
editor.update_excerpts_for_path(
path,
buffer.clone(),
@@ -4017,7 +4025,7 @@ mod tests {
let (buffer, diff) = buffer_with_diff(&base_text, &current_text, &mut cx);
editor.update(cx, |editor, cx| {
- let path = PathKey::for_buffer(&buffer, cx);
+ let path = PathKey::sorted(0);
editor.update_excerpts_for_path(
path,
buffer.clone(),
@@ -4131,7 +4139,7 @@ mod tests {
let (buffer, diff) = buffer_with_diff(base_text, &current_text, &mut cx);
editor.update(cx, |editor, cx| {
- let path = PathKey::for_buffer(&buffer, cx);
+ let path = PathKey::sorted(0);
editor.update_excerpts_for_path(
path,
buffer.clone(),
@@ -4215,7 +4223,7 @@ mod tests {
let (buffer, diff) = buffer_with_diff(&base_text, &current_text, &mut cx);
editor.update(cx, |editor, cx| {
- let path = PathKey::for_buffer(&buffer, cx);
+ let path = PathKey::sorted(0);
editor.update_excerpts_for_path(
path,
buffer.clone(),
@@ -4299,7 +4307,7 @@ mod tests {
let (buffer, diff) = buffer_with_diff(&content, &content, &mut cx);
editor.update(cx, |editor, cx| {
- let path = PathKey::for_buffer(&buffer, cx);
+ let path = PathKey::sorted(0);
editor.update_excerpts_for_path(
path,
buffer.clone(),
@@ -4391,7 +4399,7 @@ mod tests {
let (buffer, diff) = buffer_with_diff(&base_text, &current_text, &mut cx);
editor.update(cx, |editor, cx| {
- let path = PathKey::for_buffer(&buffer, cx);
+ let path = PathKey::sorted(0);
editor.update_excerpts_for_path(
path,
buffer.clone(),
@@ -4519,7 +4527,7 @@ mod tests {
let (buffer, diff) = buffer_with_diff(&base_text, &current_text, &mut cx);
editor.update(cx, |editor, cx| {
- let path = PathKey::for_buffer(&buffer, cx);
+ let path = PathKey::sorted(0);
editor.update_excerpts_for_path(
path,
buffer.clone(),
@@ -4666,7 +4674,7 @@ mod tests {
let (buffer, diff) = buffer_with_diff(&base_text, &current_text, &mut cx);
editor.update(cx, |editor, cx| {
- let path = PathKey::for_buffer(&buffer, cx);
+ let path = PathKey::sorted(0);
editor.update_excerpts_for_path(
path,
buffer.clone(),
@@ -4888,7 +4896,7 @@ mod tests {
let (buffer, diff) = buffer_with_diff(&base_text, &current_text, &mut cx);
editor.update(cx, |editor, cx| {
- let path = PathKey::for_buffer(&buffer, cx);
+ let path = PathKey::sorted(0);
editor.update_excerpts_for_path(
path,
buffer.clone(),
@@ -5227,18 +5235,16 @@ mod tests {
let buffer2_id = buffer2.read_with(cx, |buffer, _| buffer.remote_id());
editor.update(cx, |editor, cx| {
- let path1 = PathKey::for_buffer(&buffer1, cx);
editor.update_excerpts_for_path(
- path1,
+ PathKey::sorted(0),
buffer1.clone(),
vec![Point::new(0, 0)..buffer1.read(cx).max_point()],
0,
diff1.clone(),
cx,
);
- let path2 = PathKey::for_buffer(&buffer2, cx);
editor.update_excerpts_for_path(
- path2,
+ PathKey::sorted(1),
buffer2.clone(),
vec![Point::new(0, 0)..buffer2.read(cx).max_point()],
1,
@@ -5392,7 +5398,7 @@ mod tests {
let (buffer, diff) = buffer_with_diff(&base_text, &current_text, &mut cx);
editor.update(cx, |editor, cx| {
- let path = PathKey::for_buffer(&buffer, cx);
+ let path = PathKey::sorted(0);
editor.update_excerpts_for_path(
path,
buffer.clone(),
@@ -5553,7 +5559,7 @@ mod tests {
let (buffer, diff) = buffer_with_diff(&base_text, &current_text, &mut cx);
editor.update(cx, |editor, cx| {
- let path = PathKey::for_buffer(&buffer, cx);
+ let path = PathKey::sorted(0);
editor.update_excerpts_for_path(
path,
buffer.clone(),
@@ -5712,7 +5718,7 @@ mod tests {
let (buffer, diff) = buffer_with_diff(&base_text, &current_text, &mut cx);
editor.update(cx, |editor, cx| {
- let path = PathKey::for_buffer(&buffer, cx);
+ let path = PathKey::sorted(0);
editor.update_excerpts_for_path(
path,
buffer.clone(),
@@ -5843,7 +5849,7 @@ mod tests {
let (buffer, diff) = buffer_with_diff(&base_text, &current_text, &mut cx);
editor.update(cx, |editor, cx| {
- let path = PathKey::for_buffer(&buffer, cx);
+ let path = PathKey::sorted(0);
editor.update_excerpts_for_path(
path,
buffer.clone(),
@@ -5904,7 +5910,7 @@ mod tests {
let (buffer, diff) = buffer_with_diff(&base_text, &current_text, &mut cx);
editor.update(cx, |editor, cx| {
- let path = PathKey::for_buffer(&buffer, cx);
+ let path = PathKey::sorted(0);
editor.update_excerpts_for_path(
path,
buffer.clone(),
@@ -5987,7 +5993,7 @@ mod tests {
let (buffer, diff) = buffer_with_diff(&base_text, &current_text, &mut cx);
editor.update(cx, |editor, cx| {
- let path = PathKey::for_buffer(&buffer, cx);
+ let path = PathKey::sorted(0);
editor.update_excerpts_for_path(
path,
buffer.clone(),
@@ -6096,8 +6102,8 @@ mod tests {
let (buffer_a, diff_a) = buffer_with_diff(&base_text_a, &current_text_a, &mut cx);
let (buffer_b, diff_b) = buffer_with_diff(&base_text_b, &current_text_b, &mut cx);
- let path_a = cx.read(|cx| PathKey::for_buffer(&buffer_a, cx));
- let path_b = cx.read(|cx| PathKey::for_buffer(&buffer_b, cx));
+ let path_a = PathKey::sorted(0);
+ let path_b = PathKey::sorted(1);
editor.update(cx, |editor, cx| {
editor.update_excerpts_for_path(
@@ -6238,7 +6244,7 @@ mod tests {
let (buffer, diff) = buffer_with_diff(&base_text, &current_text, &mut cx);
editor.update(cx, |editor, cx| {
- let path = PathKey::for_buffer(&buffer, cx);
+ let path = PathKey::sorted(0);
editor.update_excerpts_for_path(
path,
buffer.clone(),
diff --git a/crates/git_ui/src/commit_view.rs b/crates/git_ui/src/commit_view.rs
index 353deb47ed5..9fff74d3983 100644
--- a/crates/git_ui/src/commit_view.rs
+++ b/crates/git_ui/src/commit_view.rs
@@ -368,7 +368,14 @@ impl CommitView {
let buffer_diff = if is_binary {
cx.update(|_, cx| {
let snapshot = buffer.read(cx).snapshot();
- cx.new(|cx| BufferDiff::new_unchanged(&snapshot, cx))
+ cx.new(|cx| {
+ BufferDiff::new_unchanged(
+ &snapshot,
+ snapshot.language().cloned(),
+ Some(language_registry.clone()),
+ cx,
+ )
+ })
})?
} else {
build_buffer_diff(old_text, &buffer, &language_registry, cx).await?
@@ -996,23 +1003,15 @@ async fn build_buffer_diff(
let language = cx.update(|_, cx| buffer.read(cx).language().cloned())?;
let buffer = cx.update(|_, cx| buffer.read(cx).snapshot())?;
- let diff = cx.new(|cx| BufferDiff::new(&buffer.text, cx));
-
- let update = diff
- .update(cx, |diff, cx| {
- diff.update_diff(
- buffer.text.clone(),
- old_text.map(|old_text| Arc::from(old_text.as_str())),
- Some(true),
- language.clone(),
- cx,
- )
- })
- .await;
+ let diff =
+ cx.new(|cx| BufferDiff::new(&buffer.text, language, Some(language_registry.clone()), cx));
diff.update(cx, |diff, cx| {
- diff.language_changed(language, Some(language_registry.clone()), cx);
- diff.set_snapshot(update, &buffer.text, cx)
+ diff.set_base_text(
+ old_text.map(|old_text| Arc::from(old_text.as_str())),
+ buffer.text.clone(),
+ cx,
+ )
})
.await;
diff --git a/crates/git_ui/src/file_diff_view.rs b/crates/git_ui/src/file_diff_view.rs
index ac9e4175b65..477f18be545 100644
--- a/crates/git_ui/src/file_diff_view.rs
+++ b/crates/git_ui/src/file_diff_view.rs
@@ -8,7 +8,7 @@ use gpui::{
AnyElement, App, AppContext as _, AsyncApp, Context, Entity, EventEmitter, FocusHandle,
Focusable, Font, IntoElement, Render, Task, WeakEntity, Window,
};
-use language::{Buffer, HighlightedText, LanguageRegistry};
+use language::{Buffer, HighlightedText};
use project::{Project, ProjectPath};
use settings::Settings;
use std::{
@@ -53,9 +53,8 @@ impl FileDiffView {
let new_buffer = project
.update(cx, |project, cx| project.open_local_buffer(&new_path, cx))
.await?;
- let languages = project.update(cx, |project, _| project.languages().clone());
- let buffer_diff = build_buffer_diff(&old_buffer, &new_buffer, languages, cx).await?;
+ let buffer_diff = build_buffer_diff(&old_buffer, &new_buffer, cx).await?;
workspace.update_in(cx, |workspace, window, cx| {
let workspace_entity = cx.entity();
@@ -108,6 +107,7 @@ impl FileDiffView {
editor.start_temporary_diff_override();
});
splittable.disable_diff_hunk_controls(cx);
+ splittable.set_render_diff_hunks_as_unstaged(cx);
splittable
});
@@ -154,13 +154,11 @@ impl FileDiffView {
diff.update(cx, |diff, cx| {
diff.set_base_text(
Some(old_snapshot.text().as_str().into()),
- old_snapshot.language().cloned(),
new_snapshot.text.clone(),
cx,
)
})
- .await
- .ok();
+ .await;
log::trace!("finish recalculating");
}
Ok(())
@@ -170,36 +168,30 @@ impl FileDiffView {
}
#[ztracing::instrument(skip_all)]
-async fn build_buffer_diff(
+pub(crate) async fn build_buffer_diff(
old_buffer: &Entity<Buffer>,
new_buffer: &Entity<Buffer>,
- language_registry: Arc<LanguageRegistry>,
cx: &mut AsyncApp,
) -> Result<Entity<BufferDiff>> {
let old_buffer_snapshot = old_buffer.read_with(cx, |buffer, _| buffer.snapshot());
let new_buffer_snapshot = new_buffer.read_with(cx, |buffer, _| buffer.snapshot());
+ let language_registry = new_buffer.read_with(cx, |buffer, _| buffer.language_registry());
- let diff = cx.new(|cx| BufferDiff::new(&new_buffer_snapshot.text, cx));
-
- let update = diff
- .update(cx, |diff, cx| {
- diff.update_diff(
- new_buffer_snapshot.text.clone(),
- Some(old_buffer_snapshot.text().into()),
- Some(true),
- new_buffer_snapshot.language().cloned(),
- cx,
- )
- })
- .await;
+ let diff = cx.new(|cx| {
+ BufferDiff::new(
+ &new_buffer_snapshot.text,
+ new_buffer_snapshot.language().cloned(),
+ language_registry,
+ cx,
+ )
+ });
diff.update(cx, |diff, cx| {
- diff.language_changed(
- new_buffer_snapshot.language().cloned(),
- Some(language_registry),
+ diff.set_base_text(
+ Some(old_buffer_snapshot.text().into()),
+ new_buffer_snapshot.text.clone(),
cx,
- );
- diff.set_snapshot(update, &new_buffer_snapshot.text, cx)
+ )
})
.await;
diff --git a/crates/git_ui/src/multi_diff_view.rs b/crates/git_ui/src/multi_diff_view.rs
index a3b55fabe9a..f8097e68f5c 100644
--- a/crates/git_ui/src/multi_diff_view.rs
+++ b/crates/git_ui/src/multi_diff_view.rs
@@ -1,3 +1,4 @@
+use crate::file_diff_view::build_buffer_diff;
use anyhow::Result;
use buffer_diff::BufferDiff;
use editor::{Editor, EditorEvent, MultiBuffer, multibuffer_context_lines};
@@ -140,36 +141,6 @@ fn common_prefix(paths: &[PathBuf]) -> Option<PathBuf> {
Some(prefix)
}
-async fn build_buffer_diff(
- old_buffer: &Entity<Buffer>,
- new_buffer: &Entity<Buffer>,
- cx: &mut AsyncApp,
-) -> Result<Entity<BufferDiff>> {
- let old_buffer_snapshot = old_buffer.read_with(cx, |buffer, _| buffer.snapshot());
- let new_buffer_snapshot = new_buffer.read_with(cx, |buffer, _| buffer.snapshot());
-
- let diff = cx.new(|cx| BufferDiff::new(&new_buffer_snapshot.text, cx));
-
- let update = diff
- .update(cx, |diff, cx| {
- diff.update_diff(
- new_buffer_snapshot.text.clone(),
- Some(old_buffer_snapshot.text().into()),
- Some(true),
- new_buffer_snapshot.language().cloned(),
- cx,
- )
- })
- .await;
-
- diff.update(cx, |diff, cx| {
- diff.set_snapshot(update, &new_buffer_snapshot.text, cx)
- })
- .await;
-
- Ok(diff)
-}
-
impl MultiDiffView {
pub fn open(
diff_pairs: Vec<[String; 2]>,
@@ -228,6 +199,7 @@ impl MultiDiffView {
editor.start_temporary_diff_override();
editor.disable_diagnostics(cx);
editor.set_expand_all_diff_hunks(cx);
+ editor.set_render_diff_hunks_as_unstaged(true, cx);
editor.set_render_diff_hunk_controls(
Arc::new(|_, _, _, _, _, _, _, _| gpui::Empty.into_any_element()),
cx,
diff --git a/crates/git_ui/src/project_diff.rs b/crates/git_ui/src/project_diff.rs
index 5627c40a4ca..cd929c22e67 100644
--- a/crates/git_ui/src/project_diff.rs
+++ b/crates/git_ui/src/project_diff.rs
@@ -836,7 +836,6 @@ impl ProjectDiff {
);
}
buffer_diff::BufferDiffEvent::BaseTextChanged
- | buffer_diff::BufferDiffEvent::LanguageChanged
| buffer_diff::BufferDiffEvent::HunksStagedOrUnstaged(_) => {}
}
});
diff --git a/crates/git_ui/src/text_diff_view.rs b/crates/git_ui/src/text_diff_view.rs
index aae52ffe438..5312ae6d088 100644
--- a/crates/git_ui/src/text_diff_view.rs
+++ b/crates/git_ui/src/text_diff_view.rs
@@ -11,7 +11,7 @@ use gpui::{
AnyElement, App, AppContext as _, AsyncApp, Context, Entity, EventEmitter, FocusHandle,
Focusable, IntoElement, Render, Task, Window,
};
-use language::{self, Buffer, OffsetRangeExt, Point};
+use language::{self, Buffer, Capability, OffsetRangeExt, Point};
use project::{Project, ProjectPath};
use settings::Settings;
use std::{
@@ -110,16 +110,22 @@ impl TextDiffView {
}
let workspace = workspace.weak_handle();
- let diff_buffer = cx.new(|cx| BufferDiff::new(&source_buffer_snapshot.text, cx));
let clipboard_buffer = build_clipboard_buffer(
clipboard_text,
&source_buffer,
expanded_selection_range.clone(),
cx,
);
+ let diff_buffer = cx.new(|cx| {
+ BufferDiff::new_with_base_text_buffer(
+ &source_buffer_snapshot.text,
+ clipboard_buffer.clone(),
+ cx,
+ )
+ });
let task = window.spawn(cx, async move |cx| {
- update_diff_buffer(&diff_buffer, &source_buffer, &clipboard_buffer, cx).await?;
+ update_diff_buffer(&diff_buffer, &source_buffer, &clipboard_buffer, cx).await;
workspace.update_in(cx, |workspace, window, cx| {
let project = workspace.project().clone();
@@ -179,6 +185,7 @@ impl TextDiffView {
cx,
);
splittable.disable_diff_hunk_controls(cx);
+ splittable.set_render_diff_hunks_as_unstaged(cx);
splittable.rhs_editor().update(cx, |editor, _cx| {
editor.start_temporary_diff_override();
});
@@ -240,7 +247,7 @@ impl TextDiffView {
}
log::trace!("start recalculating");
- update_diff_buffer(&diff_buffer, &source_buffer, &clipboard_buffer, cx).await?;
+ update_diff_buffer(&diff_buffer, &source_buffer, &clipboard_buffer, cx).await;
log::trace!("finish recalculating");
}
Ok(())
@@ -259,12 +266,17 @@ fn build_clipboard_buffer(
cx.new(|cx| {
let mut buffer = language::Buffer::local(source_buffer_snapshot.text(), cx);
let language = source_buffer.read(cx).language().cloned();
+ if let Some(language_registry) = source_buffer.read(cx).language_registry() {
+ buffer.set_language_registry(language_registry);
+ }
buffer.set_language(language, cx);
let range_start = source_buffer_snapshot.point_to_offset(replacement_range.start);
let range_end = source_buffer_snapshot.point_to_offset(replacement_range.end);
buffer.edit([(range_start..range_end, text)], None, cx);
+ buffer.set_capability(Capability::ReadOnly, cx);
+
buffer
})
}
@@ -274,32 +286,23 @@ async fn update_diff_buffer(
source_buffer: &Entity<Buffer>,
clipboard_buffer: &Entity<Buffer>,
cx: &mut AsyncApp,
-) -> Result<()> {
+) {
let source_buffer_snapshot = source_buffer.read_with(cx, |buffer, _| buffer.snapshot());
- let language = source_buffer_snapshot.language().cloned();
- let language_registry = source_buffer.read_with(cx, |buffer, _| buffer.language_registry());
-
let base_buffer_snapshot = clipboard_buffer.read_with(cx, |buffer, _| buffer.snapshot());
- let base_text = base_buffer_snapshot.text();
+ let base_text = Arc::<str>::from(base_buffer_snapshot.text());
let update = diff
.update(cx, |diff, cx| {
diff.update_diff(
source_buffer_snapshot.text.clone(),
- Some(Arc::from(base_text.as_str())),
- Some(true),
- language.clone(),
+ &base_buffer_snapshot,
+ Some(base_text.clone()),
cx,
)
})
.await;
- diff.update(cx, |diff, cx| {
- diff.language_changed(language, language_registry, cx);
- diff.set_snapshot(update, &source_buffer_snapshot.text, cx)
- })
- .await;
- Ok(())
+ diff.update(cx, |diff, cx| diff.set_snapshot(update, cx));
}
impl EventEmitter<EditorEvent> for TextDiffView {}
diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs
index 3f02305a4ac..57612012c84 100644
--- a/crates/language/src/buffer.rs
+++ b/crates/language/src/buffer.rs
@@ -3330,6 +3330,76 @@ impl Buffer {
pub fn set_group_interval(&mut self, group_interval: Duration) {
self.text.set_group_interval(group_interval);
}
+
+ // TODO: see if ep can use this instead of Buffer::branch
+ pub fn snapshot_with_edits<I, S, T>(
+ &mut self,
+ edits: I,
+ cx: &mut Context<Self>,
+ ) -> Task<EditedBufferSnapshot>
+ where
+ I: IntoIterator<Item = (Range<S>, T)>,
+ S: ToOffset,
+ T: Into<Arc<str>>,
+ {
+ let mut snapshot = self.snapshot();
+ let text = snapshot.text.clone();
+ let mut syntax = snapshot.syntax.clone();
+ let language = self.language().cloned();
+ let registry = self.language_registry();
+ let new_text = self.text.snapshot_with_edits(edits);
+ cx.background_spawn(async move {
+ if let Some(language) = language.clone() {
+ syntax.reparse(&text, registry.clone(), language);
+ }
+
+ syntax.interpolate(&new_text.snapshot);
+
+ if let Some(language) = language {
+ syntax.reparse(&new_text.snapshot, registry, language);
+ }
+
+ snapshot.text = new_text.snapshot.clone();
+ snapshot.syntax = syntax;
+
+ EditedBufferSnapshot {
+ text: new_text,
+ snapshot,
+ }
+ })
+ }
+
+ pub fn fast_forward(&mut self, edited: EditedBufferSnapshot, cx: &mut Context<Self>) {
+ let base_version = edited.text.base_version.clone();
+ let did_edit = edited.text.did_edit;
+ self.text.fast_forward(edited.text);
+ if edited.snapshot.language == self.language {
+ self.reparse = None;
+ self.did_finish_parsing(edited.snapshot.syntax, None, cx);
+ if did_edit {
+ cx.emit(BufferEvent::Edited {
+ source: BufferEditSource::User,
+ });
+ }
+ } else {
+ self.did_edit(&base_version, false, BufferEditSource::User, cx);
+ }
+ }
+}
+
+pub struct EditedBufferSnapshot {
+ text: text::EditedBufferSnapshot,
+ snapshot: BufferSnapshot,
+}
+
+impl EditedBufferSnapshot {
+ pub fn snapshot(&self) -> &BufferSnapshot {
+ &self.snapshot
+ }
+
+ pub fn base_version(&self) -> &clock::Global {
+ &self.text.base_version
+ }
}
#[doc(hidden)]
diff --git a/crates/multi_buffer/src/multi_buffer.rs b/crates/multi_buffer/src/multi_buffer.rs
index 1641c460eb2..dd0c24fb5f8 100644
--- a/crates/multi_buffer/src/multi_buffer.rs
+++ b/crates/multi_buffer/src/multi_buffer.rs
@@ -615,6 +615,7 @@ impl DiffState {
changed_range,
base_text_changed_range: _,
extended_range,
+ base_text_changed: _,
}) => {
let use_extended = this.snapshot.borrow().use_extended_diff_range;
let range = if use_extended {
@@ -622,13 +623,10 @@ impl DiffState {
} else {
changed_range.clone()
};
- if let Some(range) = range {
- this.buffer_diff_changed(diff, range, cx)
- }
+ this.buffer_diff_changed(diff, range, cx);
cx.emit(Event::BufferDiffChanged);
}
- BufferDiffEvent::LanguageChanged => this.buffer_diff_language_changed(diff, cx),
- _ => {}
+ BufferDiffEvent::BaseTextChanged | BufferDiffEvent::HunksStagedOrUnstaged(_) => {}
}),
diff,
main_buffer: None,
@@ -652,6 +650,7 @@ impl DiffState {
changed_range: _,
base_text_changed_range,
extended_range: _,
+ base_text_changed: _,
}) => {
this.inverted_buffer_diff_changed(
diff,
@@ -661,10 +660,8 @@ impl DiffState {
);
cx.emit(Event::BufferDiffChanged);
}
- BufferDiffEvent::LanguageChanged => {
- this.inverted_buffer_diff_language_changed(diff, main_buffer, cx)
- }
- _ => {}
+ BufferDiffEvent::BaseTextChanged
+ | BufferDiffEvent::HunksStagedOrUnstaged(_) => {}
}
}
}),
@@ -1973,38 +1970,10 @@ impl MultiBuffer {
});
}
- fn buffer_diff_language_changed(&mut self, diff: Entity<BufferDiff>, cx: &mut Context<Self>) {
- let diff = diff.read(cx);
- let buffer_id = diff.buffer_id;
- let diff = DiffStateSnapshot {
- buffer_id,
- diff: diff.snapshot(cx),
- main_buffer: None,
- };
- self.snapshot.get_mut().diffs.insert_or_replace(diff, ());
- }
-
- fn inverted_buffer_diff_language_changed(
- &mut self,
- diff: Entity<BufferDiff>,
- main_buffer: Entity<language::Buffer>,
- cx: &mut Context<Self>,
- ) {
- let base_text_buffer_id = diff.read(cx).base_text_buffer().read(cx).remote_id();
- let main_buffer_snapshot = main_buffer.read(cx).snapshot();
- let diff = diff.read(cx);
- let diff = DiffStateSnapshot {
- buffer_id: base_text_buffer_id,
- diff: diff.snapshot(cx),
- main_buffer: Some(main_buffer_snapshot),
- };
- self.snapshot.get_mut().diffs.insert_or_replace(diff, ());
- }
-
fn buffer_diff_changed(
&mut self,
diff: Entity<BufferDiff>,
- range: Range<text::Anchor>,
+ range: Option<Range<text::Anchor>>,
cx: &mut Context<Self>,
) {
let Some(buffer) = self.buffer(diff.read(cx).buffer_id) else {
@@ -2029,6 +1998,9 @@ impl MultiBuffer {
snapshot.diffs.insert_or_replace(new_diff, ());
let buffer = buffer.read(cx);
+ let Some(range) = range else {
+ return;
+ };
let diff_change_range = range.to_offset(buffer);
let excerpt_edits = snapshot.excerpt_edits_for_diff_change(&path, diff_change_range);
@@ -2239,7 +2211,7 @@ impl MultiBuffer {
self.buffer_diff_changed(
diff.clone(),
- text::Anchor::min_max_range_for_buffer(buffer_id),
+ Some(text::Anchor::min_max_range_for_buffer(buffer_id)),
cx,
);
self.diffs.insert(buffer_id, DiffState::new(diff, cx));
diff --git a/crates/multi_buffer/src/multi_buffer_tests.rs b/crates/multi_buffer/src/multi_buffer_tests.rs
index 3e71deb8f85..8e52eac1cb1 100644
--- a/crates/multi_buffer/src/multi_buffer_tests.rs
+++ b/crates/multi_buffer/src/multi_buffer_tests.rs
@@ -1,12 +1,13 @@
use super::*;
use buffer_diff::{DiffHunkStatus, DiffHunkStatusKind};
-use gpui::{App, TestAppContext};
+use gpui::{App, Entity, TestAppContext};
use indoc::indoc;
use language::{Buffer, Rope};
use parking_lot::RwLock;
use rand::prelude::*;
use settings::SettingsStore;
use std::env;
+use std::sync::Arc;
use std::time::{Duration, Instant};
use util::RandomCharIter;
use util::rel_path::rel_path;
@@ -4783,21 +4784,19 @@ async fn test_singleton_with_inverted_diff(cx: &mut TestAppContext) {
);
});
cx.run_until_parked();
+ let base_text_snapshot = diff.read_with(cx, |diff, cx| diff.base_text(cx));
+ let buffer_snapshot = buffer.read_with(cx, |buffer, _| buffer.text_snapshot());
let update = diff
.update(cx, |diff, cx| {
diff.update_diff(
- buffer.read(cx).text_snapshot(),
- Some(base_text.into()),
- None,
- None,
+ buffer_snapshot,
+ &base_text_snapshot,
+ Some(Arc::from(base_text)),
cx,
)
})
.await;
- diff.update(cx, |diff, cx| {
- diff.set_snapshot(update, &buffer.read(cx).text_snapshot(), cx)
- })
- .await;
+ diff.update(cx, |diff, cx| diff.set_snapshot(update, cx));
cx.run_until_parked();
assert_new_snapshot(
@@ -4821,21 +4820,19 @@ async fn test_singleton_with_inverted_diff(cx: &mut TestAppContext) {
buffer.set_text("ZERO\nONE\nTWO\n", cx);
});
cx.run_until_parked();
+ let base_text_snapshot = diff.read_with(cx, |diff, cx| diff.base_text(cx));
+ let buffer_snapshot = buffer.read_with(cx, |buffer, _| buffer.text_snapshot());
let update = diff
.update(cx, |diff, cx| {
diff.update_diff(
- buffer.read(cx).text_snapshot(),
- Some(base_text.into()),
- None,
- None,
+ buffer_snapshot,
+ &base_text_snapshot,
+ Some(Arc::from(base_text)),
cx,
)
})
.await;
- diff.update(cx, |diff, cx| {
- diff.set_snapshot(update, &buffer.read(cx).text_snapshot(), cx)
- })
- .await;
+ diff.update(cx, |diff, cx| diff.set_snapshot(update, cx));
cx.run_until_parked();
assert_new_snapshot(
@@ -4858,13 +4855,11 @@ async fn test_singleton_with_inverted_diff(cx: &mut TestAppContext) {
diff.update(cx, |diff, cx| {
diff.set_base_text(
Some("new base\n".into()),
- None,
buffer.read(cx).text_snapshot(),
cx,
)
})
- .await
- .unwrap();
+ .await;
cx.run_until_parked();
assert_new_snapshot(
@@ -4915,21 +4910,10 @@ async fn test_inverted_diff_base_text_change(cx: &mut TestAppContext) {
),
);
- let update = diff
- .update(cx, |diff, cx| {
- diff.update_diff(
- buffer.read(cx).text_snapshot(),
- Some("ddd\n".into()),
- Some(true),
- None,
- cx,
- )
- })
- .await;
diff.update(cx, |diff, cx| {
- diff.set_snapshot(update, &buffer.read(cx).text_snapshot(), cx)
+ diff.set_base_text(Some("ddd\n".into()), buffer.read(cx).text_snapshot(), cx)
})
- .detach();
+ .await;
let _hunks: Vec<_> = multibuffer
.read_with(cx, |multibuffer, cx| multibuffer.snapshot(cx))
@@ -4961,22 +4945,19 @@ async fn test_inverted_diff_secondary_version_mismatch(cx: &mut TestAppContext)
buffer.edit([(0..0, "ZERO\n")], None, cx);
});
+ let base_text_snapshot = unstaged_diff.read_with(cx, |diff, cx| diff.base_text(cx));
+ let buffer_snapshot = buffer.read_with(cx, |buffer, _| buffer.text_snapshot());
let update = unstaged_diff
.update(cx, |diff, cx| {
diff.update_diff(
- buffer.read(cx).text_snapshot(),
- Some(index_text.into()),
- None,
- None,
+ buffer_snapshot,
+ &base_text_snapshot,
+ Some(Arc::from(index_text)),
cx,
)
})
.await;
- unstaged_diff
- .update(cx, |diff, cx| {
- diff.set_snapshot(update, &buffer.read(cx).text_snapshot(), cx)
- })
- .await;
+ unstaged_diff.update(cx, |diff, cx| diff.set_snapshot(update, cx));
let base_text_buffer =
uncommitted_diff.read_with(cx, |diff, _| diff.base_text_buffer().clone());
diff --git a/crates/project/src/git_store.rs b/crates/project/src/git_store.rs
index 70266e2138c..6ec98f522ec 100644
--- a/crates/project/src/git_store.rs
+++ b/crates/project/src/git_store.rs
@@ -51,7 +51,7 @@ use gpui::{
Subscription, Task, TaskExt, WeakEntity,
};
use language::{
- Buffer, BufferEvent, Language, LanguageRegistry,
+ Buffer, BufferEvent, Capability, Language, LanguageRegistry,
proto::{deserialize_version, serialize_version},
};
use parking_lot::Mutex;
@@ -118,6 +118,7 @@ struct SharedDiffs {
struct BufferGitState {
unstaged_diff: Option<WeakEntity<BufferDiff>>,
+ staged_diff: Option<(WeakEntity<BufferDiff>, Entity<Buffer>)>,
uncommitted_diff: Option<WeakEntity<BufferDiff>>,
oid_diffs: HashMap<Option<git::Oid>, WeakEntity<BufferDiff>>,
conflict_set: Option<WeakEntity<ConflictSet>>,
@@ -142,6 +143,9 @@ struct BufferGitState {
head_text: Option<Arc<str>>,
index_text: Option<Arc<str>>,
oid_texts: HashMap<git::Oid, Arc<str>>,
+ head_text_buffer: WeakEntity<Buffer>,
+ index_text_buffer: WeakEntity<Buffer>,
+ index_text_buffer_language_enabled: bool,
head_changed: bool,
index_changed: bool,
language_changed: bool,
@@ -161,6 +165,7 @@ enum DiffBasesChange {
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
enum DiffKind {
Unstaged,
+ Staged,
Uncommitted,
SinceOid(Option<git::Oid>),
}
@@ -931,6 +936,53 @@ impl GitStore {
cx.background_spawn(async move { task.await.map_err(|e| anyhow!("{e}")) })
}
+ pub fn open_staged_diff(
+ &mut self,
+ buffer: Entity<Buffer>,
+ cx: &mut Context<Self>,
+ ) -> Task<Result<Entity<BufferDiff>>> {
+ let buffer_id = buffer.read(cx).remote_id();
+
+ if let Some(diff_state) = self.diffs.get(&buffer_id)
+ && let Some(staged_diff) = diff_state.read(cx).staged_diff()
+ {
+ if let Some(task) =
+ diff_state.update(cx, |diff_state, _| diff_state.wait_for_recalculation())
+ {
+ return cx.background_executor().spawn(async move {
+ task.await;
+ Ok(staged_diff)
+ });
+ }
+ return Task::ready(Ok(staged_diff));
+ }
+
+ let Some((repo, repo_path)) =
+ self.repository_and_path_for_buffer_id(buffer.read(cx).remote_id(), cx)
+ else {
+ return Task::ready(Err(anyhow!("failed to find git repository for buffer")));
+ };
+
+ let task = self
+ .loading_diffs
+ .entry((buffer_id, DiffKind::Staged))
+ .or_insert_with(|| {
+ let changes = repo.update(cx, |repo, cx| {
+ repo.load_committed_text(buffer_id, repo_path, cx)
+ });
+
+ cx.spawn(async move |this, cx| {
+ Self::open_diff_internal(this, DiffKind::Staged, changes.await, buffer, cx)
+ .await
+ .map_err(Arc::new)
+ })
+ .shared()
+ })
+ .clone();
+
+ cx.background_spawn(async move { task.await.map_err(|e| anyhow!("{e}")) })
+ }
+
pub fn open_diff_since(
&mut self,
oid: Option<git::Oid>,
@@ -968,29 +1020,28 @@ impl GitStore {
buffer.update(cx, |buffer, _| buffer.language_registry());
let content: Option<Arc<str>> = match oid {
None => None,
- Some(oid) => Some(
- repo.update(cx, |repo, cx| repo.load_blob_content(oid, cx))
- .await?
- .into(),
- ),
+ Some(oid) => Some({
+ let mut content = repo
+ .update(cx, |repo, cx| repo.load_blob_content(oid, cx))
+ .await?;
+ text::LineEnding::normalize(&mut content);
+ content.into()
+ }),
};
- let buffer_diff = cx.new(|cx| BufferDiff::new(&buffer_snapshot, cx));
+ let buffer_diff = cx.new(|cx| {
+ BufferDiff::new(
+ &buffer_snapshot,
+ buffer_snapshot.language().cloned(),
+ language_registry,
+ cx,
+ )
+ });
buffer_diff
.update(cx, |buffer_diff, cx| {
- buffer_diff.language_changed(
- buffer_snapshot.language().cloned(),
- language_registry,
- cx,
- );
- buffer_diff.set_base_text(
- content.clone(),
- buffer_snapshot.language().cloned(),
- buffer_snapshot.text,
- cx,
- )
+ buffer_diff.set_base_text(content.clone(), buffer_snapshot.text, cx)
})
- .await?;
+ .await;
let unstaged_diff = this
.update(cx, |this, cx| this.open_unstaged_diff(buffer.clone(), cx))?
.await?;
@@ -1008,7 +1059,7 @@ impl GitStore {
let diff_state = this
.diffs
.entry(buffer_id)
- .or_insert_with(|| cx.new(|_| BufferGitState::new(git_store)));
+ .or_insert_with(|| cx.new(|cx| BufferGitState::new(git_store, cx)));
diff_state.update(cx, |state, _| {
if let Some(oid) = oid {
@@ -1122,25 +1173,99 @@ impl GitStore {
let diff_state = this
.diffs
.entry(buffer_id)
- .or_insert_with(|| cx.new(|_| BufferGitState::new(git_store)));
+ .or_insert_with(|| cx.new(|cx| BufferGitState::new(git_store, cx)));
- let diff = cx.new(|cx| BufferDiff::new(&text_snapshot, cx));
+ let existing_unstaged_diff = diff_state.read(cx).unstaged_diff();
- cx.subscribe(&diff, Self::on_buffer_diff_event).detach();
+ let mut staged_index_text_buffer = None;
+ let diff = if kind == DiffKind::Unstaged
+ && let Some(existing_unstaged_diff) = existing_unstaged_diff.clone()
+ {
+ existing_unstaged_diff
+ } else {
+ let diff = match kind {
+ DiffKind::Unstaged => {
+ let base_text_buffer = diff_state.update(cx, |diff_state, cx| {
+ diff_state.get_or_create_index_text_buffer(cx)
+ });
+ cx.new(|cx| {
+ BufferDiff::new_with_base_text_buffer(
+ &text_snapshot,
+ base_text_buffer,
+ cx,
+ )
+ })
+ }
+ DiffKind::Staged => {
+ let (index_text_buffer, base_text_buffer) =
+ diff_state.update(cx, |diff_state, cx| {
+ (
+ diff_state.get_or_create_index_text_buffer(cx),
+ diff_state.get_or_create_head_text_buffer(cx),
+ )
+ });
+ index_text_buffer.update(cx, |index_text_buffer, cx| {
+ if let Some(language_registry) = language_registry.clone() {
+ index_text_buffer.set_language_registry(language_registry);
+ }
+ index_text_buffer.set_language_async(language.clone(), cx);
+ });
+ let index_text_snapshot = index_text_buffer.read(cx).text_snapshot();
+ staged_index_text_buffer = Some(index_text_buffer);
+ cx.new(|cx| {
+ BufferDiff::new_with_base_text_buffer(
+ &index_text_snapshot,
+ base_text_buffer,
+ cx,
+ )
+ })
+ }
+ DiffKind::Uncommitted => {
+ let base_text_buffer = diff_state.update(cx, |diff_state, cx| {
+ diff_state.get_or_create_head_text_buffer(cx)
+ });
+ cx.new(|cx| {
+ BufferDiff::new_with_base_text_buffer(
+ &text_snapshot,
+ base_text_buffer,
+ cx,
+ )
+ })
+ }
+ DiffKind::SinceOid(_) => {
+ unreachable!("open_diff_internal is not used for OID diffs")
+ }
+ };
+ cx.subscribe(&diff, Self::on_buffer_diff_event).detach();
+ diff
+ };
diff_state.update(cx, |diff_state, cx| {
- diff_state.language_changed = true;
diff_state.language = language;
diff_state.language_registry = language_registry;
match kind {
DiffKind::Unstaged => {
- diff_state.unstaged_diff.get_or_insert(diff.downgrade());
+ diff_state.unstaged_diff = Some(diff.downgrade());
+ }
+ DiffKind::Staged => {
+ diff_state.index_text_buffer_language_enabled = true;
+ let index_text_buffer = staged_index_text_buffer
+ .take()
+ .context("index text buffer was not created for staged diff")?;
+ diff_state.staged_diff = Some((diff.downgrade(), index_text_buffer));
}
DiffKind::Uncommitted => {
- let unstaged_diff = if let Some(diff) = diff_state.unstaged_diff() {
+ let unstaged_diff = if let Some(diff) = existing_unstaged_diff {
diff
} else {
- let unstaged_diff = cx.new(|cx| BufferDiff::new(&text_snapshot, cx));
+ let base_text_buffer = diff_state.get_or_create_index_text_buffer(cx);
+ let unstaged_diff = cx.new(|cx| {
+ BufferDiff::new_with_base_text_buffer(
+ &text_snapshot,
+ base_text_buffer,
+ cx,
+ )
+ });
diff_state.unstaged_diff = Some(unstaged_diff.downgrade());
unstaged_diff
};
@@ -1172,6 +1297,11 @@ impl GitStore {
diff_state.read(cx).unstaged_diff.as_ref()?.upgrade()
}
+ pub fn get_staged_diff(&self, buffer_id: BufferId, cx: &App) -> Option<Entity<BufferDiff>> {
+ let diff_state = self.diffs.get(&buffer_id)?;
+ diff_state.read(cx).staged_diff()
+ }
+
pub fn get_uncommitted_diff(
&self,
buffer_id: BufferId,
@@ -1191,6 +1321,17 @@ impl GitStore {
diff_state.read(cx).oid_diff(oid)
}
+ /// Whether this buffer's index text is known to match its committed text
+ /// without comparing contents, i.e. whether the texts share one allocation.
+ /// In a downstream project, this can only be true if the upstream sent
+ /// `Mode::IndexMatchesHead`.
+ #[cfg(any(test, feature = "test-support"))]
+ pub fn index_matches_head_for_buffer(&self, buffer_id: BufferId, cx: &App) -> bool {
+ self.diffs
+ .get(&buffer_id)
+ .is_some_and(|diff_state| diff_state.read(cx).index_matches_head())
+ }
+
pub fn open_conflict_set(
&mut self,
buffer: Entity<Buffer>,
@@ -1225,7 +1366,7 @@ impl GitStore {
let buffer_git_state = self
.diffs
.entry(buffer_id)
- .or_insert_with(|| cx.new(|_| BufferGitState::new(git_store)));
+ .or_insert_with(|| cx.new(|cx| BufferGitState::new(git_store, cx)));
let conflict_set = cx.new(|cx| ConflictSet::new(buffer_id, is_unmerged, cx));
self._subscriptions
@@ -3561,45 +3702,30 @@ impl GitStore {
.or_default();
shared_diffs.entry(buffer_id).or_default().uncommitted = Some(diff.clone());
});
- Ok(diff.read_with(&cx, |diff, cx| {
+ this.read_with(&cx, |this, cx| {
use proto::open_uncommitted_diff_response::Mode;
- let unstaged_diff = diff.secondary_diff();
- let index_snapshot = unstaged_diff.and_then(|diff| {
- let diff = diff.read(cx);
- diff.base_text_exists().then(|| diff.base_text(cx))
- });
+ let diff_state = this.diffs.get(&buffer_id).context("missing diff state")?;
+ let diff_state = diff_state.read(cx);
+ let index_matches_head = diff_state.index_matches_head();
+ let index_text = diff_state.index_text.clone();
+ let head_text = diff_state.head_text.clone();
- let mode;
- let staged_text;
- let committed_text;
- if diff.base_text_exists() {
- let committed_snapshot = diff.base_text(cx);
- committed_text = Some(committed_snapshot.text());
- if let Some(index_text) = index_snapshot {
- if index_text.remote_id() == committed_snapshot.remote_id() {
- mode = Mode::IndexMatchesHead;
- staged_text = None;
- } else {
- mode = Mode::IndexAndHead;
- staged_text = Some(index_text.text());
- }
- } else {
- mode = Mode::IndexAndHead;
- staged_text = None;
+ let response = if index_matches_head {
+ proto::OpenUncommittedDiffResponse {
+ committed_text: head_text.map(|head| head.to_string()),
+ staged_text: None,
+ mode: Mode::IndexMatchesHead.into(),
}
} else {
- mode = Mode::IndexAndHead;
- committed_text = None;
- staged_text = index_snapshot.as_ref().map(|buffer| buffer.text());
- }
-
- proto::OpenUncommittedDiffResponse {
- committed_text,
- staged_text,
- mode: mode.into(),
- }
- }))
+ proto::OpenUncommittedDiffResponse {
+ committed_text: head_text.map(|head| head.to_string()),
+ staged_text: index_text.map(|index| index.to_string()),
+ mode: Mode::IndexAndHead.into(),
+ }
+ };
+ anyhow::Ok(response)
+ })
}
async fn handle_update_diff_bases(
@@ -3794,9 +3920,10 @@ impl GitStore {
}
impl BufferGitState {
- fn new(_git_store: WeakEntity<GitStore>) -> Self {
+ fn new(_git_store: WeakEntity<GitStore>, _cx: &mut Context<Self>) -> Self {
Self {
unstaged_diff: Default::default(),
+ staged_diff: Default::default(),
uncommitted_diff: Default::default(),
oid_diffs: Default::default(),
recalculate_diff_task: Default::default(),
@@ -3808,6 +3935,9 @@ impl BufferGitState {
head_text: Default::default(),
index_text: Default::default(),
oid_texts: Default::default(),
+ head_text_buffer: WeakEntity::new_invalid(),
+ index_text_buffer: WeakEntity::new_invalid(),
+ index_text_buffer_language_enabled: Default::default(),
head_changed: Default::default(),
index_changed: Default::default(),
language_changed: Default::default(),
@@ -3817,6 +3947,34 @@ impl BufferGitState {
}
}
+ fn get_or_create_head_text_buffer(&mut self, cx: &mut Context<Self>) -> Entity<Buffer> {
+ if let Some(buffer) = self.head_text_buffer.upgrade() {
+ return buffer;
+ }
+ let head_text = self.head_text.clone();
+ let buffer = cx.new(|cx| {
+ let mut buffer = Buffer::local(head_text.as_deref().unwrap_or(""), cx);
+ buffer.set_capability(Capability::ReadOnly, cx);
+ buffer
+ });
+ self.head_text_buffer = buffer.downgrade();
+ buffer
+ }
+
+ fn get_or_create_index_text_buffer(&mut self, cx: &mut Context<Self>) -> Entity<Buffer> {
+ if let Some(buffer) = self.index_text_buffer.upgrade() {
+ return buffer;
+ }
+ let index_text = self.index_text.clone();
+ let buffer = cx.new(|cx| {
+ let mut buffer = Buffer::local(index_text.as_deref().unwrap_or(""), cx);
+ buffer.set_capability(Capability::ReadOnly, cx);
+ buffer
+ });
+ self.index_text_buffer = buffer.downgrade();
+ buffer
+ }
+
#[ztracing::instrument(skip_all)]
fn buffer_language_changed(&mut self, buffer: Entity<Buffer>, cx: &mut Context<Self>) {
self.language = buffer.read(cx).language().cloned();
@@ -3876,6 +4034,10 @@ impl BufferGitState {
self.unstaged_diff.as_ref().and_then(|set| set.upgrade())
}
+ fn staged_diff(&self) -> Option<Entity<BufferDiff>> {
+ self.staged_diff.as_ref().and_then(|(set, _)| set.upgrade())
+ }
+
fn uncommitted_diff(&self) -> Option<Entity<BufferDiff>> {
self.uncommitted_diff.as_ref().and_then(|set| set.upgrade())
}
@@ -3884,6 +4046,19 @@ impl BufferGitState {
self.oid_diffs.get(&oid).and_then(|weak| weak.upgrade())
}
+ /// Whether the index text is known to match the committed text, without
+ /// comparing their contents. Always true when both texts were set by a
+ /// single `DiffBasesChange::SetBoth`, which shares one allocation between
+ /// them. May be false even when the contents are equal, if the texts were
+ /// loaded separately.
+ fn index_matches_head(&self) -> bool {
+ match (self.index_text.as_ref(), self.head_text.as_ref()) {
+ (Some(index), Some(head)) => Arc::ptr_eq(index, head),
+ (None, None) => true,
+ _ => false,
+ }
+ }
+
fn handle_base_texts_updated(
&mut self,
buffer: text::BufferSnapshot,
@@ -3981,25 +4156,35 @@ impl BufferGitState {
let language = self.language.clone();
let language_registry = self.language_registry.clone();
let unstaged_diff = self.unstaged_diff();
+ let staged_diff = self.staged_diff();
let uncommitted_diff = self.uncommitted_diff();
let head = self.head_text.clone();
let index = self.index_text.clone();
+ let head_text_buffer = self.head_text_buffer.upgrade();
+ let index_text_buffer = self.index_text_buffer.upgrade();
+ let index_text_buffer_language_enabled = self.index_text_buffer_language_enabled;
let index_changed = self.index_changed;
let head_changed = self.head_changed;
let language_changed = self.language_changed;
let prev_hunk_staging_operation_count = self.hunk_staging_operation_count_as_of_write;
- let index_matches_head = match (self.index_text.as_ref(), self.head_text.as_ref()) {
- (Some(index), Some(head)) => Arc::ptr_eq(index, head),
- (None, None) => true,
- _ => false,
- };
-
- let oid_diffs: Vec<(Option<git::Oid>, Entity<BufferDiff>, Option<Arc<str>>)> = self
+ let index_matches_head = self.index_matches_head();
+
+ let oid_diffs: Vec<(
+ Option<git::Oid>,
+ Entity<BufferDiff>,
+ Entity<Buffer>,
+ Option<Arc<str>>,
+ )> = self
.oid_diffs
.iter()
.filter_map(|(oid, weak)| {
- let base_text = oid.and_then(|oid| self.oid_texts.get(&oid).cloned());
- weak.upgrade().map(|diff| (*oid, diff, base_text))
+ let diff = weak.upgrade()?;
+ let base_text_buffer = diff.read(cx).base_text_buffer().clone();
+ let base_text = match oid {
+ Some(oid) => Some(self.oid_texts.get(oid)?.clone()),
+ None => None,
+ };
+ Some((*oid, diff, base_text_buffer, base_text))
})
.collect();
@@ -4012,21 +4197,86 @@ impl BufferGitState {
}
alive
});
+ if self
+ .staged_diff
+ .as_ref()
+ .is_some_and(|(weak, _)| !weak.is_upgradable())
+ {
+ self.staged_diff = None;
+ }
self.recalculate_diff_task = Some(cx.spawn(async move |this, cx| {
log::debug!(
"start recalculating diffs for buffer {}",
buffer.remote_id()
);
+ if index_text_buffer_language_enabled
+ && let Some(index_text_buffer) = &index_text_buffer
+ {
+ index_text_buffer.update(cx, |index_text_buffer, cx| {
+ if let Some(language_registry) = language_registry.clone() {
+ index_text_buffer.set_language_registry(language_registry);
+ }
+ index_text_buffer.set_language_async(language.clone(), cx);
+ });
+ }
+ if let Some(head_text_buffer) = &head_text_buffer {
+ head_text_buffer.update(cx, |head_text_buffer, cx| {
+ if let Some(language_registry) = language_registry.clone() {
+ head_text_buffer.set_language_registry(language_registry);
+ }
+ head_text_buffer.set_language_async(language.clone(), cx);
+ });
+ }
+
+ for (_, _, base_text_buffer, _) in &oid_diffs {
+ base_text_buffer.update(cx, |base_text_buffer, cx| {
+ if let Some(language_registry) = language_registry.clone() {
+ base_text_buffer.set_language_registry(language_registry);
+ }
+ base_text_buffer.set_language_async(language.clone(), cx);
+ });
+ }
+
+ let mut edited_index_text = None;
+
+ let index_text_snapshot = if let Some(index_text_buffer) = &index_text_buffer
+ && (unstaged_diff.is_some() || staged_diff.is_some())
+ {
+ let index_text_snapshot = if index_changed || language_changed {
+ let new_index_text = index.clone().unwrap_or_default();
+ let index_text_diff = index_text_buffer
+ .update(cx, |index_text_buffer, cx| {
+ index_text_buffer.diff(new_index_text.clone(), cx)
+ })
+ .await;
+ let edited = index_text_buffer
+ .update(cx, |index_text_buffer, cx| {
+ index_text_buffer.snapshot_with_edits(index_text_diff.edits, cx)
+ })
+ .await;
+ let snapshot = edited.snapshot().clone();
+ edited_index_text = Some(edited);
+ snapshot
+ } else {
+ index_text_buffer.read_with(cx, |buffer, _| buffer.snapshot())
+ };
+ Some(index_text_snapshot)
+ } else {
+ None
+ };
+
let mut new_unstaged_diff = None;
- if let Some(unstaged_diff) = &unstaged_diff {
+
+ if let (Some(unstaged_diff), Some(index_text_snapshot)) =
+ (unstaged_diff.as_ref(), index_text_snapshot.as_ref())
+ {
new_unstaged_diff = Some(
cx.update(|cx| {
unstaged_diff.read(cx).update_diff(
buffer.clone(),
- index,
- index_changed.then_some(false),
- language.clone(),
+ index_text_snapshot,
+ index.clone(),
cx,
)
})
@@ -4038,23 +4288,72 @@ impl BufferGitState {
// for a bit
yield_now().await;
+ let mut edited_head_text = None;
+ let mut new_staged_diff = None;
let mut new_uncommitted_diff = None;
- if let Some(uncommitted_diff) = &uncommitted_diff {
- new_uncommitted_diff = if index_matches_head {
- new_unstaged_diff.clone()
+ if let Some(head_text_buffer) = &head_text_buffer
+ && (staged_diff.is_some() || uncommitted_diff.is_some())
+ {
+ let head_base_text_exists = head.is_some();
+ let head_text_snapshot = if head_changed || language_changed {
+ let new_head_text = head.clone().unwrap_or_default();
+ let head_text_diff = head_text_buffer
+ .update(cx, |head_text_buffer, cx| {
+ head_text_buffer.diff(new_head_text.clone(), cx)
+ })
+ .await;
+ let edited = head_text_buffer
+ .update(cx, |base_text_buffer, cx| {
+ base_text_buffer.snapshot_with_edits(head_text_diff.edits, cx)
+ })
+ .await;
+ let snapshot = edited.snapshot().clone();
+ edited_head_text = Some(edited);
+ snapshot
} else {
- Some(
+ head_text_buffer.read_with(cx, |buffer, _| buffer.snapshot())
+ };
+ if let (Some(staged_diff), Some(index_base_text_snapshot)) =
+ (staged_diff.as_ref(), index_text_snapshot.as_ref())
+ {
+ new_staged_diff = Some(
cx.update(|cx| {
- uncommitted_diff.read(cx).update_diff(
- buffer.clone(),
- head,
- head_changed.then_some(true),
- language.clone(),
+ staged_diff.read(cx).update_diff(
+ index_base_text_snapshot.text.clone(),
+ &head_text_snapshot,
+ head.clone(),
cx,
)
})
.await,
- )
+ );
+ }
+
+ if let Some(uncommitted_diff) = &uncommitted_diff {
+ new_uncommitted_diff = if index_matches_head {
+ new_unstaged_diff.clone().map(|mut update| {
+ update.set_base_text_snapshot(
+ head_text_snapshot.clone(),
+ head_base_text_exists,
+ );
+ update
+ })
+ } else {
+ None
+ };
+ if new_uncommitted_diff.is_none() {
+ new_uncommitted_diff = Some(
+ cx.update(|cx| {
+ uncommitted_diff.read(cx).update_diff(
+ buffer.clone(),
+ &head_text_snapshot,
+ head.clone(),
+ cx,
+ )
+ })
+ .await,
+ );
+ }
}
}
@@ -4087,64 +4386,84 @@ impl BufferGitState {
return Ok(());
}
- let unstaged_changed_range = if let Some((unstaged_diff, new_unstaged_diff)) =
- unstaged_diff.as_ref().zip(new_unstaged_diff.clone())
- {
- let task = unstaged_diff.update(cx, |diff, cx| {
- // For git index buffer we skip assigning the language as we do not really need to perform any syntax highlighting on
- // it. As a result, by skipping it we are potentially shaving off a lot of RSS plus we get a snappier feel for large diff
- // view multibuffers.
- diff.set_snapshot(new_unstaged_diff, &buffer, cx)
- });
- Some(task.await)
- } else {
- None
- };
+ this.update(cx, |_, cx| {
+ if let (Some(staged_diff), Some(new_staged_diff)) =
+ (staged_diff.as_ref(), new_staged_diff.clone())
+ {
+ staged_diff.update(cx, |diff, cx| {
+ if let Some(edited_base_text) = edited_index_text.take()
+ && let Some(index_text_buffer) = &index_text_buffer
+ {
+ index_text_buffer.update(cx, |index_text_buffer, cx| {
+ index_text_buffer.fast_forward(edited_base_text, cx)
+ });
+ }
+ if let Some(edited_head_text) = edited_head_text.take()
+ && let Some(head_text_buffer) = &head_text_buffer
+ {
+ head_text_buffer.update(cx, |head_text_buffer, cx| {
+ head_text_buffer.fast_forward(edited_head_text, cx)
+ });
+ }
+ diff.set_snapshot(new_staged_diff, cx)
+ });
+ }
- yield_now().await;
+ let unstaged_changed_range = if let (Some(unstaged_diff), Some(new_unstaged_diff)) =
+ (unstaged_diff.as_ref(), new_unstaged_diff.clone())
+ {
+ Some(unstaged_diff.update(cx, |diff, cx| {
+ if let Some(edited_index_text) = edited_index_text.take()
+ && let Some(index_text_buffer) = &index_text_buffer
+ {
+ index_text_buffer.update(cx, |index_text_buffer, cx| {
+ index_text_buffer.fast_forward(edited_index_text, cx)
+ });
+ }
+ diff.set_snapshot(new_unstaged_diff, cx)
+ }))
+ } else {
+ None
+ };
- if let Some((uncommitted_diff, new_uncommitted_diff)) =
- uncommitted_diff.as_ref().zip(new_uncommitted_diff.clone())
- {
- uncommitted_diff
- .update(cx, |diff, cx| {
- if language_changed {
- diff.language_changed(language.clone(), language_registry.clone(), cx);
+ if let (Some(uncommitted_diff), Some(new_uncommitted_diff)) =
+ (uncommitted_diff.as_ref(), new_uncommitted_diff.clone())
+ {
+ uncommitted_diff.update(cx, |diff, cx| {
+ if let Some(edited_base_text) = edited_head_text.take()
+ && let Some(head_text_buffer) = &head_text_buffer
+ {
+ head_text_buffer.update(cx, |head_text_buffer, cx| {
+ head_text_buffer.fast_forward(edited_base_text, cx)
+ });
}
diff.set_snapshot_with_secondary(
new_uncommitted_diff,
- &buffer,
unstaged_changed_range.flatten(),
true,
cx,
)
- })
- .await;
- }
+ });
+ }
+ })?;
yield_now().await;
- for (oid, oid_diff, base_text) in oid_diffs {
+ for (oid, oid_diff, base_text_buffer, base_text) in oid_diffs {
+ let base_text_snapshot =
+ base_text_buffer.read_with(cx, |buffer, _| buffer.snapshot());
let new_oid_diff = cx
.update(|cx| {
oid_diff.read(cx).update_diff(
buffer.clone(),
- base_text,
- None,
- language.clone(),
+ &base_text_snapshot,
+ base_text.clone(),
cx,
)
})
.await;
- oid_diff
- .update(cx, |diff, cx| {
- if language_changed {
- diff.language_changed(language.clone(), language_registry.clone(), cx);
- }
- diff.set_snapshot(new_oid_diff, &buffer, cx)
- })
- .await;
+ oid_diff.update(cx, |diff, cx| diff.set_snapshot(new_oid_diff, cx));
log::debug!(
"finished recalculating oid diff for buffer {} oid {:?}",
@@ -4805,6 +5124,10 @@ impl Repository {
.unstaged_diff
.as_ref()
.is_some_and(|diff| diff.is_upgradable());
+ let has_staged_diff = diff_state
+ .staged_diff
+ .as_ref()
+ .is_some_and(|(diff, _)| diff.is_upgradable());
let has_uncommitted_diff = diff_state
.uncommitted_diff
.as_ref()
@@ -4814,8 +5137,10 @@ impl Repository {
buffer,
repo_path,
is_symlink,
- has_unstaged_diff.then(|| diff_state.index_text.clone()),
- has_uncommitted_diff.then(|| diff_state.head_text.clone()),
+ (has_unstaged_diff || has_staged_diff)
+ .then(|| diff_state.index_text.clone()),
+ (has_staged_diff || has_uncommitted_diff)
+ .then(|| diff_state.head_text.clone()),
))
})
})
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index d03b341a8ac..061f8265ab3 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -3219,6 +3219,19 @@ impl Project {
.update(cx, |git_store, cx| git_store.open_unstaged_diff(buffer, cx))
}
+ #[ztracing::instrument(skip_all)]
+ pub fn open_staged_diff(
+ &mut self,
+ buffer: Entity<Buffer>,
+ cx: &mut Context<Self>,
+ ) -> Task<Result<Entity<BufferDiff>>> {
+ if self.is_disconnected(cx) {
+ return Task::ready(Err(anyhow!(ErrorCode::Disconnected)));
+ }
+ self.git_store
+ .update(cx, |git_store, cx| git_store.open_staged_diff(buffer, cx))
+ }
+
#[ztracing::instrument(skip_all)]
pub fn open_uncommitted_diff(
&mut self,
diff --git a/crates/project/tests/integration/project_tests.rs b/crates/project/tests/integration/project_tests.rs
index af276a0aa40..674a2ace910 100644
--- a/crates/project/tests/integration/project_tests.rs
+++ b/crates/project/tests/integration/project_tests.rs
@@ -9198,6 +9198,412 @@ async fn test_unstaged_diff_for_buffer(cx: &mut gpui::TestAppContext) {
});
}
+#[gpui::test]
+async fn test_reopening_unstaged_diff_after_drop(cx: &mut gpui::TestAppContext) {
+ init_test(cx);
+
+ let staged_contents = r#"
+ fn main() {
+ println!("hello world");
+ }
+ "#
+ .unindent();
+ let file_contents = r#"
+ // print goodbye
+ fn main() {
+ println!("goodbye world");
+ }
+ "#
+ .unindent();
+
+ let fs = FakeFs::new(cx.background_executor.clone());
+ fs.insert_tree(
+ "/dir",
+ json!({
+ ".git": {},
+ "src": {
+ "main.rs": file_contents,
+ }
+ }),
+ )
+ .await;
+ fs.set_index_for_repo(Path::new("/dir/.git"), &[("src/main.rs", staged_contents)]);
+
+ let project = Project::test(fs.clone(), ["/dir".as_ref()], cx).await;
+ let buffer = project
+ .update(cx, |project, cx| {
+ project.open_local_buffer("/dir/src/main.rs", cx)
+ })
+ .await
+ .unwrap();
+ let buffer_id = buffer.read_with(cx, |buffer, _| buffer.remote_id());
+
+ let unstaged_diff = project
+ .update(cx, |project, cx| {
+ project.open_unstaged_diff(buffer.clone(), cx)
+ })
+ .await
+ .unwrap();
+ cx.run_until_parked();
+
+ // Drop the diff while the buffer (and its git state) stays alive.
+ drop(unstaged_diff);
+ cx.run_until_parked();
+ project.read_with(cx, |project, cx| {
+ assert!(
+ project
+ .git_store()
+ .read(cx)
+ .get_unstaged_diff(buffer_id, cx)
+ .is_none(),
+ "unstaged diff should have been released"
+ );
+ });
+
+ // Reopen the diff. The new entity must be registered in the git store,
+ // and its hunks must be recalculated.
+ let unstaged_diff = project
+ .update(cx, |project, cx| {
+ project.open_unstaged_diff(buffer.clone(), cx)
+ })
+ .await
+ .unwrap();
+ cx.run_until_parked();
+
+ project.read_with(cx, |project, cx| {
+ let registered = project
+ .git_store()
+ .read(cx)
+ .get_unstaged_diff(buffer_id, cx);
+ assert_eq!(
+ registered.as_ref(),
+ Some(&unstaged_diff),
+ "reopened unstaged diff should be registered in the git store"
+ );
+ });
+
+ unstaged_diff.update(cx, |unstaged_diff, cx| {
+ let snapshot = buffer.read(cx).snapshot();
+ assert_hunks(
+ unstaged_diff.snapshot(cx).hunks(&snapshot),
+ &snapshot,
+ &unstaged_diff.base_text_string(cx).unwrap(),
+ &[
+ (0..1, "", "// print goodbye\n", DiffHunkStatus::added_none()),
+ (
+ 2..3,
+ " println!(\"hello world\");\n",
+ " println!(\"goodbye world\");\n",
+ DiffHunkStatus::modified_none(),
+ ),
+ ],
+ );
+ });
+}
+
+#[gpui::test]
+async fn test_staged_diff_for_buffer(cx: &mut gpui::TestAppContext) {
+ init_test(cx);
+
+ let committed_contents = r#"
+ fn main() {
+ println!("hello world");
+ }
+ "#
+ .unindent();
+ let staged_contents = r#"
+ // print goodbye
+ fn main() {
+ println!("goodbye world");
+ }
+ "#
+ .unindent();
+ let file_contents = r#"
+ // print goodbye
+ fn main() {
+ println!("working copy only");
+ }
+ "#
+ .unindent();
+
+ let fs = FakeFs::new(cx.background_executor.clone());
+ fs.insert_tree(
+ "/dir",
+ json!({
+ ".git": {},
+ "src": {
+ "main.rs": file_contents,
+ }
+ }),
+ )
+ .await;
+ fs.set_head_for_repo(
+ Path::new("/dir/.git"),
+ &[("src/main.rs", committed_contents)],
+ "deadbeef",
+ );
+ fs.set_index_for_repo(Path::new("/dir/.git"), &[("src/main.rs", staged_contents)]);
+
+ let project = Project::test(fs.clone(), ["/dir".as_ref()], cx).await;
+ let language_registry = project.read_with(cx, |project, _| project.languages().clone());
+ let language = rust_lang();
+ language_registry.add(language.clone());
+
+ let buffer = project
+ .update(cx, |project, cx| {
+ project.open_local_buffer("/dir/src/main.rs", cx)
+ })
+ .await
+ .unwrap();
+ let unstaged_diff = project
+ .update(cx, |project, cx| {
+ project.open_unstaged_diff(buffer.clone(), cx)
+ })
+ .await
+ .unwrap();
+ cx.run_until_parked();
+ unstaged_diff.read_with(cx, |diff, cx| {
+ assert_eq!(diff.base_text(cx).language().cloned(), None);
+ });
+
+ let staged_diff = project
+ .update(cx, |project, cx| {
+ project.open_staged_diff(buffer.clone(), cx)
+ })
+ .await
+ .unwrap();
+
+ cx.run_until_parked();
+ unstaged_diff.read_with(cx, |diff, cx| {
+ assert_eq!(
+ diff.base_text(cx).language().cloned(),
+ Some(language.clone())
+ );
+ });
+ staged_diff.update(cx, |staged_diff, cx| {
+ let snapshot = staged_diff.snapshot(cx);
+ let buffer_snapshot = snapshot.buffer_snapshot();
+ assert_hunks(
+ snapshot.hunks(buffer_snapshot),
+ buffer_snapshot,
+ &staged_diff.base_text_string(cx).unwrap(),
+ &[
+ (0..1, "", "// print goodbye\n", DiffHunkStatus::added_none()),
+ (
+ 2..3,
+ " println!(\"hello world\");\n",
+ " println!(\"goodbye world\");\n",
+ DiffHunkStatus::modified_none(),
+ ),
+ ],
+ );
+ });
+
+ let staged_contents = r#"
+ // print goodbye
+ fn main() {
+ }
+ "#
+ .unindent();
+ fs.set_index_for_repo(Path::new("/dir/.git"), &[("src/main.rs", staged_contents)]);
+
+ cx.run_until_parked();
+ staged_diff.update(cx, |staged_diff, cx| {
+ let snapshot = staged_diff.snapshot(cx);
+ let buffer_snapshot = snapshot.buffer_snapshot();
+ assert_hunks(
+ snapshot.hunks(buffer_snapshot),
+ buffer_snapshot,
+ &staged_diff.base_text_string(cx).unwrap(),
+ &[
+ (0..1, "", "// print goodbye\n", DiffHunkStatus::added_none()),
+ (
+ 2..2,
+ " println!(\"hello world\");\n",
+ "",
+ DiffHunkStatus::deleted_none(),
+ ),
+ ],
+ );
+ });
+}
+
+#[gpui::test]
+async fn test_base_text_buffers_released_when_diffs_dropped(cx: &mut gpui::TestAppContext) {
+ init_test(cx);
+
+ let committed_contents = "one\ntwo\nthree\n";
+ let staged_contents = "one\nTWO\nthree\n";
+ let file_contents = "one\nTWO\nTHREE\n";
+
+ let fs = FakeFs::new(cx.background_executor.clone());
+ fs.insert_tree(
+ "/dir",
+ json!({
+ ".git": {},
+ "src": {
+ "main.rs": file_contents,
+ }
+ }),
+ )
+ .await;
+ fs.set_head_for_repo(
+ Path::new("/dir/.git"),
+ &[("src/main.rs", committed_contents.to_owned())],
+ "deadbeef",
+ );
+ fs.set_index_for_repo(
+ Path::new("/dir/.git"),
+ &[("src/main.rs", staged_contents.to_owned())],
+ );
+
+ let project = Project::test(fs.clone(), ["/dir".as_ref()], cx).await;
+ let buffer = project
+ .update(cx, |project, cx| {
+ project.open_local_buffer("/dir/src/main.rs", cx)
+ })
+ .await
+ .unwrap();
+
+ let uncommitted_diff = project
+ .update(cx, |project, cx| {
+ project.open_uncommitted_diff(buffer.clone(), cx)
+ })
+ .await
+ .unwrap();
+ let unstaged_diff = project
+ .update(cx, |project, cx| {
+ project.open_unstaged_diff(buffer.clone(), cx)
+ })
+ .await
+ .unwrap();
+ cx.run_until_parked();
+
+ let weak_head_text_buffer =
+ uncommitted_diff.read_with(cx, |diff, _| diff.base_text_buffer().downgrade());
+ let weak_index_text_buffer =
+ unstaged_diff.read_with(cx, |diff, _| diff.base_text_buffer().downgrade());
+
+ drop(uncommitted_diff);
+ cx.run_until_parked();
+ cx.update(|_| {});
+ weak_head_text_buffer.assert_released();
+ assert!(
+ weak_index_text_buffer.upgrade().is_some(),
+ "index text buffer should stay alive while the unstaged diff is open"
+ );
+
+ drop(unstaged_diff);
+ cx.run_until_parked();
+ cx.update(|_| {});
+ weak_index_text_buffer.assert_released();
+
+ let uncommitted_diff = project
+ .update(cx, |project, cx| {
+ project.open_uncommitted_diff(buffer.clone(), cx)
+ })
+ .await
+ .unwrap();
+ cx.run_until_parked();
+ uncommitted_diff.update(cx, |uncommitted_diff, cx| {
+ assert_eq!(
+ uncommitted_diff.base_text_string(cx).as_deref(),
+ Some(committed_contents),
+ );
+ let snapshot = buffer.read(cx).snapshot();
+ assert_hunks(
+ uncommitted_diff.snapshot(cx).hunks(&snapshot),
+ &snapshot,
+ &uncommitted_diff.base_text_string(cx).unwrap(),
+ &[(
+ 1..3,
+ "two\nthree\n",
+ "TWO\nTHREE\n",
+ DiffHunkStatus::modified(DiffHunkSecondaryStatus::OverlapsWithSecondaryHunk),
+ )],
+ );
+ });
+}
+
+#[gpui::test]
+async fn test_staged_diff_without_unstaged_diff(cx: &mut gpui::TestAppContext) {
+ init_test(cx);
+
+ let committed_contents = "one\ntwo\nthree\n";
+ let staged_contents = "one\nTWO\nthree\n";
+ let file_contents = "one\nTWO\nthree\n";
+
+ let fs = FakeFs::new(cx.background_executor.clone());
+ fs.insert_tree(
+ "/dir",
+ json!({
+ ".git": {},
+ "src": {
+ "main.rs": file_contents,
+ }
+ }),
+ )
+ .await;
+ fs.set_head_for_repo(
+ Path::new("/dir/.git"),
+ &[("src/main.rs", committed_contents.to_owned())],
+ "deadbeef",
+ );
+ fs.set_index_for_repo(
+ Path::new("/dir/.git"),
+ &[("src/main.rs", staged_contents.to_owned())],
+ );
+
+ let project = Project::test(fs.clone(), ["/dir".as_ref()], cx).await;
+ let buffer = project
+ .update(cx, |project, cx| {
+ project.open_local_buffer("/dir/src/main.rs", cx)
+ })
+ .await
+ .unwrap();
+
+ let staged_diff = project
+ .update(cx, |project, cx| {
+ project.open_staged_diff(buffer.clone(), cx)
+ })
+ .await
+ .unwrap();
+ cx.run_until_parked();
+
+ staged_diff.update(cx, |staged_diff, cx| {
+ let snapshot = staged_diff.snapshot(cx);
+ let buffer_snapshot = snapshot.buffer_snapshot();
+ assert_hunks(
+ snapshot.hunks(buffer_snapshot),
+ buffer_snapshot,
+ &staged_diff.base_text_string(cx).unwrap(),
+ &[(1..2, "two\n", "TWO\n", DiffHunkStatus::modified_none())],
+ );
+ });
+
+ fs.set_index_for_repo(
+ Path::new("/dir/.git"),
+ &[("src/main.rs", "one\nTWO\nTHREE\n".to_owned())],
+ );
+ cx.run_until_parked();
+
+ staged_diff.update(cx, |staged_diff, cx| {
+ let snapshot = staged_diff.snapshot(cx);
+ let buffer_snapshot = snapshot.buffer_snapshot();
+ assert_hunks(
+ snapshot.hunks(buffer_snapshot),
+ buffer_snapshot,
+ &staged_diff.base_text_string(cx).unwrap(),
+ &[(
+ 1..3,
+ "two\nthree\n",
+ "TWO\nTHREE\n",
+ DiffHunkStatus::modified_none(),
+ )],
+ );
+ });
+}
+
#[gpui::test]
async fn test_uncommitted_diff_for_buffer(cx: &mut gpui::TestAppContext) {
init_test(cx);
@@ -9521,6 +9927,7 @@ async fn test_staging_hunks(cx: &mut gpui::TestAppContext) {
changed_range: Some(changed_range),
base_text_changed_range: _,
extended_range: _,
+ base_text_changed: _,
}) = event
{
let changed_range = changed_range.to_point(&snapshot);
@@ -9565,10 +9972,11 @@ async fn test_staging_hunks(cx: &mut gpui::TestAppContext) {
changed_range: Some(changed_range),
base_text_changed_range: _,
extended_range: _,
+ base_text_changed: _,
}) = event
{
let changed_range = changed_range.to_point(&snapshot);
- assert_eq!(changed_range, Point::new(0, 0)..Point::new(4, 0));
+ assert_eq!(changed_range, Point::new(1, 0)..Point::new(2, 0));
} else {
panic!("Unexpected event {event:?}");
}
@@ -9624,6 +10032,7 @@ async fn test_staging_hunks(cx: &mut gpui::TestAppContext) {
changed_range: Some(changed_range),
base_text_changed_range: _,
extended_range: _,
+ base_text_changed: _,
}) = event
{
let changed_range = changed_range.to_point(&snapshot);
@@ -9667,6 +10076,7 @@ async fn test_staging_hunks(cx: &mut gpui::TestAppContext) {
changed_range: Some(changed_range),
base_text_changed_range: _,
extended_range: _,
+ base_text_changed: _,
}) = event
{
let changed_range = changed_range.to_point(&snapshot);
@@ -9776,13 +10186,32 @@ async fn test_uncommitted_diff_opened_before_unstaged_diff(cx: &mut gpui::TestAp
let unstaged_diff_task = project.update(cx, |project, cx| {
project.open_unstaged_diff(buffer.clone(), cx)
});
- let (uncommitted_diff, _unstaged_diff) =
+ let (uncommitted_diff, unstaged_diff) =
futures::future::join(uncommitted_diff_task, unstaged_diff_task).await;
let uncommitted_diff = uncommitted_diff.unwrap();
- let _unstaged_diff = _unstaged_diff.unwrap();
+ let unstaged_diff = unstaged_diff.unwrap();
cx.run_until_parked();
+ uncommitted_diff.read_with(cx, |diff, _| {
+ assert_eq!(
+ diff.secondary_diff(),
+ Some(unstaged_diff.clone()),
+ "the unstaged diff returned to callers should be the uncommitted diff's secondary"
+ );
+ });
+ project.read_with(cx, |project, cx| {
+ let buffer_id = buffer.read(cx).remote_id();
+ assert_eq!(
+ project
+ .git_store()
+ .read(cx)
+ .get_unstaged_diff(buffer_id, cx),
+ Some(unstaged_diff.clone()),
+ "the unstaged diff returned to callers should be the registered one"
+ );
+ });
+
uncommitted_diff.read_with(cx, |diff, cx| {
let snapshot = buffer.read(cx).snapshot();
assert_hunks(
diff --git a/crates/text/src/text.rs b/crates/text/src/text.rs
index 66f93e781f7..b83875dbdb1 100644
--- a/crates/text/src/text.rs
+++ b/crates/text/src/text.rs
@@ -894,163 +894,11 @@ impl Buffer {
edits: impl ExactSizeIterator<Item = (Range<S>, T)>,
timestamp: clock::Lamport,
) -> EditOperation {
- let mut edits_patch = Patch::default();
- let mut edit_op = EditOperation {
- timestamp,
- version: self.version(),
- ranges: Vec::with_capacity(edits.len()),
- new_text: Vec::with_capacity(edits.len()),
- };
- let mut new_insertions = Vec::new();
- let mut insertion_offset: u32 = 0;
- let mut insertion_slices = Vec::new();
-
- let mut edits = edits
- .map(|(range, new_text)| (range.to_offset(&*self), new_text))
- .peekable();
-
- let mut new_ropes =
- RopeBuilder::new(self.visible_text.cursor(0), self.deleted_text.cursor(0));
- let mut old_fragments = self.fragments.cursor::<FragmentTextSummary>(&None);
- let mut new_fragments =
- FragmentBuilder::new(old_fragments.slice(&edits.peek().unwrap().0.start, Bias::Right));
- new_ropes.append(new_fragments.summary().text);
-
- let mut fragment_start = old_fragments.start().visible;
- for (range, new_text) in edits {
- let new_text = LineEnding::normalize_arc(new_text.into());
- let fragment_end = old_fragments.end().visible;
-
- // If the current fragment ends before this range, then jump ahead to the first fragment
- // that extends past the start of this range, reusing any intervening fragments.
- if fragment_end < range.start {
- // If the current fragment has been partially consumed, then consume the rest of it
- // and advance to the next fragment before slicing.
- if fragment_start > old_fragments.start().visible {
- if fragment_end > fragment_start {
- let mut suffix = old_fragments.item().unwrap().clone();
- suffix.len = (fragment_end - fragment_start) as u32;
- suffix.insertion_offset +=
- (fragment_start - old_fragments.start().visible) as u32;
- new_insertions.push(InsertionFragment::insert_new(&suffix));
- new_ropes.push_fragment(&suffix, suffix.visible);
- new_fragments.push(suffix, &None);
- }
- old_fragments.next();
- }
-
- let slice = old_fragments.slice(&range.start, Bias::Right);
- new_ropes.append(slice.summary().text);
- new_fragments.append(slice, &None);
- fragment_start = old_fragments.start().visible;
- }
-
- let full_range_start = FullOffset(range.start + old_fragments.start().deleted);
-
- // Preserve any portion of the current fragment that precedes this range.
- if fragment_start < range.start {
- let mut prefix = old_fragments.item().unwrap().clone();
- prefix.len = (range.start - fragment_start) as u32;
- prefix.insertion_offset += (fragment_start - old_fragments.start().visible) as u32;
- prefix.id = Locator::between(&new_fragments.summary().max_id, &prefix.id);
- new_insertions.push(InsertionFragment::insert_new(&prefix));
- new_ropes.push_fragment(&prefix, prefix.visible);
- new_fragments.push(prefix, &None);
- fragment_start = range.start;
- }
-
- // Insert the new text before any existing fragments within the range.
- if !new_text.is_empty() {
- let new_start = new_fragments.summary().text.visible;
-
- let next_fragment_id = old_fragments
- .item()
- .map_or(Locator::max_ref(), |old_fragment| &old_fragment.id);
- Self::push_fragments_for_insertion(
- new_text.as_ref(),
- timestamp,
- &mut insertion_offset,
- &mut new_fragments,
- &mut new_insertions,
- &mut insertion_slices,
- &mut new_ropes,
- next_fragment_id,
- timestamp,
- );
- edits_patch.push(Edit {
- old: fragment_start..fragment_start,
- new: new_start..new_start + new_text.len(),
- });
- }
-
- // Advance through every fragment that intersects this range, marking the intersecting
- // portions as deleted.
- while fragment_start < range.end {
- let fragment = old_fragments.item().unwrap();
- let fragment_end = old_fragments.end().visible;
- let mut intersection = fragment.clone();
- let intersection_end = cmp::min(range.end, fragment_end);
- if fragment.visible {
- intersection.len = (intersection_end - fragment_start) as u32;
- intersection.insertion_offset +=
- (fragment_start - old_fragments.start().visible) as u32;
- intersection.id =
- Locator::between(&new_fragments.summary().max_id, &intersection.id);
- intersection.deletions.push(timestamp);
- intersection.visible = false;
- }
- if intersection.len > 0 {
- if fragment.visible && !intersection.visible {
- let new_start = new_fragments.summary().text.visible;
- edits_patch.push(Edit {
- old: fragment_start..intersection_end,
- new: new_start..new_start,
- });
- insertion_slices
- .push(InsertionSlice::from_fragment(timestamp, &intersection));
- }
- new_insertions.push(InsertionFragment::insert_new(&intersection));
- new_ropes.push_fragment(&intersection, fragment.visible);
- new_fragments.push(intersection, &None);
- fragment_start = intersection_end;
- }
- if fragment_end <= range.end {
- old_fragments.next();
- }
- }
-
- let full_range_end = FullOffset(range.end + old_fragments.start().deleted);
- edit_op.ranges.push(full_range_start..full_range_end);
- edit_op.new_text.push(new_text);
- }
-
- // If the current fragment has been partially consumed, then consume the rest of it
- // and advance to the next fragment before slicing.
- if fragment_start > old_fragments.start().visible {
- let fragment_end = old_fragments.end().visible;
- if fragment_end > fragment_start {
- let mut suffix = old_fragments.item().unwrap().clone();
- suffix.len = (fragment_end - fragment_start) as u32;
- suffix.insertion_offset += (fragment_start - old_fragments.start().visible) as u32;
- new_insertions.push(InsertionFragment::insert_new(&suffix));
- new_ropes.push_fragment(&suffix, suffix.visible);
- new_fragments.push(suffix, &None);
- }
- old_fragments.next();
- }
-
- let suffix = old_fragments.suffix();
- new_ropes.append(suffix.summary().text);
- new_fragments.append(suffix, &None);
- let (visible_text, deleted_text) = new_ropes.finish();
- drop(old_fragments);
-
- self.snapshot.fragments = new_fragments.to_sum_tree(&None);
- self.snapshot.insertions.edit(new_insertions, ());
- self.snapshot.visible_text = visible_text;
- self.snapshot.deleted_text = deleted_text;
+ let edits: Vec<_> = edits
+ .map(|(range, new_text)| (range.to_offset(&*self), new_text.into()))
+ .collect();
+ let (edit_op, edits_patch) = self.snapshot.apply_edit_internal(edits, timestamp);
self.subscriptions.publish_mut(&edits_patch);
- self.snapshot.insertion_slices.extend(insertion_slices);
edit_op
}
@@ -1213,7 +1061,7 @@ impl Buffer {
let next_fragment_id = old_fragments
.item()
.map_or(Locator::max_ref(), |old_fragment| &old_fragment.id);
- Self::push_fragments_for_insertion(
+ push_fragments_for_insertion(
new_text,
timestamp,
&mut insertion_offset,
@@ -1301,49 +1149,6 @@ impl Buffer {
self.subscriptions.publish_mut(&edits_patch)
}
- fn push_fragments_for_insertion(
- new_text: &str,
- timestamp: clock::Lamport,
- insertion_offset: &mut u32,
- new_fragments: &mut FragmentBuilder,
- new_insertions: &mut Vec<sum_tree::Edit<InsertionFragment>>,
- insertion_slices: &mut Vec<InsertionSlice>,
- new_ropes: &mut RopeBuilder,
- next_fragment_id: &Locator,
- edit_timestamp: clock::Lamport,
- ) {
- let mut text_offset = 0;
- while text_offset < new_text.len() {
- let target_end = new_text.len().min(text_offset + MAX_INSERTION_LEN);
- let chunk_end = if target_end == new_text.len() {
- target_end
- } else {
- new_text.floor_char_boundary(target_end)
- };
- if chunk_end == text_offset {
- break;
- }
- let chunk_len = chunk_end - text_offset;
-
- let fragment = Fragment {
- id: Locator::between(&new_fragments.summary().max_id, next_fragment_id),
- timestamp,
- insertion_offset: *insertion_offset,
- len: chunk_len as u32,
- deletions: Default::default(),
- max_undos: Default::default(),
- visible: true,
- };
- insertion_slices.push(InsertionSlice::from_fragment(edit_timestamp, &fragment));
- new_insertions.push(InsertionFragment::insert_new(&fragment));
- new_fragments.push(fragment, &None);
-
- *insertion_offset += chunk_len as u32;
- text_offset = chunk_end;
- }
- new_ropes.push_str(new_text);
- }
-
fn fragment_ids_for_edits<'a>(
&'a self,
edit_ids: impl Iterator<Item = &'a clock::Lamport>,
@@ -1832,6 +1637,51 @@ impl Buffer {
pub fn set_group_interval(&mut self, group_interval: Duration) {
self.history.group_interval = group_interval;
}
+
+ pub fn snapshot_with_edits<I, S, T>(&mut self, edits: I) -> EditedBufferSnapshot
+ where
+ I: IntoIterator<Item = (Range<S>, T)>,
+ S: ToOffset,
+ T: Into<Arc<str>>,
+ {
+ let mut snapshot = self.snapshot.clone();
+ let base_version = self.version();
+ let edits: Vec<_> = edits
+ .into_iter()
+ .map(|(range, new_text)| (range.to_offset(&snapshot), new_text.into()))
+ .collect();
+ if edits.is_empty() {
+ return EditedBufferSnapshot {
+ base_version,
+ snapshot,
+ did_edit: false,
+ };
+ }
+ let timestamp = self.lamport_clock.tick();
+ snapshot.apply_edit_internal(edits, timestamp);
+ snapshot.version.observe(timestamp);
+ EditedBufferSnapshot {
+ base_version,
+ snapshot,
+ did_edit: true,
+ }
+ }
+
+ pub fn fast_forward(&mut self, edited: EditedBufferSnapshot) {
+ if self.version.changed_since(&edited.base_version) {
+ panic!("buffer cannot be fast-forwarded")
+ }
+ self.snapshot = edited.snapshot.clone();
+ for timestamp in edited.snapshot.version.iter() {
+ self.lamport_clock.observe(timestamp);
+ }
+ }
+}
+
+pub struct EditedBufferSnapshot {
+ pub base_version: clock::Global,
+ pub snapshot: BufferSnapshot,
+ pub did_edit: bool,
}
#[cfg(any(test, feature = "test-support"))]
@@ -2011,6 +1861,49 @@ impl Buffer {
}
}
+fn push_fragments_for_insertion(
+ new_text: &str,
+ timestamp: clock::Lamport,
+ insertion_offset: &mut u32,
+ new_fragments: &mut FragmentBuilder,
+ new_insertions: &mut Vec<sum_tree::Edit<InsertionFragment>>,
+ insertion_slices: &mut Vec<InsertionSlice>,
+ new_ropes: &mut RopeBuilder,
+ next_fragment_id: &Locator,
+ edit_timestamp: clock::Lamport,
+) {
+ let mut text_offset = 0;
+ while text_offset < new_text.len() {
+ let target_end = new_text.len().min(text_offset + MAX_INSERTION_LEN);
+ let chunk_end = if target_end == new_text.len() {
+ target_end
+ } else {
+ new_text.floor_char_boundary(target_end)
+ };
+ if chunk_end == text_offset {
+ break;
+ }
+ let chunk_len = chunk_end - text_offset;
+
+ let fragment = Fragment {
+ id: Locator::between(&new_fragments.summary().max_id, next_fragment_id),
+ timestamp,
+ insertion_offset: *insertion_offset,
+ len: chunk_len as u32,
+ deletions: Default::default(),
+ max_undos: Default::default(),
+ visible: true,
+ };
+ insertion_slices.push(InsertionSlice::from_fragment(edit_timestamp, &fragment));
+ new_insertions.push(InsertionFragment::insert_new(&fragment));
+ new_fragments.push(fragment, &None);
+
+ *insertion_offset += chunk_len as u32;
+ text_offset = chunk_end;
+ }
+ new_ropes.push_str(new_text);
+}
+
impl Deref for Buffer {
type Target = BufferSnapshot;
@@ -2020,6 +1913,162 @@ impl Deref for Buffer {
}
impl BufferSnapshot {
+ fn apply_edit_internal(
+ &mut self,
+ edits: Vec<(Range<usize>, Arc<str>)>,
+ timestamp: clock::Lamport,
+ ) -> (EditOperation, Patch<usize>) {
+ let mut edits_patch = Patch::default();
+ let mut edit_op = EditOperation {
+ timestamp,
+ version: self.version.clone(),
+ ranges: Vec::with_capacity(edits.len()),
+ new_text: Vec::with_capacity(edits.len()),
+ };
+ let mut new_insertions = Vec::new();
+ let mut insertion_offset: u32 = 0;
+ let mut insertion_slices = Vec::new();
+
+ let mut edits = edits.into_iter().peekable();
+
+ if edits.peek().is_none() {
+ return (edit_op, edits_patch);
+ }
+
+ let mut new_ropes =
+ RopeBuilder::new(self.visible_text.cursor(0), self.deleted_text.cursor(0));
+ let mut old_fragments = self.fragments.cursor::<FragmentTextSummary>(&None);
+ let mut new_fragments =
+ FragmentBuilder::new(old_fragments.slice(&edits.peek().unwrap().0.start, Bias::Right));
+ new_ropes.append(new_fragments.summary().text);
+
+ let mut fragment_start = old_fragments.start().visible;
+ for (range, new_text) in edits {
+ let new_text: Arc<str> = LineEnding::normalize_arc(new_text);
+ let fragment_end = old_fragments.end().visible;
+
+ if fragment_end < range.start {
+ if fragment_start > old_fragments.start().visible {
+ if fragment_end > fragment_start {
+ let mut suffix = old_fragments.item().unwrap().clone();
+ suffix.len = (fragment_end - fragment_start) as u32;
+ suffix.insertion_offset +=
+ (fragment_start - old_fragments.start().visible) as u32;
+ new_insertions.push(InsertionFragment::insert_new(&suffix));
+ new_ropes.push_fragment(&suffix, suffix.visible);
+ new_fragments.push(suffix, &None);
+ }
+ old_fragments.next();
+ }
+
+ let slice = old_fragments.slice(&range.start, Bias::Right);
+ new_ropes.append(slice.summary().text);
+ new_fragments.append(slice, &None);
+ fragment_start = old_fragments.start().visible;
+ }
+
+ let full_range_start = FullOffset(range.start + old_fragments.start().deleted);
+
+ if fragment_start < range.start {
+ let mut prefix = old_fragments.item().unwrap().clone();
+ prefix.len = (range.start - fragment_start) as u32;
+ prefix.insertion_offset += (fragment_start - old_fragments.start().visible) as u32;
+ prefix.id = Locator::between(&new_fragments.summary().max_id, &prefix.id);
+ new_insertions.push(InsertionFragment::insert_new(&prefix));
+ new_ropes.push_fragment(&prefix, prefix.visible);
+ new_fragments.push(prefix, &None);
+ fragment_start = range.start;
+ }
+
+ if !new_text.is_empty() {
+ let new_start = new_fragments.summary().text.visible;
+
+ let next_fragment_id = old_fragments
+ .item()
+ .map_or(Locator::max_ref(), |old_fragment| &old_fragment.id);
+ push_fragments_for_insertion(
+ new_text.as_ref(),
+ timestamp,
+ &mut insertion_offset,
+ &mut new_fragments,
+ &mut new_insertions,
+ &mut insertion_slices,
+ &mut new_ropes,
+ next_fragment_id,
+ timestamp,
+ );
+ edits_patch.push(Edit {
+ old: fragment_start..fragment_start,
+ new: new_start..new_start + new_text.len(),
+ });
+ }
+
+ while fragment_start < range.end {
+ let fragment = old_fragments.item().unwrap();
+ let fragment_end = old_fragments.end().visible;
+ let mut intersection = fragment.clone();
+ let intersection_end = cmp::min(range.end, fragment_end);
+ if fragment.visible {
+ intersection.len = (intersection_end - fragment_start) as u32;
+ intersection.insertion_offset +=
+ (fragment_start - old_fragments.start().visible) as u32;
+ intersection.id =
+ Locator::between(&new_fragments.summary().max_id, &intersection.id);
+ intersection.deletions.push(timestamp);
+ intersection.visible = false;
+ }
+ if intersection.len > 0 {
+ if fragment.visible && !intersection.visible {
+ let new_start = new_fragments.summary().text.visible;
+ edits_patch.push(Edit {
+ old: fragment_start..intersection_end,
+ new: new_start..new_start,
+ });
+ insertion_slices
+ .push(InsertionSlice::from_fragment(timestamp, &intersection));
+ }
+ new_insertions.push(InsertionFragment::insert_new(&intersection));
+ new_ropes.push_fragment(&intersection, fragment.visible);
+ new_fragments.push(intersection, &None);
+ fragment_start = intersection_end;
+ }
+ if fragment_end <= range.end {
+ old_fragments.next();
+ }
+ }
+
+ let full_range_end = FullOffset(range.end + old_fragments.start().deleted);
+ edit_op.ranges.push(full_range_start..full_range_end);
+ edit_op.new_text.push(new_text);
+ }
+
+ if fragment_start > old_fragments.start().visible {
+ let fragment_end = old_fragments.end().visible;
+ if fragment_end > fragment_start {
+ let mut suffix = old_fragments.item().unwrap().clone();
+ suffix.len = (fragment_end - fragment_start) as u32;
+ suffix.insertion_offset += (fragment_start - old_fragments.start().visible) as u32;
+ new_insertions.push(InsertionFragment::insert_new(&suffix));
+ new_ropes.push_fragment(&suffix, suffix.visible);
+ new_fragments.push(suffix, &None);
+ }
+ old_fragments.next();
+ }
+
+ let suffix = old_fragments.suffix();
+ new_ropes.append(suffix.summary().text);
+ new_fragments.append(suffix, &None);
+ let (visible_text, deleted_text) = new_ropes.finish();
+ drop(old_fragments);
+
+ self.fragments = new_fragments.to_sum_tree(&None);
+ self.insertions.edit(new_insertions, ());
+ self.visible_text = visible_text;
+ self.deleted_text = deleted_text;
+ self.insertion_slices.extend(insertion_slices);
+ (edit_op, edits_patch)
+ }
+
pub fn as_rope(&self) -> &Rope {
&self.visible_text
}