Yehowshua/ZIm
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Add staged status information to diff hunks (#24475)

Browse source 
Release Notes:

- Render unstaged hunks in the project diff editor with a slashed
background

---------

Co-authored-by: maxbrunsfeld <max@zed.dev>
Co-authored-by: Max Brunsfeld <maxbrunsfeld@gmail.com>
This commit is contained in:
Cole Miller 2025-02-10 21:43:25 -05:00 • committed by GitHub
parent a9de9e3cb4
commit 8f75fe25e5
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
28 changed files with 1132 additions and 753 deletions
Download patch file Download diff file Expand all files Collapse all files

217
crates/multi_buffer/src/multi_buffer.rs
View file

@ -7,9 +7,11 @@ pub use anchor::{Anchor, AnchorRangeExt, Offset};
pub use position::{TypedOffset, TypedPoint, TypedRow};
use anyhow::{anyhow, Result};
use buffer_diff::{
BufferDiff, BufferDiffEvent, BufferDiffSnapshot, DiffHunkSecondaryStatus, DiffHunkStatus,
};
use clock::ReplicaId;
use collections::{BTreeMap, Bound, HashMap, HashSet};
use diff::{BufferDiff, BufferDiffEvent, BufferDiffSnapshot, DiffHunkStatus};
use futures::{channel::mpsc, SinkExt};
use gpui::{App, Context, Entity, EntityId, EventEmitter, Task};
use itertools::Itertools;
@ -129,16 +131,18 @@ pub struct MultiBufferDiffHunk {
pub excerpt_id: ExcerptId,
/// The range within the buffer's diff base that this hunk corresponds to.
pub diff_base_byte_range: Range<usize>,
/// Whether or not this hunk also appears in the 'secondary diff'.
pub secondary_status: DiffHunkSecondaryStatus,
}
impl MultiBufferDiffHunk {
pub fn status(&self) -> DiffHunkStatus {
if self.buffer_range.start == self.buffer_range.end {
DiffHunkStatus::Removed
DiffHunkStatus::Removed(self.secondary_status)
} else if self.diff_base_byte_range.is_empty() {
DiffHunkStatus::Added
DiffHunkStatus::Added(self.secondary_status)
} else {
DiffHunkStatus::Modified
DiffHunkStatus::Modified(self.secondary_status)
}
}
}
@ -225,7 +229,14 @@ impl DiffState {
DiffState {
_subscription: cx.subscribe(&diff, |this, diff, event, cx| match event {
BufferDiffEvent::DiffChanged { changed_range } => {
this.buffer_diff_changed(diff, changed_range.clone(), cx)
let changed_range = if let Some(changed_range) = changed_range {
changed_range.clone()
} else if diff.read(cx).base_text().is_none() && this.all_diff_hunks_expanded {
text::Anchor::MIN..text::Anchor::MAX
} else {
return;
};
this.buffer_diff_changed(diff, changed_range, cx)
}
BufferDiffEvent::LanguageChanged => this.buffer_diff_language_changed(diff, cx),
}),
@ -241,7 +252,7 @@ pub struct MultiBufferSnapshot {
excerpts: SumTree<Excerpt>,
excerpt_ids: SumTree<ExcerptIdMapping>,
diffs: TreeMap<BufferId, BufferDiffSnapshot>,
pub diff_transforms: SumTree<DiffTransform>,
diff_transforms: SumTree<DiffTransform>,
trailing_excerpt_update_count: usize,
non_text_state_update_count: usize,
edit_count: usize,
@ -252,20 +263,27 @@ pub struct MultiBufferSnapshot {
}
#[derive(Debug, Clone)]
pub enum DiffTransform {
enum DiffTransform {
BufferContent {
summary: TextSummary,
inserted_hunk_anchor: Option<(ExcerptId, text::Anchor)>,
inserted_hunk_info: Option<DiffTransformHunkInfo>,
},
DeletedHunk {
summary: TextSummary,
buffer_id: BufferId,
hunk_anchor: (ExcerptId, text::Anchor),
hunk_info: DiffTransformHunkInfo,
base_text_byte_range: Range<usize>,
has_trailing_newline: bool,
},
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
struct DiffTransformHunkInfo {
excerpt_id: ExcerptId,
hunk_start_anchor: text::Anchor,
hunk_secondary_status: DiffHunkSecondaryStatus,
}
#[derive(Clone)]
pub struct ExcerptInfo {
pub id: ExcerptId,
@ -310,7 +328,7 @@ pub struct RowInfo {
pub buffer_id: Option<BufferId>,
pub buffer_row: Option<u32>,
pub multibuffer_row: Option<MultiBufferRow>,
pub diff_status: Option<diff::DiffHunkStatus>,
pub diff_status: Option<buffer_diff::DiffHunkStatus>,
}
/// A slice into a [`Buffer`] that is being edited in a [`MultiBuffer`].
@ -431,7 +449,7 @@ struct MultiBufferCursor<'a, D: TextDimension> {
struct MultiBufferRegion<'a, D: TextDimension> {
buffer: &'a BufferSnapshot,
is_main_buffer: bool,
is_inserted_hunk: bool,
diff_hunk_status: Option<DiffHunkStatus>,
excerpt: &'a Excerpt,
buffer_range: Range<D>,
range: Range<D>,
@ -2146,7 +2164,7 @@ impl MultiBuffer {
let mut snapshot = self.snapshot.borrow_mut();
let diff = diff.read(cx);
let buffer_id = diff.buffer_id;
let diff = diff.snapshot.clone();
let diff = diff.snapshot(cx);
snapshot.diffs.insert(buffer_id, diff);
}
@ -2160,36 +2178,29 @@ impl MultiBuffer {
let diff = diff.read(cx);
let buffer_id = diff.buffer_id;
let mut diff = diff.snapshot.clone();
if diff.base_text.is_none() && self.all_diff_hunks_expanded {
diff = BufferDiffSnapshot::new_with_single_insertion(cx);
}
let mut snapshot = self.snapshot.borrow_mut();
let base_text_changed =
snapshot
.diffs
.get(&buffer_id)
.map_or(true, |diff_snapshot| {
match (&diff_snapshot.base_text, &diff.base_text) {
(None, None) => false,
(None, Some(_)) => true,
(Some(_), None) => true,
(Some(old), Some(new)) => {
let (old_id, old_empty) = (old.remote_id(), old.is_empty());
let (new_id, new_empty) = (new.remote_id(), new.is_empty());
new_id != old_id && (!new_empty || !old_empty)
}
}
});
snapshot.diffs.insert(buffer_id, diff);
let buffers = self.buffers.borrow();
let Some(buffer_state) = buffers.get(&buffer_id) else {
return;
};
let diff_change_range = range.to_offset(buffer_state.buffer.read(cx));
let buffer = buffer_state.buffer.read(cx);
let diff_change_range = range.to_offset(buffer);
let mut new_diff = diff.snapshot(cx);
if new_diff.base_text().is_none() && self.all_diff_hunks_expanded {
let secondary_diff_insertion = new_diff
.secondary_diff()
.map_or(true, |secondary_diff| secondary_diff.base_text().is_none());
new_diff = BufferDiff::build_with_single_insertion(secondary_diff_insertion, cx);
}
let mut snapshot = self.snapshot.borrow_mut();
let base_text_changed = snapshot
.diffs
.get(&buffer_id)
.map_or(true, |old_diff| !new_diff.base_texts_eq(old_diff));
snapshot.diffs.insert(buffer_id, new_diff);
let mut excerpt_edits = Vec::new();
for locator in &buffer_state.excerpts {
@ -2367,7 +2378,7 @@ impl MultiBuffer {
if *cursor.start() >= end {
break;
}
if item.hunk_anchor().is_some() {
if item.hunk_info().is_some() {
return true;
}
cursor.next(&());
@ -2820,11 +2831,11 @@ impl MultiBuffer {
let keep_next_old_transform = (old_diff_transforms.start().0 >= edit.old.end)
&& match old_diff_transforms.item() {
Some(DiffTransform::BufferContent {
inserted_hunk_anchor: Some(hunk_anchor),
inserted_hunk_info: Some(hunk),
..
}) => excerpts
.item()
.is_some_and(|excerpt| hunk_anchor.1.is_valid(&excerpt.buffer)),
}) => excerpts.item().is_some_and(|excerpt| {
hunk.hunk_start_anchor.is_valid(&excerpt.buffer)
}),
_ => true,
};
@ -2853,7 +2864,7 @@ impl MultiBuffer {
new_diff_transforms.push(
DiffTransform::BufferContent {
summary: Default::default(),
inserted_hunk_anchor: None,
inserted_hunk_info: None,
},
&(),
);
@ -2876,8 +2887,8 @@ impl MultiBuffer {
excerpts: &mut Cursor<Excerpt, TypedOffset<Excerpt>>,
old_diff_transforms: &mut Cursor<DiffTransform, (TypedOffset<Excerpt>, usize)>,
new_diff_transforms: &mut SumTree<DiffTransform>,
end_of_current_insert: &mut Option<(TypedOffset<Excerpt>, ExcerptId, text::Anchor)>,
old_expanded_hunks: &mut HashSet<(ExcerptId, text::Anchor)>,
end_of_current_insert: &mut Option<(TypedOffset<Excerpt>, DiffTransformHunkInfo)>,
old_expanded_hunks: &mut HashSet<DiffTransformHunkInfo>,
snapshot: &MultiBufferSnapshot,
change_kind: DiffChangeKind,
) -> bool {
@ -2889,12 +2900,12 @@ impl MultiBuffer {
// Record which hunks were previously expanded.
while let Some(item) = old_diff_transforms.item() {
if let Some(hunk_anchor) = item.hunk_anchor() {
if let Some(hunk_info) = item.hunk_info() {
log::trace!(
"previously expanded hunk at {}",
old_diff_transforms.start().0
);
old_expanded_hunks.insert(hunk_anchor);
old_expanded_hunks.insert(hunk_info);
}
if old_diff_transforms.end(&()).0 > edit.old.end {
break;
@ -2918,7 +2929,7 @@ impl MultiBuffer {
if let Some((diff, base_text)) = snapshot
.diffs
.get(&excerpt.buffer_id)
.and_then(|diff| Some((diff, diff.base_text.as_ref()?)))
.and_then(|diff| Some((diff, diff.base_text()?)))
{
let buffer = &excerpt.buffer;
let excerpt_start = *excerpts.start();
@ -2936,7 +2947,11 @@ impl MultiBuffer {
for hunk in diff.hunks_intersecting_range(edit_anchor_range, buffer) {
let hunk_buffer_range = hunk.buffer_range.to_offset(buffer);
let hunk_anchor = (excerpt.id, hunk.buffer_range.start);
let hunk_info = DiffTransformHunkInfo {
excerpt_id: excerpt.id,
hunk_start_anchor: hunk.buffer_range.start,
hunk_secondary_status: hunk.secondary_status,
};
if hunk_buffer_range.start < excerpt_buffer_start {
log::trace!("skipping hunk that starts before excerpt");
continue;
@ -2960,7 +2975,7 @@ impl MultiBuffer {
// For every existing hunk, determine if it was previously expanded
// and if it should currently be expanded.
let was_previously_expanded = old_expanded_hunks.contains(&hunk_anchor);
let was_previously_expanded = old_expanded_hunks.contains(&hunk_info);
let should_expand_hunk = match &change_kind {
DiffChangeKind::DiffUpdated { base_changed: true } => {
self.all_diff_hunks_expanded
@ -3008,7 +3023,7 @@ impl MultiBuffer {
base_text_byte_range: hunk.diff_base_byte_range.clone(),
summary: base_text_summary,
buffer_id: excerpt.buffer_id,
hunk_anchor,
hunk_info,
has_trailing_newline,
},
&(),
@ -3016,11 +3031,8 @@ impl MultiBuffer {
}
if !hunk_buffer_range.is_empty() {
*end_of_current_insert = Some((
hunk_excerpt_end.min(excerpt_end),
hunk_anchor.0,
hunk_anchor.1,
));
*end_of_current_insert =
Some((hunk_excerpt_end.min(excerpt_end), hunk_info));
}
}
}
@ -3042,13 +3054,13 @@ impl MultiBuffer {
subtree: SumTree<DiffTransform>,
) {
if let Some(DiffTransform::BufferContent {
inserted_hunk_anchor,
inserted_hunk_info,
summary,
}) = subtree.first()
{
if self.extend_last_buffer_content_transform(
new_transforms,
*inserted_hunk_anchor,
*inserted_hunk_info,
*summary,
) {
let mut cursor = subtree.cursor::<()>(&());
@ -3067,7 +3079,7 @@ impl MultiBuffer {
transform: DiffTransform,
) {
if let DiffTransform::BufferContent {
inserted_hunk_anchor,
inserted_hunk_info: inserted_hunk_anchor,
summary,
} = transform
{
@ -3087,19 +3099,14 @@ impl MultiBuffer {
old_snapshot: &MultiBufferSnapshot,
new_transforms: &mut SumTree<DiffTransform>,
end_offset: ExcerptOffset,
current_inserted_hunk: Option<(ExcerptOffset, ExcerptId, text::Anchor)>,
current_inserted_hunk: Option<(ExcerptOffset, DiffTransformHunkInfo)>,
) {
let inserted_region =
current_inserted_hunk.map(|(insertion_end_offset, excerpt_id, anchor)| {
(
end_offset.min(insertion_end_offset),
Some((excerpt_id, anchor)),
)
});
let inserted_region = current_inserted_hunk.map(|(insertion_end_offset, hunk_info)| {
(end_offset.min(insertion_end_offset), Some(hunk_info))
});
let unchanged_region = [(end_offset, None)];
for (end_offset, inserted_hunk_anchor) in
inserted_region.into_iter().chain(unchanged_region)
for (end_offset, inserted_hunk_info) in inserted_region.into_iter().chain(unchanged_region)
{
let start_offset = new_transforms.summary().excerpt_len();
if end_offset <= start_offset {
@ -3110,13 +3117,13 @@ impl MultiBuffer {
if !self.extend_last_buffer_content_transform(
new_transforms,
inserted_hunk_anchor,
inserted_hunk_info,
summary_to_add,
) {
new_transforms.push(
DiffTransform::BufferContent {
summary: summary_to_add,
inserted_hunk_anchor,
inserted_hunk_info,
},
&(),
)
@ -3127,7 +3134,7 @@ impl MultiBuffer {
fn extend_last_buffer_content_transform(
&self,
new_transforms: &mut SumTree<DiffTransform>,
new_inserted_hunk_anchor: Option<(ExcerptId, text::Anchor)>,
new_inserted_hunk_info: Option<DiffTransformHunkInfo>,
summary_to_add: TextSummary,
) -> bool {
let mut did_extend = false;
@ -3135,10 +3142,10 @@ impl MultiBuffer {
|last_transform| {
if let DiffTransform::BufferContent {
summary,
inserted_hunk_anchor,
inserted_hunk_info: inserted_hunk_anchor,
} = last_transform
{
if *inserted_hunk_anchor == new_inserted_hunk_anchor {
if *inserted_hunk_anchor == new_inserted_hunk_info {
*summary += summary_to_add;
did_extend = true;
}
@ -3469,6 +3476,7 @@ impl MultiBufferSnapshot {
excerpt_id: excerpt.id,
buffer_range: hunk.buffer_range.clone(),
diff_base_byte_range: hunk.diff_base_byte_range.clone(),
secondary_status: hunk.secondary_status,
})
})
}
@ -3837,6 +3845,7 @@ impl MultiBufferSnapshot {
excerpt_id: excerpt.id,
buffer_range: hunk.buffer_range.clone(),
diff_base_byte_range: hunk.diff_base_byte_range.clone(),
secondary_status: hunk.secondary_status,
});
}
}
@ -4309,10 +4318,7 @@ impl MultiBufferSnapshot {
} => {
let buffer_start = base_text_byte_range.start + start_overshoot;
let mut buffer_end = base_text_byte_range.start + end_overshoot;
let Some(base_text) = self
.diffs
.get(buffer_id)
.and_then(|diff| diff.base_text.as_ref())
let Some(base_text) = self.diffs.get(buffer_id).and_then(|diff| diff.base_text())
else {
panic!("{:?} is in non-existent deleted hunk", range.start)
};
@ -4361,10 +4367,7 @@ impl MultiBufferSnapshot {
..
} => {
let buffer_end = base_text_byte_range.start + overshoot;
let Some(base_text) = self
.diffs
.get(buffer_id)
.and_then(|diff| diff.base_text.as_ref())
let Some(base_text) = self.diffs.get(buffer_id).and_then(|diff| diff.base_text())
else {
panic!("{:?} is in non-existent deleted hunk", range.end)
};
@ -4469,10 +4472,8 @@ impl MultiBufferSnapshot {
}) => {
let mut in_deleted_hunk = false;
if let Some(diff_base_anchor) = &anchor.diff_base_anchor {
if let Some(base_text) = self
.diffs
.get(buffer_id)
.and_then(|diff| diff.base_text.as_ref())
if let Some(base_text) =
self.diffs.get(buffer_id).and_then(|diff| diff.base_text())
{
if base_text.can_resolve(&diff_base_anchor) {
let base_text_offset = diff_base_anchor.to_offset(&base_text);
@ -4809,7 +4810,7 @@ impl MultiBufferSnapshot {
let base_text = self
.diffs
.get(buffer_id)
.and_then(|diff| diff.base_text.as_ref())
.and_then(|diff| diff.base_text())
.expect("missing diff base");
if offset_in_transform > base_text_byte_range.len() {
debug_assert!(*has_trailing_newline);
@ -5969,17 +5970,17 @@ impl MultiBufferSnapshot {
for item in self.diff_transforms.iter() {
if let DiffTransform::BufferContent {
summary,
inserted_hunk_anchor,
inserted_hunk_info,
} = item
{
if let Some(DiffTransform::BufferContent {
inserted_hunk_anchor: prev_inserted_hunk_anchor,
inserted_hunk_info: prev_inserted_hunk_info,
..
}) = prev_transform
{
if *inserted_hunk_anchor == *prev_inserted_hunk_anchor {
if *inserted_hunk_info == *prev_inserted_hunk_info {
panic!(
"multiple adjacent buffer content transforms with is_inserted_hunk = {inserted_hunk_anchor:?}. transforms: {:+?}",
"multiple adjacent buffer content transforms with is_inserted_hunk = {inserted_hunk_info:?}. transforms: {:+?}",
self.diff_transforms.items(&()));
}
}
@ -6149,10 +6150,11 @@ where
buffer_id,
base_text_byte_range,
has_trailing_newline,
hunk_info,
..
} => {
let diff = self.diffs.get(&buffer_id)?;
let buffer = diff.base_text.as_ref()?;
let buffer = diff.base_text()?;
let mut rope_cursor = buffer.as_rope().cursor(0);
let buffer_start = rope_cursor.summary::<D>(base_text_byte_range.start);
let buffer_range_len = rope_cursor.summary::<D>(base_text_byte_range.end);
@ -6165,14 +6167,15 @@ where
excerpt,
has_trailing_newline: *has_trailing_newline,
is_main_buffer: false,
is_inserted_hunk: false,
diff_hunk_status: Some(DiffHunkStatus::Removed(
hunk_info.hunk_secondary_status,
)),
buffer_range: buffer_start..buffer_end,
range: start..end,
});
}
DiffTransform::BufferContent {
inserted_hunk_anchor,
..
inserted_hunk_info, ..
} => {
let buffer = &excerpt.buffer;
let buffer_context_start = excerpt.range.context.start.summary::<D>(buffer);
@ -6209,7 +6212,8 @@ where
excerpt,
has_trailing_newline,
is_main_buffer: true,
is_inserted_hunk: inserted_hunk_anchor.is_some(),
diff_hunk_status: inserted_hunk_info
.map(|info| DiffHunkStatus::Added(info.hunk_secondary_status)),
buffer_range: buffer_start..buffer_end,
range: start..end,
})
@ -6717,13 +6721,12 @@ impl sum_tree::KeyedItem for ExcerptIdMapping {
}
impl DiffTransform {
fn hunk_anchor(&self) -> Option<(ExcerptId, text::Anchor)> {
fn hunk_info(&self) -> Option<DiffTransformHunkInfo> {
match self {
DiffTransform::DeletedHunk { hunk_anchor, .. } => Some(*hunk_anchor),
DiffTransform::DeletedHunk { hunk_info, .. } => Some(*hunk_info),
DiffTransform::BufferContent {
inserted_hunk_anchor,
..
} => *inserted_hunk_anchor,
inserted_hunk_info, ..
} => *inserted_hunk_info,
}
}
}
@ -7020,13 +7023,9 @@ impl<'a> Iterator for MultiBufferRows<'a> {
buffer_id: Some(region.buffer.remote_id()),
buffer_row: Some(buffer_point.row),
multibuffer_row: Some(MultiBufferRow(self.point.row)),
diff_status: if region.is_inserted_hunk && self.point < region.range.end {
Some(DiffHunkStatus::Added)
} else if !region.is_main_buffer {
Some(DiffHunkStatus::Removed)
} else {
None
},
diff_status: region
.diff_hunk_status
.filter(|_| self.point < region.range.end),
});
self.point += Point::new(1, 0);
result
@ -7194,7 +7193,7 @@ impl<'a> Iterator for MultiBufferChunks<'a> {
}
chunks
} else {
let base_buffer = &self.diffs.get(&buffer_id)?.base_text.as_ref()?;
let base_buffer = &self.diffs.get(&buffer_id)?.base_text()?;
base_buffer.chunks(base_text_start..base_text_end, self.language_aware)
};